Planet Python

Last update: April 03, 2026 09:43 PM UTC

April 03, 2026

Real Python

Quiz: How to Add Features to a Python Project With Codex CLI

In this quiz, you’ll test your understanding of How to Add Features to a Python Project With Codex CLI.

By working through this quiz, you’ll revisit how to install, configure, and use Codex CLI to implement and refine features in a Python project using natural language prompts.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

April 03, 2026 12:00 PM UTC

Quiz: Class Concepts: Object-Oriented Programming in Python

In this quiz, you’ll test your understanding of Class Concepts: Object-Oriented Programming in Python.

By working through this quiz, you’ll revisit how to define classes, use instance and class attributes, write different types of methods, and apply the descriptor protocol through properties.

You can also deepen your knowledge with the tutorial Python Classes: The Power of Object-Oriented Programming.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

April 03, 2026 12:00 PM UTC

Rodrigo Girão Serrão

Indexable iterables

Learn how objects are automatically iterable if you implement integer indexing.

Introduction

An iterable in Python is any object you can traverse through with a for loop. Iterables are typically containers and iterating over the iterable object allows you to access the elements of the container.

This article will show you how you can create your own iterable objects through the implementation of integer indexing.

Indexing with __getitem__

To make an object that can be indexed you need to implement the method __getitem__.

As an example, you'll implement a class ArithmeticSequence that represents an arithmetic sequence, like \(5, 8, 11, 14, 17, 20\). An arithmetic sequence is defined by its first number (\(5\)), the step between numbers (\(3\)), and the total number of elements (\(6\)). The sequence \(5, 8, 11, 14, 17, 20\) is seq = ArithmeticSequence(5, 3, 6) and seq[3] should be \(14\). Using some arithmetic, you can implement indexing in __getitem__ directly:

class ArithmeticSequence:
    def __init__(self, start: int, step: int, total: int) -> None:
        self.start = start
        self.step = step
        self.total = total

    def __getitem__(self, index: int) -> int:
        if not 0 <= index < self.total:
            raise IndexError(f"Invalid index {index}.")

        return self.start + index * self.step

seq = ArithmeticSequence(5, 3, 6)
print(seq[3])  # 14

Turning an indexable object into an iterable

If your object accepts integer indices, then it is automatically an iterable. In fact, you can already iterate over the sequence you created above by simply using it in a for loop:

for value in seq:
    print(value, end=", ")
# 5, 8, 11, 14, 17, 20,

How Python distinguishes iterables from non-iterables

You might ask yourself “how does Python inspect __getitem__ to see it uses numeric indices?” It doesn't! If your object implements __getitem__ and you try to use it as an iterable, Python will try to iterate over it. It either works or it doesn't!

To illustrate this point, you can define a class DictWrapper that wraps a dictionary and implements __getitem__ by just grabbing the corresponding item out of a dictionary:

class DictWrapper:
    def __init__(self, values):
        self.values = values

    def __getitem__(self, index):
        return self.values[index]

Since DictWrapper implements __getitem__, if an instance of DictWrapper just happens to have some integer keys (starting at 0) then you'll be able to iterate partially over the dictionary:

d1 = DictWrapper({0: "hey", 1: "bye", "key": "value"})

for value in d1:
    print(value)

hey
bye
Traceback (most recent call last):
  File "<python-input-25>", line 3, in <module>
    for value in d1:
                 ^^
  File "<python-input-18>", line 6, in __getitem__
    return self.values[index]
           ~~~~~~~~~~~^^^^^^^
KeyError: 2

What's interesting is that you can see explicitly that Python tried to index the object d with the key 2 and it didn't work. In the ArithmeticSequence above, you didn't get an error because you raised IndexError when you reached the end and that's how Python understood the iteration was done. In this case, since you get a KeyError, Python doesn't understand what's going on and just...

April 03, 2026 11:41 AM UTC

Talk Python Blog

Announcing Course Completion Certificates

I’m very excited to share that you can now generate course completion certificates automatically at Talk Python Training. What’s even better is our certificates allow you to one-click add them as official licenses and certifications on LinkedIn.

Remember last week, I added some really nice features to your account page showing which courses are completed and which ones you’ve recently participated in. Just start there. Find a course you recently completed, click certificate, and there is a Share to LinkedIn UI right there. It’s nearly entirely automated.

April 03, 2026 02:39 AM UTC

ListenData

How to Build ChatGPT Clone in Python

In this article, we will see the steps involved in building a chat application and an answering bot in Python using the ChatGPT API and gradio.

Developing a chat application in Python provides more control and flexibility over the ChatGPT website. You can customize and extend the chat application as per your needs. It also help you to integrate with your existing systems and other APIs.

April 03, 2026 12:42 AM UTC

How to Use Gemini API in Python

In this tutorial, you will learn how to use Google's Gemini AI model through its API in Python.

Follow the steps below to access the Gemini API and then use it in python.

1. Visit Google AI Studio website.
2. Sign in using your Google account.
3. Create an API key.
4. Install the Google AI Python library for the Gemini API using the command below :
   

   pip install google-genai

   .

April 03, 2026 12:40 AM UTC

How to Use Web Search in ChatGPT API

In this tutorial, we will explore how to use web search in OpenAI API.

Installation Step : Please make sure to install the openai library using the command - pip install openai.

from openai import OpenAI
client = OpenAI(api_key="sk-xxxxxxxxx") # Replace with your actual API key

response = client.responses.create(
    model="gpt-5.4",
    tools=[{"type": "web_search_preview"}],
    input="Apple (AAPL) most recent stock price"
)

print(response.output_text)

As of the latest available data (April 2, 2026), Apple Inc. (AAPL) stock is trading at $255.92 per share, reflecting an increase of $0.29 (approximately 0.11%) from the previous close.

In the openai latest models, the search_context_size setting controls how much information the tool gathers from the web to answer your question. A higher setting gives better answers but is slower and costs more while a lower setting is faster and cheaper but might not be as accurate. Possible values are high, medium or low.

from openai import OpenAI
client = OpenAI(api_key="sk-xxxxxxxxx") # Replace with your actual API key

response = client.responses.create(
    model="gpt-5.4",
    tools=[{
        "type": "web_search_preview",
        "search_context_size": "high",
    }],
    input="Which team won the latest FIFA World Cup?"
)

print(response.output_text)

You can improve the relevance of search results by providing approximate geographic details such as country, city, region or timezone. For example, use a two-letter country code like GB for the United Kingdom or free-form text for cities and regions like London. You may also specify the user's timezone using IANA format such as Europe/London.

from openai import OpenAI
client = OpenAI(api_key="sk-xxxxxxxxx")  # Use your actual API key

response = client.responses.create(
    model="gpt-5.4",
    tools=[{
        "type": "web_search_preview",
        "user_location": {
            "type": "approximate",
            "country": "GB",        # ISO 2-letter country code
            "city": "London",       # Free text for city
            "region": "London",     # Free text for region/state
            "timezone": "Europe/London"  # IANA timezone (optional)
        }
    }],
    input="What are the top-rated places to eat near Buckingham Palace?",
)

print(response.output_text)

You can use the following code to get the URL, title and location of the cited sources.

# Citations
response = client.responses.create(
    model="gpt-5.4",
    tools=[{"type": "web_search_preview"}],
    input="most recent news from New York?"
)

annotations = response.output[1].content[0].annotations
print("Annotations:", annotations)
print("Annotations List:")
print("-" * 80)
for i, annotation in enumerate(annotations, 1):
    print(f"Annotation {i}:")
    print(f"  Title: {annotation.title}")
    print(f"  URL: {annotation.url}")
    print(f"  Type: {annotation.type}")
    print(f"  Start Index: {annotation.start_index}")
    print(f"  End Index: {annotation.end_index}")
    print("-" * 80)

Alternative method to use web search is by integrating Google's Custom Search API with ChatGPT.

By using Google's Custom Search API, we can get real-time search results. Refer the steps below how to get an API key from the Google Developers Console and creating a custom search engine.

April 03, 2026 12:38 AM UTC

4 Ways to Use ChatGPT API in Python

In this tutorial, we will explain how to use ChatGPT API in Python, along with examples.

Please follow the steps below to access the ChatGPT API.

1. Visit the OpenAI Platform and sign up using your Google, Microsoft or Apple account.
2. After creating your account, the next step is to generate a secret API key to access the API. The API key looks like this -sk-xxxxxxxxxxxxxxxxxxxx
3. If your phone number has not been associated with any other OpenAI account previously, you may get free credits to test the API. Otherwise you have to add atleast 5 dollars into your account and charges will be based on the usage and the type of model you use. Check out the pricing details in the OpenAI website.
4. Now you can call the API using the code below.

April 03, 2026 12:25 AM UTC

April 02, 2026

death and gravity

reader 3.22 released – new web app

Hi there!

I'm happy to announce version 3.22 of reader, a Python feed reader library.

What's new? #

Here are the highlights since reader 3.20.

New feed reader web app #

The new web application is done! Features include:

• add / list / filter / delete feeds
• list / filter articles
• mark articles as read / (un)important
• article view
• custom feed titles
• dark mode

In the next releases, I'll be adding back features already present in the legacy web app, stuff like full-text search, tags, read time, MP3 tag fixing, and more.

This is building towards a hosted version of reader, which should take the pain out of self-hosting, while still leaving it as an option; more to follow soon™. (Meanwhile, if this sounds like something you'd like to use, get in touch.)

For now, here are some screenshots:

main page (dark mode)

more filters (light mode)

feed page (dark mode)

feeds page (dark mode)

article view (light mode)

article view (dark mode)

Config and plugin loading #

Part of the hosted reader work, I've unified how configuration and plugins are loaded across make_reader(), the command-line interface, and the web app, by using Click to parse and validate configuration (it's not as wrong as it sounds, I promise).

As a consequence, the config file format changed from YAML to TOML and follows the shape of the CLI, and a few commands and environment variables were renamed; no other breaking changes are expected in the foreseeable future.

Scheduled updates by default #

Both update_feeds() and the CLI now limit how often feeds get updated by default; while this is a minor compatibility break, the previous behavior was arguably a bug – doing the right thing should not be opt-in.

Also, reader now honors the Cache-Control max-age and Expires HTTP headers when updating feeds, in addition to Retry-After.

AI contributions #

Finally, reader now has an AI contributions policy; tl;dr: they are banned, for now.

The reasoning is two-fold. First, after a few low-effort contributions, I decided I don't have time for this. Second, there are various issues surrounding LLMs I don't want to bother with; for more details, see the Servo, CPython, and LLVM policies.

I am open to revisiting this later (I'll do so on my own, though, thank you).

That's it for now. For more details, see the full changelog.

Want to contribute? Check out the docs and the roadmap.

Learned something new today? Share it with others, it really helps! PyCoder's Weekly HN Bluesky linkedin Twitter

What is reader? #

reader takes care of the core functionality required by a feed reader, so you can focus on what makes yours different.

reader allows you to:

• retrieve, store, and manage Atom, RSS, and JSON feeds
• mark articles as read or important
• add arbitrary tags/metadata to feeds and articles
• filter feeds and articles
• full-text search articles
• get statistics on feed and user activity
• write plugins to extend its functionality

...all these with:

• a stable, clearly documented API
• excellent test coverage
• fully typed Python

To find out more, check out the GitHub repo and the docs, or give the tutorial a try.

Why use a feed reader library? #

Have you been unhappy with existing feed readers and wanted to make your own, but:

• never knew where to start?
• it seemed like too much work?
• you don't like writing backend code?

Are you already working with feedparser, but:

• want an easier way to store, filter, sort and search feeds and entries?
• want to get back type-annotated objects instead of dicts?
• want to restrict or deny file-system access?
• want to change the way feeds are retrieved by using Requests?
• want to also support JSON Feed?
• want to support custom information sources?

... while still supporting all the feed types feedparser does?

If you answered yes to any of the above, reader can help.

The reader philosophy #

• reader is a library
• reader is for the long term
• reader is extensible
• reader is stable (within reason)
• reader is simple to use; API matters
• reader features work well together
• reader is tested
• reader is documented
• reader has minimal dependencies

April 02, 2026 04:44 PM UTC

Mike Driscoll

Python Pop Quiz – Number Explosion

You will sometimes come across examples of code that use one or two asterisks. Depending on how the asterisks are used, they can mean different things to Python.

Check your understanding of what a single asterisk means in the following quiz!

What will be the output if you run this code?

numbers = range(3)
output = {*numbers}
print(output)

A) {range}

B) (range)

C) [0, 1, 2]

D) (0, 1, 2)

E) {0, 1, 2}

“Unpacking generalizations” is the term to look up if you get stuck..

E) {0, 1, 2}

A single asterisk before a Python dictionary or list is known as the unpacking operator. In this example, you tell Python to unpack three integers (0 – 2) into a set.

Here is the example running in a REPL:

>>> numbers = range(3)
>>> output = {*numbers}
>>> print(output)
{0, 1, 2}
>>> print(type(output))
<class 'set'>

The code output shows that you have created a set!

You can also use a single asterisk to unpack a dictionary’s keys:

>>> my_dict = {1: "one", 2: "two", 3: "three"}
>>> print({*my_dict})
{1, 2, 3}

If you want to take your knowledge of unpacking further, it can help to see Python functions use asterisks:

>>> def my_func(*args):
...     print(args)
... 
>>> my_func(1)
(1,)
>>> numbers = range(3)
>>> output = {*numbers}
>>> my_func(output)
({0, 1, 2},)
>>> my_func(*output)
(0, 1, 2)

When you see a single asterisk in a function definition, the asterisk means that the function can take an unlimited number of arguments. In the second example, you pass in the set as a single argument, while in the last example, you use a single asterisk to unpack the numbers and pass them in as three separate arguments.

For more information, see PEP 448 – Additional Unpacking Generalizations, which has many more examples!

Get the Book

Want to try out over one HUNDRED more quizzes? Check out the book!

Purchase at Gumroad or Leanpub or Amazon

The post Python Pop Quiz – Number Explosion appeared first on Mouse Vs Python.

April 02, 2026 12:29 PM UTC

Real Python

Quiz: Python's Counter: The Pythonic Way to Count Objects

In this quiz, you’ll test your understanding of Python’s Counter: The Pythonic Way to Count Objects.

By working through this quiz, you’ll revisit how to create Counter objects, update counts, find most common elements, and use counters as multisets with arithmetic operations.

This quiz covers practical Counter tasks such as constructing counters from different data types, accessing counts, and working with multiset operations. If you want a deeper walkthrough, review the tutorial linked above.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

April 02, 2026 12:00 PM UTC

Graham Dumpleton

Free Python decorator workshops

I've been working on a set of interactive workshops on Python decorators and they are now available for free on the labs page of this site. There are 22 workshops in total, covering everything from the fundamentals of how decorators work through to advanced topics like the descriptor protocol, async decorators and metaclasses. The workshops are hosted on the Educates training platform and accessed through the browser, so there is nothing to install.

An experiment in learning

We are well into the age of AI at this point. Need to know how to write a decorator in Python? Just ask ChatGPT or Claude and you will get an answer in seconds. Want to refactor some code to use decorators? Let an AI agent do it for you. The tools are genuinely impressive and I use them myself every day.

That said, as someone who spent years as a developer advocate helping people learn, the question that keeps coming up is whether there is still an appetite for actually learning how things work. Not just getting an answer, but understanding why the answer is what it is. Understanding the mechanics well enough that when the AI gives you something subtly wrong (and it will), you can spot it and fix it yourself.

These workshops are my experiment in finding out. If people are still interested in sitting down with a guided, hands-on environment and working through a topic step by step, then this format has a future. If not, it will at least help me work out whether developer advocacy even matters anymore, and whether the years I have put into building the Educates platform have been worth the effort.

What the workshops cover

The Python Decorators course starts from the ground up. The early workshops cover functions as first-class objects, closures, and the basic mechanics of how decorators work. From there the core path builds through decorator arguments, functools.wraps, stacking decorators, and class-based decorators.

Branching off from the core path are a set of elective workshops covering practical applications: input validation, caching and memoisation, access control, registration and plugin patterns, exception handling, deprecation warnings, and profiling. These are the kinds of things you would actually use decorators for in real projects.

The later workshops go deeper into territory that most tutorials skip over entirely. The descriptor protocol, how decorators interact with classes and inheritance, async decorators, class decoration, and metaclasses.

The aim here is to go well beyond the basics. There are plenty of introductory decorator tutorials out there already. What I wanted to create was something for people who want to genuinely broaden their Python knowledge and understand how the language works at a deeper level. If you have not completely given in to letting AI do all the thinking for you and still want to build real expertise, these workshops are for you.

If you have never experienced interactive online workshops like this before, I would recommend doing the Educates Walkthrough workshop first. It will get you familiar with how the platform works, how to navigate the workshop instructions, and how to use the integrated terminal and editor, before you jump into the Python content.

Keeping the workshops running

The system hosting the workshops has limited resources and capacity. I am running this on modest infrastructure and I am honestly not sure how long I will be able to keep it going. It depends in part on how much interest there is, and in part on whether I can sustain any hosting costs.

The system is also engineered to only let a limited number of people in at a time, so if you get a message about being at capacity, try again later. I will be monitoring how things hold up and if possible will increase the limits.

If you try the workshops and find them useful, it would mean a lot if you considered helping out through my GitHub Sponsors page. Even small contributions add up and would help keep the workshops available. If there is enough interest and support, I could move to a more capable hosting environment and handle more concurrent users. Right now capacity is limited and I am just seeing how things go.

What comes next

If things go well and there is demand for more, I have plans for additional workshop courses. The natural successor to the Python decorators course would be one built around my wrapt library, covering both its decorator utilities and its monkey patching features. After that I would look at WSGI and Python web hosting, which is another area where I have deep experience from years of working on mod_wsgi.

The common thread is topics that go into real depth. There is no shortage of surface-level content on the internet (and AI can generate more of it on demand). What I think is harder to find is material that takes a topic seriously, works through the edge cases, and gives you a genuine understanding of what is happening under the hood. That is what I am trying to provide.

A note on how these were made

I should be transparent about this: the workshops were created with the assistance of AI. I wrote about the process in some detail back in February, covering the approach to using AI for content, how I taught an AI about the Educates platform, and how I used AI to review the workshops.

I realise there is a certain irony in using AI to create workshops that are partly motivated by the belief that people should still learn things themselves. But I see a difference between using AI as a tool to help produce quality educational content and blindly publishing whatever an AI generates. Every workshop has been reviewed, tested, and refined based on my own knowledge and experience with Python decorators going back over a decade. Hopefully the result is something genuinely useful rather than AI slop. And hopefully the use of the Educates platform itself contributes to the experience, letting people focus on actually learning rather than spending time trying to get their own computer environment set up correctly. I hope people will judge the workshops on their quality rather than dismissing them because AI was involved in making them.

Head over to the labs page to get started. I would love to hear what you think.

April 02, 2026 04:38 AM UTC

Python Engineering at Microsoft

Python in Visual Studio Code – March 2026 Release

We’re excited to announce that the March 2026 release of the Python extension for Visual Studio Code are now available!

This release includes the following announcements:

• Search Python Symbols in Installed Packages
• Experimental: Rust-Based Parallel Indexer

If you’re interested, you can check the full list of improvements in our changelogs for the Python, and Pylance extensions.

Search Python Symbols in Installed Packages

When working in a new codebase or exploring an unfamiliar library, one of the most common needs is quickly locating where a function or class is defined — even if it lives outside your workspace. With this release, Pylance can now include symbols from packages installed in your active virtual environment in Workspace Symbol search (Cmd/Ctrl+T).

This is controlled by a new setting:

Python › Analysis: Include Venv In Workspace Symbols

When enabled:

• Workspace Symbol search surfaces symbols from packages in your active virtual environment’s site-packages
• You can navigate into third-party libraries without leaving VS Code or reaching for external documentation
• For libraries without py.typed, only symbols exported via __init__.py or __all__ are included, keeping results focused and relevant

Because indexing installed packages can affect performance, this feature is opt-in by design. You can fine-tune the depth of indexing per-package using Python › Analysis: Package Index Depths, which controls how deeply Pylance searches into sub-modules.

This gives you richer code exploration when you need it, without changing the default experience for everyone else.

To try it:

1. Open Settings (Cmd+, / Ctrl+,)
2. Search for “Include Venv In Workspace Symbols”
3. Check the box under Python › Analysis

Experimental: Rust-Based Parallel Indexer

We’re shipping an experimental setting that switches Pylance’s indexer — the engine behind completions, auto-imports, and workspace symbol search — to a new Rust-based parallel implementation that runs out-of-process.

In our testing, this indexer is on average 10× faster on large Python projects, which means faster completions after workspace open and a more responsive IntelliSense experience overall.

Python › Analysis: Enable Parallel Indexing

This is intentionally experimental. We want to validate the performance gains and reliability across the wide variety of project setups and environments our users have before making it the default.

To try it:

1. Open Settings (Cmd+, / Ctrl+,)
2. Search for “Parallel Indexing”
3. Check Enable Parallel Indexing (Experimental) under Python › Analysis

Or add this to your settings.json:

"python.analysis.enableParallelIndexing": true

After enabling, reload VS Code (Cmd/Ctrl+Shift+P → Reload Window) to ensure the new indexer starts cleanly. This setting has the most impact on larger projects — small projects may see little difference.

We want your feedback. If you try it and notice faster completions, slower behavior, or anything unexpected, please let us know by filing an issue on the Pylance GitHub repo. Your real-world reports are what will help us get this to stable.

This is an experimental feature. If you run into issues, you can disable it at any time by unchecking the setting.

Python Environments extension

• Various bug fixes in the Python Environments extension for env file notifications and environment manager selection priority:
• The workspace’s saved interpreter selection now takes precedence over terminal-activated virtual or conda environments across restarts.
• The env file change notification now includes a “Don’t Show Again” option to permanently dismiss it. vscode-python#25867, vscode-python-environments#1347, vscode-python-environments#1393
• The Python Environments extension now recommends the community Pixi extension when Pixi environments are detected, and includes Pixi in the environment manager priority order. vscode-python-environments#1291

Try out these new improvements by downloading the Python extension and the Pylance extension from the Marketplace, or install them directly from the extensions view in Visual Studio Code (Ctrl + Shift + X or ⌘ + ⇧ + X). You can learn more about Python support in Visual Studio Code in the documentation. If you run into any problems or have suggestions, please file an issue on the Python VS Code GitHub page.

The post Python in Visual Studio Code – March 2026 Release appeared first on Microsoft for Python Developers Blog.

April 02, 2026 12:27 AM UTC

April 01, 2026

Talk Python to Me

#543: Deep Agents: LangChain's SDK for Agents That Plan and Delegate

When you type a question into ChatGPT, the model only has what you typed to work with. But tools like Claude Code can plan, iterate, test, and recover from mistakes. They work more like we do. The difference is the agent harness: Planning tools, file system access, sub-agents, and carefully crafted system prompts that turn a raw LLM into something genuinely capable. <br/> <br/> Sydney Runkle is back on Talk Python representing LangChain and their new open source library, Deep Agents: A framework for building your own deep agents with plain Python functions, middleware hooks, and MCP support. This is how the magic works under the hood.<br/> <br/> <strong>Episode sponsors</strong><br/> <br/> <a href='https://talkpython.fm/sentry'>Sentry Error Monitoring, Code talkpython26</a><br> <a href='https://talkpython.fm/temporal'>Temporal</a><br> <a href='https://talkpython.fm/training'>Talk Python Courses</a><br/> <br/> <h2 class="links-heading mb-4">Links from the show</h2> <div><strong>Guest</strong><br/> <strong>Sydney Runkle</strong>: <a href="https://github.com/sydney-runkle?featured_on=talkpython" target="_blank" >github.com</a><br/> <br/> <strong>Claude Code uses</strong>: <a href="https://x.com/alexalbert__/status/1948765443776544885?ref=blog.langchain.com&amp;featured_on=talkpython" target="_blank" >x.com</a><br/> <strong>Deep Research</strong>: <a href="https://openai.com/index/introducing-deep-research/?ref=blog.langchain.com&amp;featured_on=talkpython" target="_blank" >openai.com</a><br/> <strong>Manus</strong>: <a href="https://manus.im/?ref=blog.langchain.com&amp;featured_on=talkpython" target="_blank" >manus.im</a><br/> <strong>Blog post announcement</strong>: <a href="https://blog.langchain.com/deep-agents/?featured_on=talkpython" target="_blank" >blog.langchain.com</a><br/> <strong>Claudes system prompt</strong>: <a href="https://github.com/kn1026/cc/blob/main/claudecode.md?ref=blog.langchain.com&amp;featured_on=talkpython" target="_blank" >github.com</a><br/> <strong>sub agents</strong>: <a href="https://docs.anthropic.com/en/docs/claude-code/sub-agents?ref=blog.langchain.com&amp;featured_on=talkpython" target="_blank" >docs.anthropic.com</a><br/> <strong>the quick start</strong>: <a href="https://docs.langchain.com/oss/python/deepagents/quickstart?featured_on=talkpython" target="_blank" >docs.langchain.com</a><br/> <strong>CLIs</strong>: <a href="https://github.com/langchain-ai/deepagents?tab=readme-ov-file#deep-agents-cli" target="_blank" >github.com</a><br/> <strong>Talk Python's CLI</strong>: <a href="https://talkpython.fm/blog/posts/talk-python-now-has-a-cli/" target="_blank" >talkpython.fm</a><br/> <strong>custom tools</strong>: <a href="https://docs.langchain.com/oss/python/deepagents/overview#create-a-deep-agent" target="_blank" >docs.langchain.com</a><br/> <strong>DeepAgents Examples</strong>: <a href="https://github.com/langchain-ai/deepagents/tree/main/examples?featured_on=talkpython" target="_blank" >github.com</a><br/> <strong>Custom Middleware</strong>: <a href="https://docs.langchain.com/langsmith/custom-middleware#how-to-add-custom-middleware" target="_blank" >docs.langchain.com</a><br/> <strong>Built in middleware</strong>: <a href="https://docs.langchain.com/oss/python/deepagents/customization#middleware" target="_blank" >docs.langchain.com</a><br/> <strong>Improving Deep Agents with harness engineering</strong>: <a href="https://blog.langchain.com/improving-deep-agents-with-harness-engineering/?featured_on=talkpython" target="_blank" >blog.langchain.com</a><br/> <strong>Prebuilt middleware</strong>: <a href="https://docs.langchain.com/oss/python/langchain/middleware/built-in?featured_on=talkpython" target="_blank" >docs.langchain.com</a><br/> <br/> <strong>Watch this episode on YouTube</strong>: <a href="https://www.youtube.com/watch?v=NRwA-fBNZZ4" target="_blank" >youtube.com</a><br/> <strong>Episode #543 deep-dive</strong>: <a href="https://talkpython.fm/episodes/show/543/deep-agents-langchains-sdk-for-agents-that-plan-and-delegate#takeaways-anchor" target="_blank" >talkpython.fm/543</a><br/> <strong>Episode transcripts</strong>: <a href="https://talkpython.fm/episodes/transcript/543/deep-agents-langchains-sdk-for-agents-that-plan-and-delegate" target="_blank" >talkpython.fm</a><br/> <br/> <strong>Theme Song: Developer Rap</strong><br/> <strong>🥁 Served in a Flask 🎸</strong>: <a href="https://talkpython.fm/flasksong" target="_blank" >talkpython.fm/flasksong</a><br/> <br/> <strong>---== Don't be a stranger ==---</strong><br/> <strong>YouTube</strong>: <a href="https://talkpython.fm/youtube" target="_blank" ><i class="fa-brands fa-youtube"></i> youtube.com/@talkpython</a><br/> <br/> <strong>Bluesky</strong>: <a href="https://bsky.app/profile/talkpython.fm" target="_blank" >@talkpython.fm</a><br/> <strong>Mastodon</strong>: <a href="https://fosstodon.org/web/@talkpython" target="_blank" ><i class="fa-brands fa-mastodon"></i> @talkpython@fosstodon.org</a><br/> <strong>X.com</strong>: <a href="https://x.com/talkpython" target="_blank" ><i class="fa-brands fa-twitter"></i> @talkpython</a><br/> <br/> <strong>Michael on Bluesky</strong>: <a href="https://bsky.app/profile/mkennedy.codes?featured_on=talkpython" target="_blank" >@mkennedy.codes</a><br/> <strong>Michael on Mastodon</strong>: <a href="https://fosstodon.org/web/@mkennedy" target="_blank" ><i class="fa-brands fa-mastodon"></i> @mkennedy@fosstodon.org</a><br/> <strong>Michael on X.com</strong>: <a href="https://x.com/mkennedy?featured_on=talkpython" target="_blank" ><i class="fa-brands fa-twitter"></i> @mkennedy</a><br/></div>

April 01, 2026 05:20 PM UTC

"Michael Kennedy's Thoughts on Technology"

Cutting Python Web App Memory Over 31%

tl;dr; I cut 3.2 GB of memory usage from our Python web apps using five techniques: async workers, import isolation, the Raw+DC database pattern, local imports for heavy libraries, and disk-based caching. Here are the exact before-and-after numbers for each optimization.

Over the past few weeks, I’ve been ruthlessly focused on reducing memory usage on my web apps, APIs, and daemons. I’ve been following the one big server pattern for deploying all the Talk Python web apps, APIs, background services, and supporting infrastructure.

There are a ridiculous number of containers running to make everything go around here at Talk Python (23 apps, APIs, and database servers in total).

Even with that many apps running, the actual server CPU load is quite low. But memory usage is creeping up. The server was running at 65% memory usage on a 16GB server. While that may be fine - the server’s not that expensive - I decided to take some time and see if there were some code level optimizations available.

What I learned was interesting and much of it was a surprise to me. So, I thought I’d share it here with you. I was able to drop the memory usage by 3.2GB basically for free just by changing some settings, changing how I import packages in Python, and proper use of offloading some caching to disk.

How much memory were the Python apps using before optimization?

For this blog post, I’m going to focus on just two applications. However, I applied this to most of the apps that we own the source code for (as opposed to Umami, etc). Take these as concrete examples more than the entire use case.

Here are the initial stats we’ll be improving on along the way.

How async workers and Quart cut Python web app memory in half

I knew that starting with a core architectural change in how we run our apps and access our database would have huge implications. You see, we’re running our web apps as a web garden, one orchestrator, multiple worker processes via the lovely Granian.

I’ve wanted to migrate our remaining web applications to some fully asynchronous application framework. See Talk Python rewritten in Quart (async Flask) for a detailed discussion on this topic. If we have a truly async-capable application server (Granian) and a truly async web framework (Quart), then we can change our deployment style to one worker running fully asynchronous code. Much less blocking code means a single worker is more responsive now. Thus we can work with a single worker instance.

This one change alone would cut the memory usage nearly in half. To facilitate this, we needed two actions:

Action 1: Rewrite Talk Python Training in Quart

The first thing I had to do was rewrite Talk Python Training, the app I was mostly focused on at the time, in Quart. This was a lot of work. You might not know it from the outside, but Talk Python Training is a significant application.

178,000 lines of code! Rewriting this from the older framework, Pyramid, to async Flask (aka Quart), was a lot of work, but I pulled it off last week.

Action 2: Rewrite data access to raw + dc design pattern

Data access was based on MongoEngine, a barely maintained older database ODM for talking to MongoDB, which does not support async code and never will support async code. Even though we have Quart as a runtime option, we hardly can do anything async without the data access layer.

So I spent some time removing MongoEngine and implementing the Raw + DC design pattern. That saved us a ton of memory, facilitated writing async queries, and almost doubled our requests per second.

I actually wrote this up in isolation here with some nice graphs: Raw+DC Database Pattern: A Retrospective. Switching from a formalized ODM to raw database queries along with data classes with slots saved us 100 MB per worker process, or in this case, 200 MB of working memory. Given that it also sped up the app significantly, that’s a serious win.

How switching to a single async Granian worker saved 542 MB

Now that our web app runs asynchronously and our database queries fully support it, we could trim our web garden down to a single, fully asynchronous worker process using Granian. When every request is run in a blocking mode, one worker not ideal. But now the requests all interleave using Python concurrency.

This brought things down to a whopping 536 MB in total (a savings of 542 MB!) I could have stopped there, and things would have been excellent compared to where we were before, but I wanted to see what else was a possibility.

How isolating Python imports in a subprocess cut memory from 708 MB to 22 MB

The next biggest problem was that the Talk Python Training search indexer. It reads literally everything from the many gigabyte database backing Talk Python Training, indexes it, and stores it into a custom data structure that we use for our ultra-fast search. It was running at 708 MB in its own container.

Surely, this could be more efficient.

And boy, was it. There were two main takeaways here. I noticed first that even if no indexing ran, just at startup, this process was using almost 200 megabytes of memory. Why? Import chains.

The short version is it was importing almost all of the files of Talk Python Training and their in third-party dependencies because that was just the easiest way to write the code and because of PEP 8. When the app starts, it imports a few utilities from Talk Python Training. That, in turn, pulls in the entire mega application plus all of the dependencies that the application itself is using, bloating the memory way, way up.

All this little daemon needs to do is every few hours re-index the site. It sits there, does nothing in particular related to our app, loops around, waits for exit commands from Docker, and if enough time has elapsed, then it runs the search process with our code.

We could move all of that search indexing code into a subprocess. And only that subprocess’s code actually imports anything of significance. When the search index has to run, that process kicks off for maybe 30 seconds, builds the index, uses a bunch of memory, but once the indexing is done, it shuts down and even the imports are unloaded.

What was the change? Amazing. The search indexer went from 708 MB to just 22 MB! All we had to do was isolate imports into its own separate file and then run that separately using a Python subprocess. That’s it, 32x less memory used.

How much memory do Python imports like boto3, pandas, and matplotlib use?

When we write simple code such as import boto3 it looks like no big deal. You’re just telling Python you need to use this library. But as I hinted at above, what it actually does is load up that library in total, and any static data or singleton-style data is created, as well as transitive dependencies for that library.

Unbeknownst to me, boto3 takes a ton of memory.

Yet for our application, these are very rarely used. Maybe we need to upload a file to blob storage using boto3, or use matplotlib and pandas to generate some report that we rarely run.

By moving these to be local imports, we are able to save a ton of memory. What do I mean by that? Simply don’t follow PEP 8 here - instead of putting these at the top of your file, put them inside of the functions that use them, and they will only be imported if those functions are called.

def generate_usage_report():
  import matplotlib
  import pandas
  
  # Write code with these libs...

Now eventually, this generate_usage_report function probably will get called, but that’s where you go back to DevOps. We can simply set a time-to-live on the worker process. Granian will gracefully shut down the worker process and start a new one every six hours or once a day or whatever you choose.

PEP 810 – Explicit lazy imports

This makes me very excited for Python 3.15. That’s where the lazy imports feature will land. That should make this behavior entirely automatic without the need to jump through hoops.

How moving Python caches to diskcache reduced memory usage

Finally I addressed our caches. This was probably the smallest of the improvements, but still relevant. We had quite a few things that were small to medium-sized caches being kept in memory. For example, the site takes a fragment of markdown which is repeatedly used, and instead of regenerating it every time, we would stash the generated markdown and just return that from cache.

We moved most of this caching to diskcache. If you want to hear me and Vincent nerd out on how powerful this little library is, listen to the Talk Python episode diskcache: Your secret Python perf weapon.

Total memory savings: from 1,988 MB to 472 MB

So where are things today after applying these optimizations?

Applying these techniques and more to all of our web apps reduced our server load by 3.2 GB of memory. Memory is often the most expensive and scarce resource in production servers. This is a huge win for us.

April 01, 2026 03:52 PM UTC

Real Python

Python Classes: The Power of Object-Oriented Programming

Python classes are blueprints for creating objects that bundle data and behavior together. Using the class keyword, you define attributes to store state and methods to implement behavior, then create as many instances as you need. Classes are the foundation of object-oriented programming (OOP) in Python and help you write organized, reusable, and maintainable code.

By the end of this tutorial, you’ll understand that:

• A Python class is a reusable blueprint that defines object attributes and methods.
• Instance attributes hold data unique to each object, while class attributes are shared across all instances.
• Python classes support single and multiple inheritance, enabling code reuse through class hierarchies.
• Abstract base classes (ABCs) define formal interfaces that subclasses must implement.
• Classes enable polymorphism, allowing you to use different object types interchangeably through shared interfaces.

To get the most out of this tutorial, you should be familiar with Python variables, data types, and functions. Some experience with object-oriented programming (OOP) is a plus, but you’ll cover all the key concepts you need here.

Get Your Code: Click here to download your free sample code that shows you how to build powerful object blueprints with classes in Python.

Take the Quiz: Test your knowledge with our interactive “Python Classes - The Power of Object-Oriented Programming” quiz. You’ll receive a score upon completion to help you track your learning progress:

---

Interactive Quiz

Python Classes - The Power of Object-Oriented Programming

In this quiz, you'll test your understanding of Python classes, including attributes, methods, inheritance, and object-oriented programming concepts.

Getting Started With Python Classes

Python is a multiparadigm programming language that supports object-oriented programming (OOP) through classes that you can define with the class keyword. You can think of a class as a piece of code that specifies the data and behavior that represent and model a particular type of object.

What is a class in Python? A common analogy is that a class is like the blueprint for a house. You can use the blueprint to create several houses and even a complete neighborhood. Each concrete house is an object or instance that’s derived from the blueprint.

Each instance can have its own properties, such as color, owner, and interior design. These properties carry what’s commonly known as the object’s state. Instances can also have different behaviors, such as locking the doors and windows, opening the garage door, turning the lights on and off, watering the garden, and more.

In OOP, you commonly use the term attributes to refer to the properties or data associated with a specific object of a given class. In Python, attributes are variables defined inside a class with the purpose of storing all the required data for the class to work.

Similarly, you’ll use the term methods to refer to the different behaviors that objects will show. Methods are functions that you define within a class. These functions typically operate on or with the attributes of the underlying instance or class. Attributes and methods are collectively referred to as members of a class or object.

You can write classes to model the real world. These classes will help you better organize your code and solve complex programming problems.

For example, you can use classes to create objects that emulate people, animals, vehicles, books, buildings, cars, or other objects. You can also model virtual objects, such as a web server, directory tree, chatbot, file manager, and more.

Finally, you can use classes to build class hierarchies. This way, you’ll promote code reuse and remove repetition throughout your codebase.

In this tutorial, you’ll learn a lot about classes and all the cool things that you can do with them. To kick things off, you’ll start by defining your first class in Python. Then you’ll dive into other topics related to instances, attributes, and methods.

Defining a Class in Python

To define a class, you need to use the class keyword followed by the class name and a colon, just like you’d do for other compound statements in Python. Then you must define the class body, which will start at the next indentation level:

Python Syntax

class ClassName:
    <body>

In a class’s body, you can define attributes and methods as needed. As you already learned, attributes are variables that hold the class data, while methods are functions that provide behavior and typically act on the class data.

Note: In Python, the body of a given class works as a namespace where attributes and methods live. You can only access those attributes and methods through the class or its objects.

As an example of how to define attributes and methods, say that you need a Circle class to model different circles in a drawing application. Initially, your class will have a single attribute to hold the radius. It’ll also have a method to calculate the circle’s area:

Python circle.py

import math

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def calculate_area(self):
        return math.pi * self.radius ** 2

In this code snippet, you define Circle using the class keyword. Inside the class, you write two methods. The .__init__() method has a special meaning in Python classes. This method is known as the object initializer because it defines and sets the initial values for the object’s attributes. You’ll learn more about this method in the Instance Attributes section.

The second method of Circle is conveniently named .calculate_area() and will compute the area of a specific circle by using its radius. In this example, you’ve used the math module to access the pi constant as it’s defined in that module.

Read the full article at https://realpython.com/python-classes/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

April 01, 2026 02:00 PM UTC

Peter Bengtsson

pytest "import file mismatch"

Make sure your test files in a pytest tested project sit in directories with a __init__.py

April 01, 2026 01:20 PM UTC

Real Python

Quiz: Exploring Keywords in Python

In this quiz, you’ll test your understanding of Exploring Keywords in Python.

By working through this quiz, you’ll revisit how to identify Python keywords, understand the difference between regular and soft keywords, categorize keywords by purpose, and avoid common pitfalls with deprecated keywords.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

April 01, 2026 12:00 PM UTC

Tryton News

Tryton News April 2026

During the last month we focused on fixing bugs, improving the behaviour of things, speeding-up performance issues - building on the changes from our last release. We also added some new features which we would like to introduce to you in this newsletter.

For an in depth overview of the Tryton issues please take a look at our issue tracker or see the issues and merge requests filtered by label.

Changes for the User

Sales, Purchases and Projects

Now we add the support for the pick-up delivery method from Shopify.

We now add a number field to the project work efforts, based on a default sequence.

Now we use the party lang functionality to set the language for the taxes and and chats.

We now add support for gift card products on Shopify.

We now add a field that indicates if an invoice is sent via Peppol to help on filtering.

Now we unpublish products from the web-shops when they are deactivated.

We now allow the Peppol admin access group to create incoming documents.

Now we improve the address schema for web-shop usage and add attn to Party Addresses.

We now allow to copy the resources from sale rental to its invoices.

Now we move the Purchase Lines in its own tab on the Production form.

We now allow the manual method on sale.

Now the sale is always confirmed when a Shopify order has payment terms.

Accounting, Invoicing and Payments

Now we set the related-to field of an account statement line to invoice when the statement line overpays an invoice.

We now filter the MIME-type of the additional documents in UBL to the ones which are allowed by the specification.

Now we forbid a zero amount in draft state and also processing state for manual payments.

We now accrue and allocate rounding errors when using multiple taxes to calculate correct total amounts.

Now we allow cash-rounding with the opposite method.

We now add UNECE codes to Belgian taxes.

Now we
add the VAT exemption code on tax for electronic invoices in the EU.

We now add payment means to invoices to be used in UBL and UNCEFACT.

Now we add an optional account to the list of payable/receivable lines to be able to reconcile lines with the same accounts.

Stock, Production and Shipments

Now we implemented the management of ethanol in stock.

We now set the default locations when adding manually stock moves to production.

Now we add a reference field on quality inspections.

We now add a wizard to pack shipments.

Now we add the Stock Cancellation access group that allows to cancel shipments and productions in the states running or done.

User Interface

As a first step to add labels inside the widgets, we now add a generic management for the label style in form widgets.

Now we strip the user field from white-space characters in the login window.

We now add a new right drop-down menu in SAO, including Logout and Help menu items.

Now we add a visual hint on widgets of modified fields.

New Modules

We now support the common European requirements for excise products.

Now we add the sale_project_task module which creates tasks for services sold.

Now we add the account_payment_check module which manages and prints checks.

New Releases

We released bug fixes for the currently maintained long term support series 7.0 and 6.0, and for the penultimate series 7.8 and 7.6.

Security

Changes for the System Administrator

We now use cookies to store authentication informations in Sao.

Now we order the cron logs by descending ID to show the last cron-runs first.

Changes for Implementers and Developers

Now we allow to specify subdirectories in the tryton.cfg file and include them when activating a module.

We now replace the ShopifyAPI library by shopifyapp.

Now we add a contextual _log key to force the logging of events.

We now add notify_user to ModelStorage to store them in an efficient way at
the end of the transaction.

Now we add a deprecation warning when a new API version for Stripe is available.

We now show missing modules when running tests.

Now we remove the obsolete methods dump_values and load_values in ir.ModelData.

We now also check the button states when testing access.

Now we introduced the option model.fields.Binary.queue_for_removal which makes it possible to remove a file from the filestore on setting a binary field to None.

We now make the retrieval of metadata via documentation build very quiet.

Now we remove the default import of wizards in our cookicutter module
template.

Now we upgrade to Psycopg 3.

We now upgrade our setup to pyproject using hatchling as build-system.

Now we replace C3.js by its fork billboard.js as it seems better maintained.

We now remove the Sao dependency to bower.

Now we remove the internal name from the record name of the trytond.model.fields.

We now implement a recursive search for unused XML views in our tests.

Changes for Translators

Now the translation mechanism in Tryton does find the translations of type view.

2 posts - 2 participants

Read full topic

April 01, 2026 06:00 AM UTC

Python⇒Speed

Timesliced reservoir sampling: a new(?) algorithm for profilers

Imagine you are processing a stream of events, of unknown length. It could end in 3 seconds, it could run for 3 months; you simply don’t know. As a result, storing the whole stream in memory or even on disk is not acceptable, but you still need to extract relevant information.

Depending on what information you need, choosing a random sample of the stream will give you almost as good information as storing all the data. For example, consider a performance profiler, used to find which parts of your running code are slowest. Many profilers records a program’s callstack every few microseconds, resulting a stream of unlimited size: you don’t know how long the program will run. For this use case, a random sample of callstacks, say 2000 of them, can usually give you sufficient information to do performance optimization.

Why does this work?

• Slow code will result in the same callstack being repeated.
• A random sample of callstacks is more likely to contain callstacks that repeat a lot.
• Thus, a random sample is more likely to include slow code, the code you specifically want to identify with your profiler.

When you need to extract a random sample from a stream of unknown length, a common solution is the family of algorithms known as reservoir sampling. In this article you will learn:

• How basic reservoir sampling works.
• Some problems with reservoir sampling, motivated by a profiler that wants to generate a timeline.
• A (new?) variant of reservoir sampling that allows you to ensure samples are spread evenly across time.

April 01, 2026 12:00 AM UTC

March 31, 2026

PyCoder’s Weekly

Issue #728: Django With Alpine, Friendly Classes, SQLAlchemy, and More (March 31, 2026)

#728 – MARCH 31, 2026
View in Browser »

Right-Size Your Celery & RQ Workers

CPU doesn’t tell you if tasks are piling up. Queue latency does. Autoscale your workers based on the metric that matters →
JUDOSCALE sponsor

Articles & Tutorials

Dignified Python: 10 Rules to Improve your LLM Agents

At Dagster, we created “Dignified Python” to improve LLM-generated code by embedding clear coding principles into prompts. Instead of messy, pattern-based output, our agents produce code that reflects intent, consistency, and team standards. Here are the 10 rules from our Claude prompt →
DAGSTER LABS sponsor

Projects & Code

Events

Happy Pythoning!
This was PyCoder’s Weekly Issue #728.
View in Browser »

[ Subscribe to 🐍 PyCoder’s Weekly 💌 – Get the best Python news, articles, and tutorials delivered to your inbox once a week >> Click here to learn more ]

March 31, 2026 07:30 PM UTC

Real Python

Adding Python to PATH

You may need to add Python to PATH if you’ve installed Python, but typing python on the command line doesn’t seem to work. You might see a message saying that python isn’t recognized, or you might end up running the wrong version of Python.

A common fix for these problems is adding Python to the PATH environment variable. In this video course, you’ll learn how to add Python to PATH. You’ll also learn what PATH is and why it’s essential for tools like the command line to be able to find your Python installation.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

March 31, 2026 02:00 PM UTC

Quiz: Test-Driven Development With pytest

In this quiz, you’ll test your understanding of Test-Driven Development With pytest.

By working through this quiz, you’ll revisit creating and executing Python unit tests with pytest, practicing test-driven development, finding bugs before users, and checking code coverage.

Use this quiz to confirm what you learned and spot gaps to review. Return to the video course for hands-on examples and guidance.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

March 31, 2026 12:00 PM UTC

PyCon

Introducing the 8 Companies on Startup Row at PyCon US 2026

Each year at PyCon US, Startup Row highlights a select group of early-stage companies building ambitious products with Python at their core. The 2026 cohort reflects a rapidly evolving landscape, where advances in AI, data infrastructure, and developer tooling are reshaping how software is built, deployed, and secured.

This year’s companies aim to solve an evolving set of problems facing independent developers and large-scale organizations alike: securing AI-driven applications, managing multimodal data, orchestrating autonomous agents, automating complex workflows, and extracting insight from increasingly unstructured information. Across these domains, Python continues to serve as a unifying layer: encouraging experimentation, enabling systems built to scale, and connecting open-source innovation with real-world impact.

Startup Row brings these emerging teams into direct conversation with the Python community at PyCon US. Throughout the conference, attendees can meet founders, explore new tools, and see firsthand how these companies are applying Python to solve meaningful problems. For the startups in attendance, it’s an opportunity to share their work, connect with users and collaborators, and contribute back to the ecosystem that helped shape them. Register now to experience Startup Row and much more at PyCon US 2026.

CapiscIO

Chonkie

Pixeltable

Skyvern

SubImage

Tetrix

TimeCopilot

Thank You's and Acknowledgements

March 31, 2026 09:00 AM UTC

March 30, 2026

"Michael Kennedy's Thoughts on Technology"

Raw+DC Database Pattern: A Retrospective

TL;DR; After migrating three production Python web apps from MongoEngine to the Raw+DC database pattern, I measured nearly 2x the requests per second, 18% less memory, and gained native async support. Raw+DC delivered real-world performance gains, not just synthetic benchmarks.

About a month ago, I wrote about a new design pattern I’m seeing gain traction in the software space: Raw+DC: The ORM pattern of 2026. This article generated a lot of interest and a lot of debate. The short version: instead of using an ORM or ODM, you write raw database queries paired with Python dataclasses for type safety. This gives AI coding assistants a much larger training base to work from, reduces dependency risk, and delivers comparable or better performance.

Putting Raw+DC into practice

Now that some time has passed and I’ve thought about it more, I’ve had a chance to migrate three of my most important web apps to Raw+DC: Talk Python the podcast, Talk Python Courses, and Python Bytes.

So how did it go? From a pure functionality perspective, it went great. There were maybe one to three problems per web app. This might not sound great, and I didn’t love it, but given this is thousands and thousands of lines of code per app, that’s a small percentage of issues, given how many things went right.

More importantly, I was able to remove a dependency on two faltering database libraries. Mongoengine, the one that I’m going to pull numbers from for Talk Python Training below, has not had a meaningful release in years. It was one of the two core blockers that prevented me from using async programming patterns on the website entirely.

How much faster is Raw+DC than MongoEngine?

I said I imagined that we would save in memory and CPU costs, but did it actually pan out in a practical application? After all, we saw that Robyn, the web framework, is 25 times faster than Flask. However, in practice, it was almost a dead even heat.

I’m thrilled to report that yes, the web app is much faster using Raw+DC.

Below is an apples-to-apples comparison for Talk Python Training using MongoEngine and the Raw+DC pattern.

The memory story is really great as well. After letting the web app run for over 24 hours for each mode, we saw a 200 MB memory usage decrease using Raw+DC.

That amount of memory might still look high to you. This Raw+DC transformation actually facilitates future work that will cut it in half again, down to about 500 MB for the full app, up and running in production at equilibrium.

Is Raw+DC worth migrating to?

To me, this seems 100% worth it. I’ve gained four important things with Raw+DC.

1. 1.75x the requests per second on the exact same hardware and codebase (sans data layer swap)
2. 18% less memory usage with much more savings on the horizon
3. New data layer natively supports async/await
4. Removal of problematic, core data access library

All of these benefits and none of that even touches on whether or not this new programming model is better for AI (it is).

March 30, 2026 03:31 PM UTC

• • RSS feed
  • Titles Only
  • Powered by Planet!
• Other Python Planets
  • Python Summer of Code
  • Planet Python Francophone
  • Planet Python Argentina
  • Planet Python Brasil
  • Planet Python Poland
• Python Libraries
  • OLPC
  • PySoy
  • SciPy
  • SymPy
  • Twisted
• Python/Web Planets
  • CherryPy
  • Django Community
  • Plone
  • Turbogears
• Other Languages
  • Haskell
  • Lisp
  • Parrot
  • Perl
  • Ruby
• Databases
  • MySQL
  • PostgreSQL
• Subscriptions
  • [OPML feed]
  • "Menno's Musings"
  • "Michael J.T. O'Kelly"
  • "Michael Kennedy's Thoughts on Technology"
  • "Morphex's Blogologue"
  • "Speno's Pythonic Avocado"
  • "William's Journal"
  • 2degrees
  • A. Jesse Jiryu Davis
  • ABlog for Sphinx
  • Aahz
  • Abhijeet Pal
  • Abu Ashraf Masnun
  • Adam Pletcher
  • Adrarsh Divakaran
  • Agendaless Consulting
  • Ahmed Bouchefra
  • Al-Ahmadgaid Asaad
  • Alec Munro
  • Alex Grönholm
  • Alex Morozov
  • Alexander Limi
  • Alexandre Conrad
  • Alexandre Vassalotti
  • Alexey Evseev
  • Allison Kaptur
  • Amjith Ramanujam
  • AmvTek
  • Anarcat
  • Anatoly Techtonik
  • Andre Roberge
  • Andrea Grandi
  • Andrew Dalke
  • Andriy Kornatskyy
  • Andy Dustman
  • Andy R. Terrel
  • Anna Martelli Ravenscroft
  • Anthony Baxter
  • Anton Belyaev
  • Anton Bobrov
  • Antonio Cuni
  • Anwesha Das
  • Ari Lamstein
  • Armin Ronacher
  • Artem Golubin
  • Artem Rys
  • Ashish Vidyarthi
  • Astro Code School
  • Audrey M. Roy Greenfeld
  • Automating OSINT
  • Awesome Python Applications
  • Baiju Muthukadan
  • Bajusz Tamás
  • BeDjango
  • Ben Bass
  • Ben Cook
  • Ben Rousch
  • Benjamin Peterson
  • Benji York
  • Bertrand Mathieu
  • Bhavin Gandhi
  • Bhishan Bhandari
  • BioPython News
  • Bit of Cheese
  • Bojan Mihelac
  • Brandon Rhodes
  • BreadcrumbsCollector
  • Brendan Scott
  • Brett Cannon
  • Brian Okken
  • Bruno Oliveira
  • Bruno Ponne / Coding The Past
  • Bruno Rocha
  • Caktus Consulting Group
  • Calvin Cheng
  • Calvin Spealman
  • Carl Chenet
  • Carl Düvel
  • Carl Trachte
  • Carlos Eduardo de Paula
  • Casey Duncan
  • Catherine Devlin
  • Ching-Hwa Yu
  • Chris Hager
  • Chris Miles
  • Chris Mitchell
  • Chris Moffitt
  • Chris Rose
  • Chris Warrick
  • Christian Heimes
  • Christian Ledermann
  • Christian Scholz
  • Christoph Schiessl
  • Christoph Zwerschke
  • CodeGrades
  • CodeSnipers
  • CodersLegacy
  • Coding Diet
  • Corey Gallon
  • Corey Goldberg
  • Cormoran Project
  • Cross-Platform Command Line Tools
  • CubicWeb
  • Curtis Miller
  • DSPIllustrations.com
  • DaPythonista
  • Daily Tech Video (Python)
  • Dallas Fort Worth Pythoneers
  • Dan Crosta
  • Dan Stromberg
  • Dan Yeaw
  • Daniel Bader
  • Daniel Nouri
  • Daniel Roy Greenfeld
  • Data Community DC
  • Data School
  • DataWars.io
  • Dave Beazley
  • David Amos
  • David Caron
  • David Goodger
  • David Lindelof
  • David MacIver
  • David Malcolm
  • David Szotten
  • Davide Moro
  • Davy Mitchell
  • Davy Wybiral
  • Declassed Art
  • Denis Kurov
  • Django Weblog
  • Djangostars
  • Doing Math with Python
  • Doug Hellmann
  • Dougal Matthews
  • Duncan McGreggor
  • Ed Crewe
  • Edward K. Ream
  • Eli Bendersky
  • Eniram Ltd.
  • Eray Özkural (examachine)
  • Erik Marsja
  • Etienne Desautels
  • EuroPython
  • EuroPython Society
  • Evennia
  • Everyday Superpowers
  • Fabio Zadrozny
  • Filip Wasilewski
  • Filipe Saraiva
  • First Institute of Reliable Software
  • Flavio Coelho
  • Flavio Percoco
  • Floris Bruynooghe
  • Frank Wierzbicki
  • François Dion
  • François Marier
  • Frederik Rietdijk
  • From Python Import Podcast
  • Full Stack Python
  • Gaël Varoquaux
  • Georges Dubus
  • Ghaandee on IT
  • Giampaolo Rodola
  • Giulio Fidente
  • Glenn Franxman
  • Glyph Lefkowitz
  • Go Deh
  • Gocept Weblog
  • Godson Gera
  • Graeme Cross
  • Graham Dumpleton
  • Graham Wheeler
  • Grant Baillie
  • Grant Rettke
  • Greg Taylor
  • Grig Gheorghiu
  • Grzegorz Śliwiński
  • Guido van Rossum
  • Gustavo Narea
  • Gustavo Niemeyer
  • Gökhan Sever
  • Hernan Grecco
  • Hilary Mason
  • Holger Peters
  • HoloViz
  • Hugo van Kemenade
  • Humberto Rocha
  • Hynek Schlawack
  • Ian Ozsvald
  • Ilian Iliev
  • Import Python
  • Inspired Python
  • Ionel Cristian Maries
  • IronPython-URLs
  • IslandT
  • Israel Fruchter
  • Itamar Turner Trauring
  • Ivan Velichko
  • J. Pablo Fernández
  • Jack Diederich
  • Jacob Perkins
  • Jahongir Rahmonov
  • Jaime Buelta
  • Jamal Moir
  • James Bennett
  • Janusworx
  • Jarrod Millman
  • Jean-Paul Calderone
  • Jeff Bisbee
  • Jeff Bradberry
  • Jeff Hinrichs
  • Jeff Shell
  • Jeremy Epstein
  • Jeremy Hylton
  • Jim Fulton
  • Joe Abbate
  • Joe Pitz
  • Johan Dahlin
  • John Burns
  • John Cook
  • John Jacobsen
  • John Ludhi/nbshare.io
  • Jon Parise
  • Jonathan Ellis
  • Jonathan Harrington
  • Jonathan Hartley
  • Jonathan Street
  • Jorgen Schäfer
  • Juan Manuel Contreras
  • Julien Danjou
  • Julien Tayon
  • Juri Pakaste
  • Just a little Python
  • Justin Mayer
  • Kai Lautaportti
  • Karim Elghamrawy
  • Kay Hayen
  • Kay Schluehr
  • Kelly Yancey
  • Kevin Renskers
  • Kodnito
  • Kogan Dev
  • Konrad Delong
  • Koodaamo
  • Kristján Valur Jónsson
  • Kriti Godey
  • Kulbir Saini
  • Kumar McMillan
  • Kumar Vipin Yadav
  • Kushal Das
  • Károly Nagy
  • LAAC Technology
  • Laurent Szyster
  • Leigh Honeywell
  • Lennart Regebro
  • Leonhard Vogt
  • Lintel Technologies
  • Linux Stans
  • ListenData
  • Logilab
  • Low Kian Seong
  • Luca Botti
  • Lucas Cimon
  • Ludovic Gasc
  • Ludvig Ericson
  • Luke Plant
  • Maciej Fijalkowsk
  • Made With Mu
  • Mahmoud Hashemi
  • Malthe Borch
  • Marc Richter
  • Marc-André Lemburg
  • Marcos Dione
  • Mariatta
  • Marius Gedminas
  • Mark Dufour
  • Mark McLoughlin
  • Mark McMahon
  • Martijn Pieters
  • Martin Fitzpatrick
  • Mats Kindahl
  • Matt Layman
  • Matthew Rocklin
  • Matthew Rollings
  • Matthew Wilson
  • Matthew Wright
  • Mattias Brändström
  • Mauveweb
  • Michael Becker
  • Michael Droettboom
  • Michael Foord
  • Michael Nelson
  • Michal Kwiatkowski
  • Michał Bultrowicz
  • Michele Simionato
  • Michy Alice
  • Mike C. Fletcher
  • Mike Driscoll
  • Mike Müller
  • Mikhail Korobov
  • Mikko Ohtamaa
  • Mirek Długosz
  • Mitchell Garnaat
  • Mitya Sirenef
  • Montreal Python User Group
  • Moshe Zadka
  • Moya Project
  • Mozilla Web Development
  • Muharem Hrnjadovic
  • Mycli
  • Nadav Samet
  • Naomi Ceder
  • Natan Zabkar
  • Ned Batchelder
  • Neil Schemenauer
  • Nick Coghlan
  • Nick Craig-Wood
  • Nick Efford
  • Nick Janetakis
  • Nicola Iarocci
  • Nicolas Dumazet
  • Nicolas Paris
  • Nigel Babu
  • Nikola
  • Nikolaos Diamantis
  • Not Invented Here
  • Nsukami Patrick
  • Obey the Testing Goat
  • Ofosos
  • Omaha Python Users Group
  • Ondřej Čertík
  • Paolo Melchiorre
  • Pathwright
  • Patrice Neff
  • Patrick Altman
  • Patrick Kennedy
  • Patrick Müller
  • Paul Everitt
  • Paul Harrison
  • Paul Redman
  • Paweł Fertyk
  • Pedro Lima
  • Peter Bengtsson
  • Peter Eisentraut
  • Peter Fankhänel
  • Peter Harkins
  • Peter Hoffmann
  • Phil Hassey
  • Philip Jenvey
  • Philipp von Weitershausen
  • Philippe Normand
  • Phillip J. Eby
  • Podcast.__init__
  • Polyglot.Ninja()
  • Possbility and Probability
  • Pradeep Gowda
  • Pranav Pandey
  • Praveen Gollakota
  • Programiz
  • Programming Ideas With Jake
  • Przemysław Kołodziejczyk
  • PyATL Bytecode
  • PyBites
  • PyCharm
  • PyCoder’s Weekly
  • PyCon
  • PyPodcats
  • PyPy
  • PyTennessee
  • Python 4 Kids
  • Python 411 Podcast
  • Python Advocacy
  • Python Anywhere
  • Python Bytes
  • Python Celery - Weekly Celery Tutorials and How-tos
  • Python Circle
  • Python Data
  • Python Diary
  • Python Docs Editorial Board
  • Python Does What?!
  • Python Engineering at Microsoft
  • Python GUIs
  • Python Insider
  • Python Morsels
  • Python People
  • Python Piedmont Triad User Group
  • Python Pool
  • Python Software Foundation
  • Python Sweetness
  • Python User Groups
  • Python for Beginners
  • Python on Karan
  • Python with Myo
  • Python(x,y) News
  • PythonClub - A Brazilian collaborative blog about Python
  • PythonDebugging.com
  • Pythonicity
  • Pythonology
  • Python⇒Speed
  • Péter Szabó
  • Péter Zsoldos
  • Quansight Labs Blog
  • R David Murray
  • RMOTR
  • Ralph Bean
  • Ram Rachum
  • Randell Benavidez
  • Randle Taylor
  • Randy Zwitch
  • Raymond Hettinger
  • Read the Docs
  • Real Python
  • Red Hat Developers
  • Rene Dudfield
  • Reuven Lerner
  • Richard Tew
  • Richard Wall
  • Rickard Lindberg
  • Rishi Maker
  • Rob Galanakis
  • Robert Collins
  • Robert Zaremba
  • Robin Parmar
  • Robin Wilson
  • Rodrigo Araúj
  • Rodrigo Girão Serrão
  • RoseHosting Blog
  • Ruslan Spivak
  • Ryan Cox
  • S. Lott
  • S. R. Krishnan
  • SDJournal
  • SPE Weblog
  • STX Next
  • Salim Fadhley
  • Sandipan Dey
  • Sandro Tosi
  • Sean McGrath
  • Sebastian Pölsterl
  • Sebastian Witowski
  • Selena Deckelmann
  • Senthil Kumaran
  • Seth Michael Larson
  • Shannon -jj Behrens
  • ShiningPanda
  • Simeon Franklin
  • Simeon Visser
  • Simon
  • Simon Brunning
  • Simon Wittber
  • Simple is Better Than Complex
  • SoftFormance
  • Speed Matters
  • Spike ekipS
  • Spyder IDE
  • Stack Abuse
  • Stanislas Morbieu
  • Starzel.de
  • Stefan Behnel
  • Stefan Scherfke
  • Stefanie Molin
  • Stein Magnus Jodal
  • Stephen Ferg
  • Steve Holden
  • Steven Klass
  • Stuart Gordon Reid
  • Stéphane Wirtel
  • Sumana Harihareswara - Cogito, Ergo Sumana
  • Suresh Dasari/Tutlane.com
  • Swisscom ICT
  • Talk Python Blog
  • Talk Python to Me
  • Taylor Edmiston
  • TechBeamers Python
  • Techiediaries - Django
  • Terri Oda
  • Terry Jones
  • Test and Code
  • TestDriven.io
  • The Data Scientist
  • The Digital Cat
  • The Lunar Cowboy
  • The No Title® Tech Blog
  • The Occasional Occurrence
  • The Open Sourcerer
  • The Parcon Blog
  • The Python Coding Blog
  • The Python Coding Stack
  • The Python Papers
  • The Python Show
  • The Three of Wands
  • Thibauld Nion
  • ThisHosting.Rocks
  • Thomas Guest
  • Thomas Vander Stichele
  • Tibo Beijen
  • Tim Arnold / reachtim
  • Tim Gilbert
  • Tim Knapp
  • Tim Lesher
  • Tobias Ivarsson
  • Tom Christie
  • Tomasz Ducin
  • Tomaž Muraus
  • Tomer Filiba
  • Tony Breyal
  • Toshio Kuratomi
  • Travis Oliphant
  • Trey Hunner
  • Tryton News
  • Turnkey Linux
  • Twisted Matrix Labs
  • TypeThePipe
  • V.S. Babu
  • Varun Nischal
  • Vasudev Ram
  • Vinay Sajip
  • Vinay Sajip (Logging)
  • Vinayak Mehta
  • Virgil Dupras
  • Vladimir Perić
  • Wayne Witzel
  • Weekly Python Chat
  • Weekly Python StackOverflow Report
  • Wes Mason
  • Wesley Chun
  • Will Kahn-Greene
  • Will McGugan
  • Will Pierce
  • William Minchin
  • William Reade
  • Wing Tips
  • Wingware
  • Wyatt Baldwin
  • Yaniv Aknin
  • Yann Larrivée
  • Yuval Greenfield
  • Zaki Akhmad
  • Zato Blog
  • Zero to Mastery
  • Zero-with-Dot (Oleg Żero)
  • ZeroDB
  • bottlepy-dev
  • codeboje
  • death and gravity
  • eGenix.com
  • hypothesis.works articles
  • kdev-python
  • meejah.ca
  • nl-project
  • pgcli
  • py.CheckIO
  • pygame
  • pythonwise
  • qutebrowser development blog
  • saaj/recollection
  • scikit-learn
  • testmon
  • tryexceptpass
  • Éric Araujo
  • Łukasz Langa
  • To request addition or removal, open a PR or issue