CodeMemoirs

My journey and thoughts on AI as a Software Engineer

2026-04-05T00:00:00+00:00

It's time we talk about it. AI is everywhere and while I'm just a random dude who codes for a living and lives on this planet in the cosmos we call Earth, aka a nobody, I still want to share my journey and thoughts on it.</p>

How It Started</h2>
The first time I used AI at all was back in 2023 in a programming context. A Senior Engineer at the place I was working suggested we try Codeium (now called Windsurf). I gave it a try, and it was a game changer for me. I was only taking advantage of the code completion feature, but I remember feeling that this tool must somehow be inside my head because, 90% of the time, it suggested exactly what I wanted to write.</p>
Coding for me at the time resolved around typing some characters, the beginning of my logic, waiting to see if the AI would suggest what I was thinking about, and simply press TAB. This felt amazing, and I was super productive. The AI could write what I was thinking much faster than I ever could. I must admit I'm a bit</del> lazy, which is, in my opinion, actually a great feature as a Software Engineer, but I'm side tracking here. Combine the laziness, with not having to physically write what I was thinking about, and develop faster, and you can see how, for me, this felt like the best of both worlds.</p>
This kept going for a while until one day...</p>

The Realization</h2>
At the end of 2023 I was working on a side project at home and Codeium was suffering an outage and right there I realized how dependent I was on AI autocompletion. I spent years coding without AI but at that moment I couldn't remember the syntax of anything, it's embarrassing to admit but I had to check the syntax of a simple python lambda function. On top of all that, I remember vividly just constantly stopping and waiting for AI to suggest something, to write the logic I was thinking for me. I felt afraid and thought that I lost my ability to code forever and for that reason I went cold turkey.</p>
It took only a couple of days to remove that annoying wait for AI suggestions completely and, thankfully, my coding skills were just rusty. After this incident, I was a bit afraid and reluctant to use AI again, but I eventually came back to using it, not in the same way, but these tools are just so powerful.</p>

Relapsing</h2>
I never enabled AI autocompletion again, but throughout 2024 and 2025 I used AI as a coding partner and a smart search engine. I discussed ideas, edge cases and architectural designs with it, used it to find alternatives/refactor the code I wrote, to navigate and understand unknown codebases, and to create tests and documentation for me. I never felt as productive as I was, I was able to do what I loved, coding, and having a partner in crime 24/7 at my side. But as coding agents improved and got "smarter", I began to allow them to write most of the code for me, and once again I was mainly reviewing code and not writing it myself.</p>

The Present</h2>
Now in 2026, I basically use AI, mainly Claude Code, every day at work, but opposite to the feeling I got at the end of 2023, I actually think I found a good and healthy balance between myself and AI.</p>
At work, I use it to plan and discuss solutions for complex tasks, write code and tests, debug escalations, and documentation. With MCPs, better models, and now skills and sub agents, I feel like if you're not using them, you're missing out and not being as productive as you can. One thing to note is, I always review all the generated code deeply, since I know that I will always be solely responsible for the code and, in my view, you should never push something you don't understand. From my experience, AI is far from perfect, and I still have to fix, refactor or iterate on it the majority of the time, but it seems that it will always be and write faster than I ever will.</p>
For side projects, I try to use as little AI as possible and only for mundane and repetitive tasks do I rely on it. I feel like, since I don't have the need to be as productive as possible, I can scale down, simplify and really do what I want and enjoy the moment without any rush. I don't always need to be at full speed.</p>

Final Words</h2>
What I think AI will never replace is my passion for understanding how something works and to dive deep into it. At worst, it will actually enable me to do it faster. I still think that scaling it down and not being fully dependent on it is super important. If, for some reason, AI is not available, we want to be able to get your own hands dirty.</p>
I'm seeing similar things happening around me, outside the Software Engineer bubble. My friends, family, and everyone else is using AI for everything. My takeaway is that AI is better than the average person in most of the fields, but worse than any specialist in said field.</p>
As funny as it seems, I chose and opted to not use any AI while writing this post about AI. Like I've been saying, I'm trying to scale down my usage of it whenever I can for all the reasons I mentioned above. I'm sure that AI will be here to stay and make the majority of people more productive, but for me, I sometimes enjoy the simplicity of just doing it myself.</p>

TIL: Gunicorn's gthread Worker Timeout Doesn't Work as Expected

2025-03-06T00:00:00+00:00

When using Gunicorn to run our Django application in production, I had a simple assumption: setting a timeout value (or using the default 30-second timeout) would make sure that any request taking longer than that would be stopped. This is important for keeping the system stable and preventing resource problems.</p>

The Unexpected Discovery</h1>

While looking into issues in our system, I created a simple Django server similar to our application to test how it works.</p>

What I found was surprising: when using Gunicorn with the gthread</code> worker class and testing a delayed response, the worker didn't stop after the expected 30-second timeout. Instead, it kept waiting for the response.</p>


Note: This behavior may change in future versions of Gunicorn. If you're reading this in the future, check the latest documentation and test the behavior in your system.</em></p>
Digging Deeper</h1>
After some research, I found an existing issue</a> describing similar behavior. The key point: Gunicorn's timeout setting doesn't work as described in the docs when using the gthread</code> worker class.</p>
Reproducing the Issue</h1>
To show this behavior, I created a simple test:</p>
Dockerfile</h3>
FROM</span> python:3.13-slim</span></span>
WORKDIR</span> /app</span></span>
COPY</span> requirements.txt .</span></span>
RUN</span> pip install --no-cache-dir -r requirements.txt</span></span>
COPY</span> . .</span></span>
EXPOSE</span> 8080</span></span>
CMD</span> [</span>"gunicorn"</span>, </span>"--bind"</span>, </span>"0.0.0.0:8080"</span>, </span>"project.wsgi:application"</span>, </span>"-k"</span>, </span>"gthread"</span>, </span>"-t"</span>, </span>"30"</span>]</span></span></code></pre>A Simple View That Sleeps</h3>
1</span>def</span> long_sleep</span>(</span>request</span>) -></span> HttpResponseBase</span>:</span></span>
2</span>    logger</span>.</span>info</span>(</span>f</span>"Going to sleep!"</span>)</span></span>
3</span>    time</span>.</span>sleep</span>(</span>30</span>)</span></span>
4</span>    logger</span>.</span>info</span>(</span>f</span>"30 seconds passed! Am I still alive?"</span>)</span></span>
5</span>    time</span>.</span>sleep</span>(</span>30</span>)</span></span>
6</span>    logger</span>.</span>info</span>(</span>f</span>"Isn't my timeout suposed to kill me? Weird..."</span>)</span></span>
7</span>    return</span> JsonResponse</span>({</span>"message"</span>:</span> "ok"</span>})</span></span></code></pre>Server Logs</h3>
server-1  | [2025-03-06 14:26:06 +0000] [1] [INFO] Starting gunicorn 23.0.0</span></span>
server-1  | [2025-03-06 14:26:06 +0000] [1] [INFO] Listening at: http://0.0.0.0:8080 (1)</span></span>
server-1  | [2025-03-06 14:26:06 +0000] [1] [INFO] Using worker: gthread</span></span>
server-1  | [2025-03-06 14:26:06 +0000] [7] [INFO] Booting worker with pid: 7</span></span>
server-1  | INFO 2025-03-06 14:26:10,175: Going to sleep!</span></span>
server-1  | INFO 2025-03-06 14:26:40,176: 30 seconds passed! Am I still alive?</span></span>
server-1  | INFO 2025-03-06 14:27:10,176: Isn't my timeout suposed to kill me? Weird...</span></span></code></pre>
The worker simply kept running without any timeout, which goes against what the Gunicorn's documentation</a> says:</p>

Workers silent for more than this many seconds are killed and restarted.</p>
Default: 30</p>
</blockquote>
Conclusion</h1>
If you're using Gunicorn with the gthread</code> worker in production, I strongly suggest testing your timeout behavior to make sure it works as you expect.</p>
References</h1>
Gunicorn's documentation</a></p>



Building a Minimal ASGI Web Framework in Python
2025-01-05T00:00:00+00:00
ASGI (Asynchronous Server Gateway Interface) is the modern standard for asynchronous Python web applications, extending WSGI to support WebSockets, long-lived connections, and background tasks.</p>
This post walks through building a minimal ASGI web framework from scratch for educational purposes, designed to help you understand how web frameworks work under the hood.</p>
Understanding ASGI</h1>
ASGI applications are Python callables that accept three arguments:</p>
1</span>async def</span> app</span>(</span>scope</span>,</span> receive</span>,</span> send</span>):</span></span>
2</span>    ...</span></span></code></pre>

scope</strong>: Connection information (type, path, headers).</li>
receive</strong>: Async function to receive events (for WebSockets or HTTP requests).</li>
send</strong>: Async function to send responses.</li>
</ul>
Creating the Core Framework</h1>
A minimal ASGI framework needs:</p>

Routing</strong> to match incoming requests to handlers.</li>
Request & Response abstraction</strong> for easier handling.</li>
</ul>
Defining Request and Response Classes</h2>
 1</span>from</span> urllib</span>.</span>parse</span> import</span> parse_qs</span></span>
 2</span></span>
 3</span>class</span> Request</span>:</span></span>
 4</span>    def</span> __init__</span>(</span>self</span>,</span> scope</span>,</span> receive</span>):</span></span>
 5</span>        self</span>.</span>scope</span> =</span> scope</span></span>
 6</span>        self</span>.</span>receive</span> =</span> receive</span></span>
 7</span>        self</span>.</span>method</span> =</span> scope</span>[</span>"</span>method</span>"</span>]</span></span>
 8</span>        self</span>.</span>path</span> =</span> scope</span>[</span>"</span>path</span>"</span>]</span></span>
 9</span>        self</span>.</span>query_params</span> =</span> parse_qs</span>(</span>scope</span>.</span>get</span>(</span>"query_string"</span>,</span> b</span>""</span>).</span>decode</span>())</span></span>
10</span></span>
11</span>class</span> Response</span>:</span></span>
12</span>    def</span> __init__</span>(</span>self</span>,</span> body</span>,</span> status</span>=</span>200</span>,</span> headers</span>=</span>None</span>):</span></span>
13</span>        self</span>.</span>body</span> =</span> body</span>.</span>encode</span>(</span>"utf-8"</span>)</span></span>
14</span>        self</span>.</span>status</span> =</span> status</span></span>
15</span>        self</span>.</span>headers</span> =</span> headers</span> or</span> [(</span>"content-type"</span>,</span> "text/plain"</span>)]</span></span>
16</span></span>
17</span>    async def</span> send</span>(</span>self</span>,</span> send</span>):</span></span>
18</span>        await</span> send</span>({</span></span>
19</span>            "type"</span>:</span> "http.response.start"</span>,</span></span>
20</span>            "status"</span>:</span> self</span>.</span>status</span>,</span></span>
21</span>            "headers"</span>: [(</span>k</span>.</span>encode</span>(),</span> v</span>.</span>encode</span>())</span> for</span> k</span>,</span> v</span> in</span> self</span>.</span>headers</span>],</span></span>
22</span>        })</span></span>
23</span>        await</span> send</span>({</span></span>
24</span>            "type"</span>:</span> "http.response.body"</span>,</span></span>
25</span>            "body"</span>:</span> self</span>.</span>body</span>,</span></span>
26</span>        })</span></span></code></pre>Adding Routing</h2>
 1</span>class</span> App</span>:</span></span>
 2</span>    def</span> __init__</span>(</span>self</span>):</span></span>
 3</span>        self</span>.</span>routes</span> =</span> {}</span></span>
 4</span></span>
 5</span>    def</span> route</span>(</span>self</span>,</span> path</span>):</span></span>
 6</span>        def</span> wrapper</span>(</span>handler</span>):</span></span>
 7</span>            self</span>.</span>routes</span>[</span>path</span>]</span> =</span> handler</span></span>
 8</span>            return</span> handler</span></span>
 9</span>        return</span> wrapper</span></span>
10</span></span>
11</span>    async def</span> __call__</span>(</span>self</span>,</span> scope</span>,</span> receive</span>,</span> send</span>):</span></span>
12</span>        if</span> scope</span>[</span>"</span>type</span>"</span>]</span> !=</span> "http"</span>:</span></span>
13</span>            return</span></span>
14</span></span>
15</span>        request</span> =</span> Request</span>(</span>scope</span>,</span> receive</span>)</span></span>
16</span>        handler</span> =</span> self</span>.</span>routes</span>.</span>get</span>(</span>request</span>.</span>path</span>)</span></span>
17</span>        </span></span>
18</span>        if</span> handler</span>:</span></span>
19</span>            response</span> =</span> await</span> handler</span>(</span>request</span>)</span></span>
20</span>        else</span>:</span></span>
21</span>            response</span> =</span> Response</span>(</span>"Not Found"</span>,</span> status</span>=</span>404</span>)</span></span>
22</span></span>
23</span>        await</span> response</span>.</span>send</span>(</span>send</span>)</span></span></code></pre>Running the Application</h1>
Define a Simple ASGI App Using the Framework</h2>
Once the framework is set up, create an instance of App</code> and define some routes:</p>
 1</span>app</span> =</span> App</span>()</span></span>
 2</span></span>
 3</span>@app</span>.</span>route</span>(</span>"/"</span>)</span></span>
 4</span>async def</span> homepage</span>(</span>request</span>):</span></span>
 5</span>    return</span> Response</span>(</span>"Hello, ASGI!"</span>)</span></span>
 6</span></span>
 7</span>@app</span>.</span>route</span>(</span>"/echo"</span>)</span></span>
 8</span>async def</span> echo</span>(</span>request</span>):</span></span>
 9</span>    message</span> =</span> request</span>.</span>query_params</span>.</span>get</span>(</span>"message"</span>, [</span>""</span>])[</span>0</span>]</span></span>
10</span>    return</span> Response</span>(</span>f</span>"You said: </span>{</span>message</span>}</span>"</span>)</span></span></code></pre>Running the Server Locally</h2>
To start the ASGI application locally, use Uvicorn</strong>, a high-performance ASGI server:</p>
First, install Uvicorn if you haven't:</p>
pip</span> install uvicorn</span></span></code></pre>
Then, run the server:</p>
uvicorn</span> myapp:app --host</span> 127.0.0.1</span> --port</span> 8000</span></span></code></pre>
You can test it in a browser or with curl</code>:</p>
curl</span> http://127.0.0.1:8000/</span></span>
curl</span> http://127.0.0.1:8000/echo?message=Hello</span></span></code></pre>Deploying to Production</h2>
For production, use Uvicorn with multiple workers</strong> behind a process manager like systemd</code> or a reverse proxy like nginx</code>:</p>
uvicorn</span> myapp:app --host</span> 0.0.0.0</span> --port</span> 8000</span> --workers</span> 4</span></span></code></pre>
Alternatively, use Daphne</strong>:</p>
pip</span> install daphne</span></span>
daphne</span> -b</span> 0.0.0.0</span> -p</span> 8000</span> myapp:app</span></span></code></pre>Note on Kubernetes, Docker Swarm, and Load Balancers</h3>
If deploying in Kubernetes</strong>, Docker Swarm</strong>, or behind a load balancer</strong>, the general best practice is to run only one worker per container or pod</strong>. The load balancer distributes traffic across multiple instances, making additional workers inside a single container unnecessary and potentially counterproductive.</p>
Handling JSON Requests and Responses</h1>
Extend Response</code> to handle JSON:</p>
1</span>import</span> json</span></span>
2</span></span>
3</span>class</span> JSONResponse</span>(</span>Response</span>):</span></span>
4</span>    def</span> __init__</span>(</span>self</span>,</span> data</span>,</span> status</span>=</span>200</span>,</span> headers</span>=</span>None</span>):</span></span>
5</span>        body</span> =</span> json</span>.</span>dumps</span>(</span>data</span>)</span></span>
6</span>        headers</span> =</span> headers</span> or</span> [(</span>"content-type"</span>,</span> "application/json"</span>)]</span></span>
7</span>        super</span>().</span>__init__</span>(</span>body</span>,</span> status</span>,</span> headers</span>)</span></span></code></pre>
Example usage:</p>
1</span>@app</span>.</span>route</span>(</span>"/json"</span>)</span></span>
2</span>async def</span> json_route</span>(</span>request</span>):</span></span>
3</span>    return</span> JSONResponse</span>({</span>"message"</span>:</span> "Hello, JSON!"</span>})</span></span></code></pre>Conclusion</h1>
This minimal ASGI framework demonstrates:</p>

Request and response abstraction.</li>
Simple routing.</li>
JSON response handling.</li>
</ul>
However, this framework is not meant for production use. It's a basic implementation designed to help you understand how web frameworks work. For a production-ready alternative, consider Starlette</strong></a> or FastAPI</strong></a>, which offer more robust features, security, and scalability.</p>
References</h1>
ASGI</a></p>
Uvicorn</a></p>


Mastering Type Hinting in Python
2024-12-29T00:00:00+00:00
Type hinting, introduced in Python 3.5 with PEP 484</a>, makes code clearer, less error-prone, and easier to maintain. It’s not just about neatness, it helps catch bugs early and makes life easier for you and your team. In this post, I’ll cover the basics, benefits, and advanced tips to help you get the most out of type hints.</p>
What is Type Hinting?</h1>
Type hinting allows you to annotate Python code with expected data types for variables, function arguments, and return values. This improves readability and helps tools like mypy</code> catch errors before the code runs. For example:</p>
1</span>def</span> greet</span>(</span>name</span>:</span> str</span>) -></span> str</span>:</span></span>
2</span>    return</span> f</span>"Hello, </span>{</span>name</span>}</span>!"</span></span></code></pre>
Here, name</code> is a string, and the function returns a string. Simple, right?</p>
Why Use Type Hinting?</h1>
Type hints make your code self-explanatory, help avoid mistakes, and enable smarter autocompletion in IDEs. They don’t change how Python runs your code but make it easier to work with, especially in large or collaborative projects.</p>
Basics of Type Hinting</h1>
You can annotate function arguments, return types, and variables using the typing</code> module.</p>
Functions</h2>
1</span>def</span> add</span>(</span>a</span>:</span> int</span>,</span> b</span>:</span> int</span>) -></span> int</span>:</span></span>
2</span>    return</span> a</span> +</span> b</span></span></code></pre>
This means a</code> and b</code> are integers, and the function returns an integer.</p>
Variables</h2>
1</span>x</span>:</span> int</span> =</span> 10</span></span>
2</span>y</span>:</span> str</span> =</span> "Python"</span></span>
3</span>names</span>:</span> list</span>[</span>str</span>]</span> =</span> [</span>"Alice"</span>,</span> "Bob"</span>]</span></span>
4</span>scores</span>:</span> dict</span>[</span>str</span>,</span> int</span>]</span> =</span> {</span>"Alice"</span>:</span> 90</span>,</span> "Bob"</span>:</span> 85</span>}</span></span></code></pre>
This tells readers and tools what types these variables are.</p>
Advanced Type Hinting</h1>
Unions and Optional Arguments</h2>
For more complex scenarios where multiple types are valid you can use the |</code> operator:</p>
1</span>def</span> add</span>(</span>a</span>:</span> int</span> |</span> float</span>,</span> b</span>:</span> int</span> |</span> float</span>,</span> c</span>:</span> int</span> |</span> float</span> |</span> None</span>) -></span> int</span> |</span> float</span>:</span></span>
2</span>    result</span> =</span> a</span> +</span> b</span></span>
3</span>    if</span> c</span> is not</span> None</span>:</span></span>
4</span>        result</span> +=</span> c</span></span>
5</span>    return</span> result</span></span></code></pre>
This means a</code> and b</code> can be either int</code> or float</code> and c</code> can be either int</code>, float</code>, or None</code>.</p>
New Types</h2>
You can also use NewType</code> to define custom types:</p>
 1</span>from</span> typing</span> import</span> NewType</span></span>
 2</span></span>
 3</span>Point</span> =</span> NewType</span>(</span>"Point"</span>,</span> tuple</span>[</span>int</span>,</span> int</span>])</span></span>
 4</span></span>
 5</span>def</span> sum_points</span>(</span>p1</span>:</span> Point</span>,</span> p2</span>:</span> Point</span>) -></span> Point</span>:</span></span>
 6</span>    x1</span>,</span> y1</span> =</span> p1</span></span>
 7</span>    x2</span>,</span> y2</span> =</span> p2</span></span>
 8</span>    return</span> Point</span>((</span>x1</span> +</span> x2</span>,</span> y1</span> +</span> y2</span>))</span></span></code></pre>
This creates a custom type called Point</code> that is a tuple of two integers.</p>
Using ABCs from collections.abc</code></h2>
The collections.abc</code> module provides abstract base classes (ABCs) for common container types, enabling generic programming with consistent interfaces.</p>
 1</span>from</span> collections</span>.</span>abc</span> import</span> Iterable</span>,</span> Callable</span>,</span> Generator</span></span>
 2</span></span>
 3</span>def</span> process</span>(</span>iterable</span>:</span> Iterable</span>[</span>int</span>]) -></span> None</span>:</span></span>
 4</span>    for</span> item</span> in</span> iterable</span>:</span></span>
 5</span>        print</span>(</span>item</span>)</span></span>
 6</span></span>
 7</span>def</span> apply</span>(</span>function</span>:</span> Callable</span>[[</span>int</span>],</span> int</span>]) -></span> None</span>:</span></span>
 8</span>    for</span> i</span> in</span> range</span>(</span>len</span>(</span>sequence</span>)):</span></span>
 9</span>        sequence</span>[</span>i</span>]</span> =</span> function</span>(</span>sequence</span>[</span>i</span>])</span></span>
10</span></span>
11</span>def</span> generate</span>() -></span> Generator</span>[</span>int</span>,</span> None</span>,</span> None</span>]:</span></span>
12</span>    for</span> i</span> in</span> range</span>(</span>10</span>):</span></span>
13</span>        yield</span> i</span></span></code></pre>
The Generator[int, None, None]</code> type annotation specifies a generator that yields integers (int</code>), does not accept any values to its send()</code> method (None</code>), and does not return a value upon completion (None</code>).</p>
Similarly, Callable[[int], int]</code> represents a callable (like a function) that takes a single integer as an argument (int</code>) and returns an integer (int</code>).</p>
For asynchronous programming, the collections.abc</code> module also includes counterparts such as Coroutine</code>, AsyncGenerator</code> and Awaitable</code>.</p>
Note: Avoid using typing.Iterable</code>, typing.Callable</code>, etc., as they are deprecated in favor of their collections.abc</code> counterparts.</p>

Functions – or other callable objects – can be annotated using collections.abc.Callable or deprecated typing.Callable.</a></p>
</blockquote>
Conclusion</h1>
Type hinting is a powerful tool that improves code clarity, catches potential bugs early, and makes your codebase more maintainable. While it may seem like extra work at first, the long-term benefits, especially in larger or collaborative projects, are undeniable. By mastering the basics and exploring advanced techniques, you can write Python code that is not only functional but also robust and self-documenting.</p>
References</h1>
Support for type hints</a></p>
Abstract Base Classes for Containers</a></p>


Asynchronous Python: Behind the Scenes with Asyncio
2024-11-20T00:00:00+00:00
In recent times, I faced a significant architectural challenge at work. Our large Django monolith was struggling to scale due to its synchronous nature, especially when handling WebSocket connections. To address this, I took on the task of migrating all the WebSocket and asynchronous functionality from Django to a more lightweight, asynchronous microservice built with FastAPI.</p>
This migration not only required a deep dive into asynchronous programming with Python but also gave me valuable hands-on experience with asyncio</code>. In this post, I’ll walk you through how asyncio</code> works and why it plays a pivotal role in building scalable, efficient applications.</p>
What is Asynchronous Programming?</h1>
Asynchronous programming allows a program to perform non-blocking I/O operations such as reading from a file, making a network request, or waiting for a message from a client without halting the execution of other tasks. This contrasts with synchronous programming, where each operation blocks the next one until it completes.</p>
Think of it like this: if a server is waiting for data from one client, it can simultaneously process messages from other clients without waiting idly.</p>
A Quick Dive into Asyncio</h1>
At its core, asyncio</code> allows you to define asynchronous tasks using async def</code> functions. These tasks are then scheduled and run on an event loop. Here's a breakdown of key concepts:</p>

Event Loop</strong>: The heart of asyncio</code>, which handles all the asynchronous operations. It runs tasks and schedules them in an efficient, non-blocking manner.</li>
Coroutines</strong>: Functions defined with async def</code>, which return an "awaitable" object when called. These are the building blocks of asynchronous code.</li>
Tasks</strong>: Instances of coroutines that are scheduled to run in the event loop.</li>
</ul>
Here’s an example of a basic asyncio</code> program:</p>
 1</span>import</span> time</span></span>
 2</span>import</span> asyncio</span></span>
 3</span></span>
 4</span>async def</span> greet</span>(</span>name</span>):</span></span>
 5</span>    print</span>(</span>f</span>"Hello, </span>{</span>name</span>}</span>!"</span>)</span></span>
 6</span>    await</span> asyncio</span>.</span>sleep</span>(</span>1</span>)</span>  # Sleep for 1 second</span></span>
 7</span>    print</span>(</span>f</span>"Goodbye, </span>{</span>name</span>}</span>!"</span>)</span></span>
 8</span></span>
 9</span>async def</span> main</span>():</span></span>
10</span>    task1</span> =</span> asyncio</span>.</span>create_task</span>(</span>greet</span>(</span>"Rui"</span>))</span></span>
11</span>    task2</span> =</span> asyncio</span>.</span>create_task</span>(</span>greet</span>(</span>"Teixeira"</span>))</span></span>
12</span>    task3</span> =</span> asyncio</span>.</span>create_task</span>(</span>greet</span>(</span>"Catarino"</span>))</span></span>
13</span>    </span></span>
14</span>    # Await all tasks to complete</span></span>
15</span>    await</span> task1</span></span>
16</span>    await</span> task2</span></span>
17</span>    await</span> task3</span></span>
18</span></span>
19</span>start_time</span> =</span> time</span>.</span>time</span>()</span></span>
20</span>asyncio</span>.</span>run</span>(</span>main</span>())</span></span>
21</span>print</span>(</span>f</span>"Execution time: </span>{</span>time</span>.</span>time</span>()</span> -</span> start_time</span>}</span> seconds."</span>)</span></span>
22</span></span>
23</span># Output:</span></span>
24</span># Hello, Rui!</span></span>
25</span># Hello, Teixeira!</span></span>
26</span># Hello, Catarino!</span></span>
27</span># Goodbye, Rui!</span></span>
28</span># Goodbye, Teixeira!</span></span>
29</span># Goodbye, Catarino!</span></span>
30</span># Execution time: 1.0026977062225342 seconds.</span></span></code></pre>
In this example, three greet()</code> tasks are created and run concurrently. The event loop handles each task, and the program doesn’t block while waiting for one task to finish before starting the next. Instead, the tasks run in parallel, and the total execution time is just over 1 second.</p>
A Deeper Dive into Asyncio</h1>
Now that we’ve seen the basics of defining and awaiting tasks, let’s explore more advanced features of asyncio</code> that help you manage timeouts, cancel tasks, and synchronize concurrent operations.</p>
Warning:</strong> This section will be detailed and extensive, covering a wide range of features to help you master asyncio</code>. Feel free to refer back to specific parts as needed!</p>
Task Management and Lifecycle</h2>
In asyncio</code>, tasks represent coroutines that have been scheduled to run in the event loop. We can create tasks using asyncio.create_task()</code> and await them individually, as seen earlier. However, if you need to run several tasks concurrently, you can await them all at once using asyncio.gather()</code>.</p>
 1</span>import</span> asyncio</span></span>
 2</span></span>
 3</span>async def</span> greet</span>(</span>name</span>):</span></span>
 4</span>    await</span> asyncio</span>.</span>sleep</span>(</span>1</span>)</span></span>
 5</span>    return</span> f</span>"Hello, </span>{</span>name</span>}</span>!"</span></span>
 6</span></span>
 7</span>async def</span> main</span>():</span></span>
 8</span>    task1</span> =</span> asyncio</span>.</span>create_task</span>(</span>greet</span>(</span>"Rui"</span>))</span></span>
 9</span>    task2</span> =</span> asyncio</span>.</span>create_task</span>(</span>greet</span>(</span>"Teixeira"</span>))</span></span>
10</span>    task3</span> =</span> asyncio</span>.</span>create_task</span>(</span>greet</span>(</span>"Catarino"</span>))</span></span>
11</span>    </span></span>
12</span>    results</span> =</span> await</span> asyncio</span>.</span>gather</span>(</span>task1</span>,</span> task2</span>,</span> task3</span>)</span></span>
13</span>    print</span>(</span>results</span>)</span></span>
14</span></span>
15</span>asyncio</span>.</span>run</span>(</span>main</span>())</span></span></code></pre>
In this example, asyncio.gather()</code> allows the tasks to run concurrently, and the results are collected once all tasks complete.</p>
Handling Exceptions with</strong> **return_exceptions**</code>: By default, if any task raises an exception, asyncio.gather()</code> stops and raises that exception. However, if you set return_exceptions=True</code>, exceptions are returned as part of the results, allowing the program to continue:</p>
 1</span>async def</span> faulty_task</span>():</span></span>
 2</span>    raise</span> ValueError</span>(</span>"An error occurred!"</span>)</span></span>
 3</span></span>
 4</span>async def</span> main</span>():</span></span>
 5</span>    results</span> =</span> await</span> asyncio</span>.</span>gather</span>(</span></span>
 6</span>        greet</span>(</span>"Alice"</span>),</span></span>
 7</span>        faulty_task</span>(),</span></span>
 8</span>        return_exceptions</span>=</span>True</span></span>
 9</span>    )</span></span>
10</span>    print</span>(</span>results</span>)</span>  # Outputs: ['Hello, Alice!', ValueError('An error occurred!')]</span></span>
11</span></span>
12</span>asyncio</span>.</span>run</span>(</span>main</span>())</span></span></code></pre>Task Timeouts</h2>
Sometimes you need to enforce time limits on your tasks. asyncio.wait_for()</code> is perfect for this. It allows you to set a timeout for a task, and if it doesn't finish in time, it raises a TimeoutError</code>.</p>
 1</span>import</span> asyncio</span></span>
 2</span></span>
 3</span>async def</span> long_task</span>():</span></span>
 4</span>    await</span> asyncio</span>.</span>sleep</span>(</span>3</span>)</span></span>
 5</span>    return</span> "Task completed"</span></span>
 6</span></span>
 7</span>async def</span> main</span>():</span></span>
 8</span>    try</span>:</span></span>
 9</span>        result</span> =</span> await</span> asyncio</span>.</span>wait_for</span>(</span>long_task</span>(),</span> timeout</span>=</span>2</span>)</span></span>
10</span>        print</span>(</span>result</span>)</span></span>
11</span>    except</span> asyncio</span>.</span>TimeoutError</span>:</span></span>
12</span>        print</span>(</span>"The task took too long!"</span>)</span></span>
13</span></span>
14</span>asyncio</span>.</span>run</span>(</span>main</span>())</span></span></code></pre>Task Cancellation</h2>
asyncio</code> also allows you to cancel tasks that are no longer needed. This is particularly useful when you want to stop a task before it finishes. To cancel a task, call the cancel()</code> method, and handle the CancelledError</code> exception.</p>
 1</span>import</span> asyncio</span></span>
 2</span></span>
 3</span>async def</span> task_to_cancel</span>():</span></span>
 4</span>    try</span>:</span></span>
 5</span>        await</span> asyncio</span>.</span>sleep</span>(</span>5</span>)</span></span>
 6</span>        print</span>(</span>"Task completed"</span>)</span></span>
 7</span>    except</span> asyncio</span>.</span>CancelledError</span>:</span></span>
 8</span>        print</span>(</span>"Task was cancelled"</span>)</span></span>
 9</span>        raise</span></span>
10</span></span>
11</span>async def</span> main</span>():</span></span>
12</span>    task</span> =</span> asyncio</span>.</span>create_task</span>(</span>task_to_cancel</span>())</span></span>
13</span>    await</span> asyncio</span>.</span>sleep</span>(</span>1</span>)</span></span>
14</span>    task</span>.</span>cancel</span>()</span></span>
15</span>    try</span>:</span></span>
16</span>        await</span> task</span></span>
17</span>    except</span> asyncio</span>.</span>CancelledError</span>:</span></span>
18</span>        print</span>(</span>"Caught cancellation"</span>)</span></span>
19</span></span>
20</span>asyncio</span>.</span>run</span>(</span>main</span>())</span></span></code></pre>Preventing Resource Conflicts</h2>
When multiple tasks need to access shared resources, you can use asyncio.Lock()</code> to ensure that only one task can access the resource at a time. This helps avoid race conditions.</p>
 1</span>import</span> asyncio</span></span>
 2</span></span>
 3</span>lock</span> =</span> asyncio</span>.</span>Lock</span>()</span></span>
 4</span></span>
 5</span>async def</span> critical_section</span>(</span>name</span>):</span></span>
 6</span>    async with</span> lock</span>:</span></span>
 7</span>        print</span>(</span>f</span>"</span>{</span>name</span>}</span> is in the critical section."</span>)</span></span>
 8</span>        await</span> asyncio</span>.</span>sleep</span>(</span>1</span>)</span></span>
 9</span>        print</span>(</span>f</span>"</span>{</span>name</span>}</span> is leaving the critical section."</span>)</span></span>
10</span></span>
11</span>async def</span> main</span>():</span></span>
12</span>    await</span> asyncio</span>.</span>gather</span>(</span></span>
13</span>        critical_section</span>(</span>"Task 1"</span>),</span></span>
14</span>        critical_section</span>(</span>"Task 2"</span>),</span></span>
15</span>    )</span></span>
16</span></span>
17</span>asyncio</span>.</span>run</span>(</span>main</span>())</span></span></code></pre>Managing Resource Conflicts</h2>
Sometimes, you want to allow multiple tasks to access a resource, but with a limit. asyncio.Semaphore</code> lets you control how many tasks can run concurrently.</p>
 1</span>import</span> asyncio</span></span>
 2</span></span>
 3</span>semaphore</span> =</span> asyncio</span>.</span>Semaphore</span>(</span>2</span>)</span>  # Allow 2 tasks at a time</span></span>
 4</span></span>
 5</span>async def</span> limited_task</span>(</span>name</span>):</span></span>
 6</span>    async with</span> semaphore</span>:</span></span>
 7</span>        print</span>(</span>f</span>"</span>{</span>name</span>}</span> is working."</span>)</span></span>
 8</span>        await</span> asyncio</span>.</span>sleep</span>(</span>1</span>)</span></span>
 9</span>        print</span>(</span>f</span>"</span>{</span>name</span>}</span> is done."</span>)</span></span>
10</span></span>
11</span>async def</span> main</span>():</span></span>
12</span>    tasks</span> =</span> [</span>limited_task</span>(</span>f</span>"Task </span>{</span>i</span>}</span>"</span>)</span> for</span> i</span> in</span> range</span>(</span>5</span>)]</span></span>
13</span>    await</span> asyncio</span>.</span>gather</span>(</span>*</span>tasks</span>)</span></span>
14</span></span>
15</span>asyncio</span>.</span>run</span>(</span>main</span>())</span></span></code></pre>Task Communication</h2>
Queues are great for coordinating work between producer and consumer tasks. asyncio.Queue</code> provides thread-safe operations for adding and retrieving items.</p>
 1</span>import</span> asyncio</span></span>
 2</span></span>
 3</span>queue</span> =</span> asyncio</span>.</span>Queue</span>()</span></span>
 4</span></span>
 5</span>async def</span> producer</span>():</span></span>
 6</span>    for</span> i</span> in</span> range</span>(</span>5</span>):</span></span>
 7</span>        await</span> queue</span>.</span>put</span>(</span>f</span>"Item </span>{</span>i</span>}</span>"</span>)</span></span>
 8</span>        print</span>(</span>f</span>"Produced: Item </span>{</span>i</span>}</span>"</span>)</span></span>
 9</span>        await</span> asyncio</span>.</span>sleep</span>(</span>0.5</span>)</span></span>
10</span></span>
11</span>async def</span> consumer</span>():</span></span>
12</span>    while</span> True</span>:</span></span>
13</span>        item</span> =</span> await</span> queue</span>.</span>get</span>()</span></span>
14</span>        if</span> item</span> is</span> None</span>:</span></span>
15</span>            break</span></span>
16</span>        print</span>(</span>f</span>"Consumed: </span>{</span>item</span>}</span>"</span>)</span></span>
17</span>        await</span> asyncio</span>.</span>sleep</span>(</span>1</span>)</span></span>
18</span></span>
19</span>async def</span> main</span>():</span></span>
20</span>    prod_task</span> =</span> asyncio</span>.</span>create_task</span>(</span>producer</span>())</span></span>
21</span>    cons_task</span> =</span> asyncio</span>.</span>create_task</span>(</span>consumer</span>())</span></span>
22</span>    await</span> prod_task</span></span>
23</span>    await</span> queue</span>.</span>put</span>(</span>None</span>)</span>  # Signal the consumer to stop</span></span>
24</span>    await</span> cons_task</span></span>
25</span></span>
26</span>asyncio</span>.</span>run</span>(</span>main</span>())</span></span></code></pre>Coordinating Tasks</h2>
asyncio.Event</code> allows tasks to wait for a signal before continuing. This is helpful for coordinating between tasks.</p>
 1</span>import</span> asyncio</span></span>
 2</span></span>
 3</span>event</span> =</span> asyncio</span>.</span>Event</span>()</span></span>
 4</span></span>
 5</span>async def</span> waiter</span>():</span></span>
 6</span>    print</span>(</span>"Waiting for the event..."</span>)</span></span>
 7</span>    await</span> event</span>.</span>wait</span>()</span></span>
 8</span>    print</span>(</span>"Event set! Proceeding."</span>)</span></span>
 9</span></span>
10</span>async def</span> setter</span>():</span></span>
11</span>    print</span>(</span>"Setting the event in 2 seconds..."</span>)</span></span>
12</span>    await</span> asyncio</span>.</span>sleep</span>(</span>2</span>)</span></span>
13</span>    event</span>.</span>set</span>()</span></span>
14</span></span>
15</span>async def</span> main</span>():</span></span>
16</span>    await</span> asyncio</span>.</span>gather</span>(</span>waiter</span>(),</span> setter</span>())</span></span>
17</span></span>
18</span>asyncio</span>.</span>run</span>(</span>main</span>())</span></span></code></pre>Structured Concurrency</h2>
asyncio.TaskGroup</code> simplifies managing multiple tasks, ensuring they complete or clean up together. It provides better error handling and automatic cancellation for tasks in the group.</p>
 1</span>import</span> asyncio</span></span>
 2</span></span>
 3</span>async def</span> task</span>(</span>name</span>,</span> delay</span>):</span></span>
 4</span>    await</span> asyncio</span>.</span>sleep</span>(</span>delay</span>)</span></span>
 5</span>    print</span>(</span>f</span>"</span>{</span>name</span>}</span> completed!"</span>)</span></span>
 6</span></span>
 7</span>async def</span> main</span>():</span></span>
 8</span>    async with</span> asyncio</span>.</span>TaskGroup</span>()</span> as</span> tg</span>:</span></span>
 9</span>        tg</span>.</span>create_task</span>(</span>task</span>(</span>"Task 1"</span>,</span> 1</span>))</span></span>
10</span>        tg</span>.</span>create_task</span>(</span>task</span>(</span>"Task 2"</span>,</span> 2</span>))</span></span>
11</span>        tg</span>.</span>create_task</span>(</span>task</span>(</span>"Task 3"</span>,</span> 3</span>))</span></span>
12</span>    print</span>(</span>"All tasks completed!"</span>)</span></span>
13</span></span>
14</span>asyncio</span>.</span>run</span>(</span>main</span>())</span></span></code></pre>
By combining these tools — locks, semaphores, queues, events, and task groups— you can build robust, scalable, and highly efficient asynchronous applications with asyncio</code>.</p>
Conclusion</h1>
Asynchronous programming with asyncio</code> is a game-changer for building scalable systems.</p>
I hope this post has clarified the inner workings of asyncio</code> and showcased its ability to handle I/O-bound tasks effectively. Whether you're building a microservice or optimizing a project, mastering asyncio</code> unlocks new possibilities for performance and scalability.</p>
References</h1>
asyncio - Asynchronous I/O</a></p>
Synchronization Primitives</a></p>
Coroutines and Tasks</a></p>


Metaclasses in Python: Mastering Class Creation and Customization
2024-10-12T00:00:00+00:00
When working with Python, you’ve likely come across concepts like classes and inheritance. But have you ever wondered how Python defines and creates classes themselves? That’s where metaclasses come into play.</p>
What is a Metaclass?</h1>
A metaclass is a class responsible for creating other classes, just as a class is responsible for creating objects. In simpler terms, if an object is an instance of a class, then a class is an instance of a metaclass.</p>
Metaclasses allow you to modify or customize how classes are defined and constructed. By default, Python uses type()</code> as its metaclass. When you define a class using the class</code> keyword, Python is essentially doing this behind the scenes:</p>
1</span>class</span> MyClass</span>:</span></span>
2</span>    def</span> test</span>(</span>self</span>):</span></span>
3</span>        print</span>(</span>"This is a test"</span>)</span></span></code></pre>
The above is equivalent to the following:</p>
1</span>MyClass</span> =</span> type</span>(</span>'MyClass'</span>, (), {</span></span>
2</span>    'test'</span>:</span> lambda</span> self</span>:</span> print</span>(</span>"This is a test"</span>)</span></span>
3</span>})</span></span></code></pre>
The _type(name,bases,namespace)_</code> function takes three arguments when creating a class:</p>
name</code>: The name of the class (as a string).</p>
bases</code>: A tuple of base classes for inheritance (use ()</code> for no inheritance).</p>
namespace</code>: A dictionary that holds attributes and methods for the class.</p>
Creating Custom Metaclasses</h1>
To create a metaclass, you need to define a class that inherits from type</code>. You can override three important methods:</p>

__new__(cls, name, bases, dct)</code>: Responsible for creating the new class.</li>
__init__(cls, name, bases, dct)</code>: Called after the class is created, allowing further customizations.</li>
__call__(cls, *args, **kwargs)</code>: Enables instances of the metaclass (i.e., the classes created by it) to be called like functions.</li>
</ol>
Let’s walk through a basic example:</p>
 1</span>class</span> MyMeta</span>(</span>type</span>):</span></span>
 2</span>    def</span> __new__</span>(</span>cls</span>,</span> name</span>,</span> bases</span>,</span> dct</span>):</span></span>
 3</span>        print</span>(</span>f</span>"Creating class </span>{</span>name</span>}</span>"</span>)</span></span>
 4</span>        return</span> super</span>().</span>__new__</span>(</span>cls</span>,</span> name</span>,</span> bases</span>,</span> dct</span>)</span></span>
 5</span></span>
 6</span>    def</span> __init__</span>(</span>cls</span>,</span> name</span>,</span> bases</span>,</span> dct</span>):</span></span>
 7</span>        print</span>(</span>f</span>"Initializing class </span>{</span>name</span>}</span>"</span>)</span></span>
 8</span>        super</span>().</span>__init__</span>(</span>name</span>,</span> bases</span>,</span> dct</span>)</span></span>
 9</span></span>
10</span>    def</span> __call__</span>(</span>cls</span>,</span> *</span>args</span>,</span> **</span>kwargs</span>):</span></span>
11</span>        print</span>(</span>f</span>"Creating an instance of </span>{</span>cls</span>.</span>__name__</span>}</span> with args: </span>{</span>args</span>}</span> and kwargs: </span>{</span>kwargs</span>}</span>"</span>)</span></span>
12</span>        return</span> super</span>().</span>__call__</span>(</span>*</span>args</span>,</span> **</span>kwargs</span>)</span></span>
13</span></span>
14</span>class</span> MyClass</span>(</span>metaclass</span>=</span>MyMeta</span>):</span></span>
15</span>    def</span> __init__</span>(</span>self</span>,</span> *</span>args</span>,</span> **</span>kwargs</span>):</span></span>
16</span>        pass</span></span>
17</span></span>
18</span># Output:</span></span>
19</span># Creating class MyClass</span></span>
20</span># Initializing class MyClass</span></span>
21</span></span>
22</span>obj</span> =</span> MyClass</span>(</span>1</span>,</span> key</span>=</span>"value"</span>)</span></span>
23</span># Output:</span></span>
24</span># Creating an instance of MyClass with args: (1,) and kwargs: {'key': 'value'}</span></span></code></pre>
You might be wondering what the difference between __new__</code> and __init__</code> is. In Python, __new__</code> is a special method responsible for creating a new instance of a class, and returning it. On the other hand, __init__</code> is called after the instance has been created and is used to initialize the instance’s attributes and set up its state. Essentially, __new__</code> creates the instance, while __init__</code> configures it.</p>
Additional Methods You Can Override in a Metaclass</h2>
Beyond __new__</code>, __init__</code>, and __call__</code>, you can customize various other methods in a metaclass to gain further control over class behavior:</p>

__setattr__(cls, name, value)</code>: Customize behavior when setting attributes on the class.</li>
__getattr__(cls, name)</code>: Control the behavior for accessing non-existent class attributes.</li>
__delattr__(cls, name)</code>: Customize the behavior when an attribute is deleted from the class.</li>
__repr__(cls)</code>: Define a custom string representation of the class for debugging or logging.</li>
__str__(cls)</code>: Create a string representation of the class.</li>
__prepare__(name, bases)</code>: Customize the class namespace before the class is created.</li>
__instancecheck__(cls, instance)</code>: Modify how isinstance()</code> behaves for classes created with the metaclass.</li>
__subclasscheck__(cls, subclass)</code>: Change how issubclass()</code> operates for classes created with the metaclass.</li>
</ol>
Practical Examples of Metaclass Usage</h1>
Enforcing Class Attributes</h2>
Metaclasses can be used to enforce that certain attributes or methods are defined in a class. Here’s an example that ensures every subclass of Animal</code> has a speak()</code> method:</p>
 1</span>class</span> EnforceSpeak</span>(</span>type</span>):</span></span>
 2</span>    def</span> __new__</span>(</span>cls</span>,</span> name</span>,</span> bases</span>,</span> dct</span>):</span></span>
 3</span>        if</span> 'speak'</span> not in</span> dct</span>:</span></span>
 4</span>            raise</span> TypeError</span>(</span>f</span>"Class </span>{</span>name</span>}</span> must implement a 'speak' method."</span>)</span></span>
 5</span>        return</span> super</span>().</span>__new__</span>(</span>cls</span>,</span> name</span>,</span> bases</span>,</span> dct</span>)</span></span>
 6</span></span>
 7</span>class</span> Animal</span>(</span>metaclass</span>=</span>EnforceSpeak</span>):</span></span>
 8</span>    def</span> speak</span>(</span>self</span>):</span></span>
 9</span>        print</span>(</span>"I am an animal."</span>)</span></span>
10</span></span>
11</span>class</span> Dog</span>(</span>Animal</span>):</span></span>
12</span>    def</span> speak</span>(</span>self</span>):</span></span>
13</span>        print</span>(</span>"Woof!"</span>)</span></span>
14</span></span>
15</span>class</span> Cat</span>(</span>Animal</span>):</span></span>
16</span>    pass</span></span>
17</span># Output: TypeError: Class Cat must implement a 'speak' method.</span></span></code></pre>Implementing the Singleton Pattern</h2>
Metaclasses are excellent for implementing design patterns like the Singleton, where a class can only have one instance:</p>
 1</span>class</span> Singleton</span>(</span>type</span>):</span></span>
 2</span></span>
 3</span>    _instances</span> =</span> {}</span></span>
 4</span></span>
 5</span>    def</span> __call__</span>(</span>cls</span>,</span> *</span>args</span>,</span> **</span>kwargs</span>):</span></span>
 6</span>        if</span> cls</span> not in</span> cls</span>.</span>_instances</span>:</span></span>
 7</span>            cls</span>.</span>_instances</span>[</span>cls</span>]</span> =</span> super</span>().</span>__call__</span>(</span>*</span>args</span>,</span> **</span>kwargs</span>)</span></span>
 8</span>        return</span> cls</span>.</span>_instances</span>[</span>cls</span>]</span></span>
 9</span></span>
10</span>class</span> MyClass</span>(</span>metaclass</span>=</span>Singleton</span>):</span></span>
11</span>    pass</span></span>
12</span></span>
13</span>a</span> =</span> MyClass</span>()</span></span>
14</span>b</span> =</span> MyClass</span>()</span></span>
15</span>print</span>(</span>a</span> is</span> b</span>)</span>  # Output: True</span></span></code></pre>
The metaclass Singleton</code> overrides the __call__</code> method to ensure that only one instance of the class is created. Even though we try to create two instances of MyClass</code>, both a</code> and b</code> refer to the same instance.</p>
Metaclasses vs. Class Decorators</h1>
While both metaclasses and class decorators can modify class behavior, they differ in important ways:</p>

Metaclasses intervene during class creation, while class decorators modify a class after it’s created.</li>
Metaclasses provide more control and are applied at a deeper level of the class creation lifecycle, making them more powerful, but also more complex.</li>
</ul>
Use metaclasses when you need fine-grained control over the class itself (e.g., enforcing certain rules, design patterns), and class decorators when you need simple modifications after the class is defined.</p>
Conclusion</h1>
Metaclasses are a powerful feature in Python that allow you to control and customize the behavior of class creation. While they can seem complex at first, understanding their purpose — defining how classes themselves are constructed — opens up advanced patterns in object-oriented programming.</p>
Whether you’re enforcing class-level constraints, creating singletons, or dynamically modifying class behavior, metaclasses give you deep control over how Python classes behave. While they are not needed in most day-to-day Python programming tasks, mastering them allows for more flexible and reusable code when working with complex systems.</p>
I hope this guide has deepened your understanding of Python.</p>
References</h1>
Data model</a></p>


Understanding Python’s Method Resolution Order (MRO)
2024-09-21T00:00:00+00:00
When working with Python, especially object-oriented programming (OOP), you’ll encounter inheritance and, at times, multiple inheritance. In such scenarios, Python provides a sophisticated way of determining which method to call using something called the Method Resolution Order (MRO)</strong>.</p>
If you’re diving into OOP in Python and wondering how the language decides which method to invoke when dealing with complex class hierarchies, you’re in the right place. Let’s break down how Python’s MRO works, why it matters, and how you can inspect and control it.</p>
What is Method Resolution Order?</h1>
In Python, the MRO defines the sequence in which classes are searched when looking for a method or attribute. This becomes especially important in cases involving multiple inheritance. The MRO ensures that method lookups follow a consistent and logical path, preventing issues like calling the wrong method or skipping over a method altogether.</p>
Python also provides a handy way to inspect the MRO of any class using the .mro()</code> method, giving you a clear view of the order in which methods will be resolved.</p>
C3 Linearization</h1>
Since Python 2.3, the language uses the C3 linearization algorithm</strong> to compute the MRO for a class. In simple inheritance scenarios, this ordering can be intuitive, but as inheritance hierarchies grow complex, the MRO can become tricky to predict. Here’s an easy-to-understand example:</p>
 1</span>class</span> A</span>:</span> pass</span></span>
 2</span>class</span> B</span>:</span> pass</span></span>
 3</span>class</span> C</span>(</span>A</span>,</span>B</span>):</span> pass</span></span>
 4</span>class</span> D</span>(</span>C</span>):</span> pass</span></span>
 5</span>class</span> E</span>(</span>C</span>):</span> pass</span></span>
 6</span>class</span> F</span>(</span>D</span>,</span>E</span>):</span> pass</span></span>
 7</span>F</span>.</span>mro</span>()</span></span>
 8</span># [F, D, E, C, A, B, object]</span></span></code></pre>
</p>
In this example, Python uses the MRO to determine which class’s method should be called first. However, when the inheritance hierarchy becomes more complex, as in the next example, predicting the MRO by intuition is more difficult:</p>
 1</span>class</span> A</span>:</span> pass</span></span>
 2</span>class</span> B</span>:</span> pass</span></span>
 3</span>class</span> C</span>:</span> pass</span></span>
 4</span>class</span> D</span>:</span> pass</span></span>
 5</span>class</span> E</span>:</span> pass</span></span>
 6</span>class</span> F</span>(</span>C</span>,</span> A</span>,</span> B</span>):</span> pass</span></span>
 7</span>class</span> G</span>(</span>A</span>,</span> D</span>):</span> pass</span></span>
 8</span>class</span> H</span>(</span>B</span>,</span> D</span>,</span> E</span>):</span> pass</span></span>
 9</span>class</span> I</span>(</span>F</span>,</span> G</span>,</span> H</span>):</span> pass</span></span>
10</span>I</span>.</span>mro</span>()</span></span>
11</span># [I, F, C, G, A, H, B, D, E, object]</span></span></code></pre>
</p>
To understand how this ordering is computed, let’s explore the C3 linearization algorithm.</p>
C3 Linearization Algorithm</h1>
C3 linearization works by merging the MRO of parent classes in a way that ensures consistent order and avoids method conflicts. Here’s how the algorithm works:</p>
Given a class C</code> with base classes B1</code>, B2</code>, ..., BN</code>, the MRO of C</code> is computed as:</p>
L</span>[</span>object</span>]</span> =</span> [</span>object</span>]</span></span>
L</span>[</span>C</span>(</span>B1</span>,</span> B2</span>,</span> ...</span>,</span> BN</span>)]</span> =</span> [</span>C</span>]</span> +</span> merge</span>(</span>L</span>[</span>B1</span>],</span> L</span>[</span>B2</span>],</span> ...</span>,</span> L</span>[</span>BN</span>], [</span>B1</span>,</span> B2</span>,</span> ...</span>,</span> BN</span>])</span></span></code></pre>
Where:</p>

L[X]</code> refers to the MRO of class X</code>.</li>
The merge</code> function takes the MROs of the parent classes and merges them, ensuring that no class appears before its superclass.</li>
</ul>
The steps in merging are as follows:</p>

Take the first element (head) of each list.</li>
Check the heads sequentially from left to right; a head is valid if it does not appear in the tail of any other list.</li>
If a valid head is found, select it as the next class in the MRO, remove it from all lists, and restart from the first head.</li>
If no valid head exists, Python raises an exception and refuses to create the class.</li>
</ol>
Now, let’s see how this works with the example I(F, G, H)</code>:</p>
L</span>[</span>I</span>]</span> =</span> [</span>I</span>]</span> +</span> merge</span>(</span>L</span>[</span>F</span>],</span> L</span>[</span>G</span>],</span> L</span>[</span>H</span>], [</span>F</span>,</span>G</span>,</span>H</span>])</span></span>
L</span>[</span>I</span>]</span> =</span> [</span>I</span>]</span> +</span> merge</span>([</span>F</span>,</span>C</span>,</span>A</span>,</span>B</span>,</span>obj</span>], [</span>G</span>,</span>A</span>,</span>D</span>,</span>obj</span>], [</span>H</span>,</span>B</span>,</span>D</span>,</span>E</span>,</span>obj</span>], [</span>F</span>,</span>G</span>,</span>H</span>])</span></span>
# F is not in the tail of any other list, so it is selected.</span></span>
L</span>[</span>I</span>]</span> =</span> [</span>I</span>,</span> F</span>]</span> +</span> merge</span>([</span>C</span>,</span>A</span>,</span>B</span>,</span>obj</span>], [</span>G</span>,</span>A</span>,</span>D</span>,</span>obj</span>], [</span>H</span>,</span>B</span>,</span>D</span>,</span>E</span>,</span>obj</span>], [</span>G</span>,</span>H</span>])</span></span>
# C is not in the tail of any other list, so it is selected.</span></span>
L</span>[</span>I</span>]</span> =</span> [</span>I</span>,</span> F</span>,</span> C</span>]</span> +</span> merge</span>([</span>A</span>,</span>B</span>,</span>obj</span>], [</span>G</span>,</span>A</span>,</span>D</span>,</span>obj</span>], [</span>H</span>,</span>B</span>,</span>D</span>,</span>E</span>,</span>obj</span>], [</span>G</span>,</span>H</span>])</span></span>
# A is in the tail of [G,A,D,obj], so we move to the next head.</span></span>
# G is not in the tail of any other list, so it is selected.</span></span>
L</span>[</span>I</span>]</span> =</span> [</span>I</span>,</span> F</span>,</span> C</span>,</span> G</span>]</span> +</span> merge</span>([</span>A</span>,</span>B</span>,</span>obj</span>], [</span>A</span>,</span>D</span>,</span>obj</span>], [</span>H</span>,</span>B</span>,</span>D</span>,</span>E</span>,</span>obj</span>], [</span>H</span>])</span></span>
# A is not in the tail of any other list, so it is selected.</span></span>
L</span>[</span>I</span>]</span> =</span> [</span>I</span>,</span> F</span>,</span> C</span>,</span> G</span>,</span> A</span>]</span> +</span> merge</span>([</span>B</span>,</span>obj</span>], [</span>D</span>,</span>obj</span>], [</span>H</span>,</span>B</span>,</span>D</span>,</span>E</span>,</span>obj</span>], [</span>H</span>])</span></span>
# B is in the tail of [H,B,D,E,obj], so we move to the next head.</span></span>
# D is in the tail of [H,B,D,E,obj], so we move to the next head.</span></span>
# H is not in the tail of any other list, so it is selected.</span></span>
L</span>[</span>I</span>]</span> =</span> [</span>I</span>,</span> F</span>,</span> C</span>,</span> G</span>,</span> A</span>,</span> H</span>]</span> +</span> merge</span>([</span>B</span>,</span>obj</span>], [</span>D</span>,</span>obj</span>], [</span>B</span>,</span>D</span>,</span>E</span>,</span>obj</span>])</span></span>
# B is not in the tail of any other list, so it is selected.</span></span>
L</span>[</span>I</span>]</span> =</span> [</span>I</span>,</span> F</span>,</span> C</span>,</span> G</span>,</span> A</span>,</span> H</span>,</span> B</span>]</span> +</span> merge</span>([</span>obj</span>], [</span>D</span>,</span>obj</span>], [</span>D</span>,</span>E</span>,</span>obj</span>])</span></span>
# obj is in the tail of [D,E,obj], so we move to the next head.</span></span>
# D is not in the tail of any other list, so it is selected.</span></span>
L</span>[</span>I</span>]</span> =</span> [</span>I</span>,</span> F</span>,</span> C</span>,</span> G</span>,</span> A</span>,</span> H</span>,</span> B</span>,</span> D</span>]</span> +</span> merge</span>([</span>obj</span>], [</span>obj</span>], [</span>E</span>,</span>obj</span>])</span></span>
# obj is in the tail of [E,obj], so we move to the next head.</span></span>
# E is not in the tail of any other list, so it is selected.</span></span>
L</span>[</span>I</span>]</span> =</span> [</span>I</span>,</span> F</span>,</span> C</span>,</span> G</span>,</span> A</span>,</span> H</span>,</span> B</span>,</span> D</span>,</span> E</span>]</span> +</span> merge</span>([</span>obj</span>], [</span>obj</span>], [</span>obj</span>])</span></span>
# obj is not in the tail of any other list, so it is selected.</span></span>
L</span>[</span>I</span>]</span> =</span> [</span>I</span>,</span> F</span>,</span> C</span>,</span> G</span>,</span> A</span>,</span> H</span>,</span> B</span>,</span> D</span>,</span> E</span>,</span> obj</span>]</span></span></code></pre>Conclusion</h1>
The Method Resolution Order (MRO) is a crucial part of Python’s object-oriented system, ensuring that methods are resolved in a consistent, predictable way, even when multiple inheritance is involved. By understanding the C3 linearization algorithm, you can confidently navigate and control method lookups in complex class hierarchies.</p>
I hope this guide has deepened your understanding of Python.</p>
References</h1>
The Python 2.3 Method Resolution Order</a></p>

Running the Application</h1>

References</h1> ASGI</a></p>
Uvicorn</a></p>

Basics of Type Hinting</h1>
You can annotate function arguments, return types, and variables using the `typing</code> module.</p>`

Advanced Type Hinting</h1>

References</h1>
Support for type hints</a></p>
Abstract Base Classes for Containers</a></p>

`References</h1> asyncio - Asynchronous I/O</a></p> Synchronization Primitives</a></p> Coroutines and Tasks</a></p>`

Practical Examples of Metaclass Usage</h1>

References</h1>
Data model</a></p>

References</h1>
The Python 2.3 Method Resolution Order</a></p>

CodeMemoirs

My journey and thoughts on AI as a Software Engineer

TIL: Gunicorn's gthread Worker Timeout Doesn't Work as Expected

Conclusion</h1>
If you're using Gunicorn with the `gthread</code> worker in production, I strongly suggest testing your timeout behavior to make sure it works as you expect.</p>`

`References</h1>Gunicorn's documentation</a></p>`

Building a Minimal ASGI Web Framework in Python

Mastering Type Hinting in Python

Asynchronous Python: Behind the Scenes with Asyncio

Metaclasses in Python: Mastering Class Creation and Customization

Understanding Python’s Method Resolution Order (MRO)

CodeMemoirs

My journey and thoughts on AI as a Software Engineer

TIL: Gunicorn's gthread Worker Timeout Doesn't Work as Expected

Conclusion</h1> If you're using Gunicorn with the gthread</code> worker in production, I strongly suggest testing your timeout behavior to make sure it works as you expect.</p>

Building a Minimal ASGI Web Framework in Python

Understanding ASGI</h1> ASGI applications are Python callables that accept three arguments:</p>

Creating the Core Framework</h1> A minimal ASGI framework needs:</p>

Mastering Type Hinting in Python

Basics of Type Hinting</h1> You can annotate function arguments, return types, and variables using the typing</code> module.</p>

Advanced Type Hinting</h1>

Unions and Optional Arguments</h2> For more complex scenarios where multiple types are valid you can use the |</code> operator:</p>

Asynchronous Python: Behind the Scenes with Asyncio

A Quick Dive into Asyncio</h1> At its core, asyncio</code> allows you to define asynchronous tasks using async def</code> functions. These tasks are then scheduled and run on an event loop. Here's a breakdown of key concepts:</p>

Metaclasses in Python: Mastering Class Creation and Customization

Practical Examples of Metaclass Usage</h1>

References</h1> Data model</a></p>

Understanding Python’s Method Resolution Order (MRO)

References</h1> The Python 2.3 Method Resolution Order</a></p>

Conclusion</h1>
If you're using Gunicorn with the `gthread</code> worker in production, I strongly suggest testing your timeout behavior to make sure it works as you expect.</p>`

Basics of Type Hinting</h1>
You can annotate function arguments, return types, and variables using the `typing</code> module.</p>`

References</h1>
Data model</a></p>

References</h1>
The Python 2.3 Method Resolution Order</a></p>