Merge pull request #10 from aligheshlaghi97/feat/ch8-9

Feat/ch8 9

Author: aligheshlaghi97

README.md

@@ -2,15 +2,24 @@
 
 Welcome to the Async Python Playground repository! 🚀
 
-This repository serves as a comprehensive resource for learning about asynchronous programming in Python, with a focus on the asyncio module and the latest features introduced in Python 3.11, 3.12 and 3.13. Whether you're a beginner looking to dive into async programming or an experienced developer seeking to explore advanced techniques, this repository has something for everyone.
+This repository is a comprehensive guide to mastering asynchronous programming in Python,
+covering core concepts, practical tools, and advanced techniques. 
+From the fundamentals of asyncio to alternative libraries like AnyIO and Trio,
+as well as task scheduling solutions such as Celery and APScheduler,
+this repository provides a one-stop resource for exploring the async Python ecosystem.
+
+Whether you're a beginner eager to dive into async programming
+or an experienced developer looking to refine your skills and explore emerging patterns,
+this repository has you covered.
+
 
 ## Key Features:
 
-**Structured Content:** Explore a curated collection of code examples, tutorials, and explanations covering a wide range of async Python topics.<br />
-**Clear Documentation:** Each example is accompanied by detailed documentation, guiding you through the concepts, syntax, and best practices of async programming.<br />
-**Python latest versions Coverage:** Discover the newest capabilities of async related Python 3.11, 3.12 and 3.13 and how they enhance async programming in Python.<br />
-**Interactive Learning:** Experiment with the provided code examples and gain hands-on experience with async Python in action.<br />
-**Community Engagement:** Join a growing community of developers interested in async Python, contribute your own examples, and collaborate with others to explore async programming further.<br />
+**Structured Content:** Tutorials and examples covering a wide range of async Python topics.<br />
+**Clear Documentation:** Detailed explanations to help you understand concepts and best practices.<br />
+**Latest Python Features:** Highlights of async improvements in Python 3.11, 3.12, and 3.13.<br />
+**Hands-On Learning:** Try out code examples to build practical async skills.<br />
+**Collaborative Community:** Share ideas and contribute to the growing async Python ecosystem.<br />
 
 ## Documentation
 For full documentation, including tutorials and examples, visit the

_includes/sidebar.html

@@ -2,12 +2,51 @@
     <h2>Navigation</h2>
     <ul>
         <li><a href="{{ '/' | relative_url }}">Home</a></li>
-        <li><a href="{{ '/chapter1/' | relative_url }}">Chapter 1: Introduction to Asynchronous Programming</a></li>
-        <li><a href="{{ '/chapter2/' | relative_url }}">Chapter 2: Getting Started with asyncio</a></li>
-        <li><a href="{{ '/chapter3/' | relative_url }}">Chapter 3: Handling CPU and I/O Bound Tasks</a></li>
-        <li><a href="{{ '/chapter4/' | relative_url }}">Chapter 4: Synchronization and Coordination</a></li>
-        <li><a href="{{ '/chapter5/' | relative_url }}">Chapter 5: Advanced Techniques</a></li>
-        <li><a href="{{ '/chapter6/' | relative_url }}">Chapter 6: Exploring Features of New Python Versions</a></li>
-        <li><a href="{{ '/chapter7/' | relative_url }}">Chapter 7: Web Applications</a></li>
+        <li>
+            <a href="{{ '/chapter1/' | relative_url }}"
+                >Chapter 1: Introduction to Asynchronous Programming</a
+            >
+        </li>
+        <li>
+            <a href="{{ '/chapter2/' | relative_url }}"
+                >Chapter 2: Getting Started with asyncio</a
+            >
+        </li>
+        <li>
+            <a href="{{ '/chapter3/' | relative_url }}"
+                >Chapter 3: Handling CPU and I/O Bound Tasks</a
+            >
+        </li>
+        <li>
+            <a href="{{ '/chapter4/' | relative_url }}"
+                >Chapter 4: Synchronization and Coordination</a
+            >
+        </li>
+        <li>
+            <a href="{{ '/chapter5/' | relative_url }}"
+                >Chapter 5: Advanced Techniques</a
+            >
+        </li>
+        <li>
+            <a href="{{ '/chapter6/' | relative_url }}"
+                >Chapter 6: Exploring Features of New Python Versions</a
+            >
+        </li>
+        <li>
+            <a href="{{ '/chapter7/' | relative_url }}"
+                >Chapter 7: Web Applications</a
+            >
+        </li>
+        <li>
+            <a href="{{ '/chapter8/' | relative_url }}"
+                >Chapter 8: Introduction to AnyIO and Trio</a
+            >
+        </li>
+        <li>
+            <a href="{{ '/chapter9/' | relative_url }}"
+                >Chapter 9: Task Scheduling and Queues: Celery and
+                APScheduler</a
+            >
+        </li>
     </ul>
 </div>

docs/8. Introduction to AnyIO and Trio/ex_8_1.py

@@ -0,0 +1,19 @@
+import asyncio
+
+
+async def coro_a():
+    await asyncio.sleep(0.2)
+
+
+async def coro_b():
+    await asyncio.sleep(0.1)
+
+
+async def fn():
+    task_a = asyncio.create_task(coro_a())
+    task_b = asyncio.create_task(coro_b())
+
+    return await task_a
+
+
+asyncio.run(fn())

docs/8. Introduction to AnyIO and Trio/ex_8_2.py

@@ -0,0 +1,20 @@
+import asyncio
+
+
+async def sleep_coro(delay):
+    print(f"Started sleeping for {delay} seconds!")
+    await asyncio.sleep(delay)
+    print(f"Finished sleeping for {delay} seconds!")
+    return delay
+
+
+async def main():
+    print('Before running task group!')
+    async with asyncio.TaskGroup() as tg:
+        task_a = tg.create_task(sleep_coro(2))
+        task_b = tg.create_task(sleep_coro(1))
+    print("After running task group!")
+    print("Both tasks finished!")
+    print(f"Results are: (task_a: {task_a.result()}, task_b: {task_b.result()})")
+
+asyncio.run(main())

docs/8. Introduction to AnyIO and Trio/ex_8_3.py

@@ -0,0 +1,30 @@
+import trio
+
+
+async def child1():
+    print("  child1: started! sleeping now...")
+    await trio.sleep(1)
+    print("  child1: exiting!")
+
+
+async def child2():
+    print("  child2: started! sleeping now...")
+    await trio.sleep(1)
+    print("  child2: exiting!")
+
+
+async def parent():
+    print("parent: started!")
+    async with trio.open_nursery() as nursery:
+        print("parent: spawning child1...")
+        nursery.start_soon(child1)
+
+        print("parent: spawning child2...")
+        nursery.start_soon(child2)
+
+        print("parent: waiting for children to finish...")
+        # -- we exit the nursery block here --
+    print("parent: all done!")
+
+
+trio.run(parent)

docs/8. Introduction to AnyIO and Trio/ex_8_4.py

@@ -0,0 +1,25 @@
+import trio
+
+
+async def main():
+    async with trio.open_nursery() as nursery:
+        send_channel, receive_channel = trio.open_memory_channel(0)
+        nursery.start_soon(producer, send_channel)
+        nursery.start_soon(consumer, receive_channel)
+    print("Done!")
+
+
+async def producer(send_channel):
+    async with send_channel:
+        for value in range(5):
+            await trio.sleep(1)
+            await send_channel.send(value)
+
+
+async def consumer(receive_channel):
+    async with receive_channel:
+        async for value in receive_channel:
+            print(f"Got number {value}")
+
+
+trio.run(main)

docs/8. Introduction to AnyIO and Trio/ex_8_5.py

@@ -0,0 +1,17 @@
+from anyio import sleep, create_task_group, run
+
+
+async def sometask(num: int) -> None:
+    print('Task', num, 'running')
+    await sleep(1)
+    print('Task', num, 'finished')
+
+
+async def main() -> None:
+    async with create_task_group() as tg:
+        for num in range(5):
+            tg.start_soon(sometask, num)
+
+    print('All tasks finished!')
+
+run(main)

docs/8. Introduction to AnyIO and Trio/ex_8_6.py

@@ -0,0 +1,26 @@
+import anyio
+
+
+async def producer(sender):
+    async with sender:
+        for value in range(5):
+            await sender.send(value)
+            await anyio.sleep(1)
+
+
+async def consumer(receiver):
+    async with receiver:
+        async for value in receiver:
+            print(f'Got number {value}')
+            await anyio.sleep(1)
+
+
+async def main():
+    sender, receiver = anyio.create_memory_object_stream()
+    async with anyio.create_task_group() as tg:
+        async with sender, receiver:
+            tg.start_soon(producer, sender.clone())
+            tg.start_soon(consumer, receiver.clone())
+
+
+anyio.run(main)

docs/8. Introduction to AnyIO and Trio/ex_8_7.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+import anyio
+from anyio import to_thread
+
+
+def print_dir_content():
+    current_dir = Path.cwd()
+    for file in current_dir.iterdir():
+        print(file)
+
+
+async def display_dir_content(event):
+    await to_thread.run_sync(print_dir_content)
+    event.set()
+
+
+async def wait_print_finished(event):
+    print('wait dir printing is finished')
+    await event.wait()
+    print('finished!')
+
+
+async def main():
+    event = anyio.Event()
+    async with anyio.create_task_group() as tg:
+        tg.start_soon(display_dir_content, event)
+        tg.start_soon(wait_print_finished, event)
+
+
+anyio.run(main)

docs/8. Introduction to AnyIO and Trio/index.md

@@ -0,0 +1,118 @@
+---
+layout: default
+title: "Chapter 8: Introduction to AnyIO and Trio"
+permalink: /chapter8/
+---
+
+# Introduction to AnyIO and Trio
+## What Are AnyIO and Trio?
+Let's imagine that our primary objective is achieving concurrency for I/O bound tasks.
+While we have been exploring `asyncio` in Python to support this goal,
+additional tools such as `anyio` and `trio` offer valuable alternatives for enhancing I/O parallelism
+which leverage the benefits of the `Structured Concurrency` design pattern.
+Their appeal lies in their user-friendly nature, enhanced features, and reduced learning curve,
+making them attractive options for improving task efficiency.
+
+### Why to use them?
+
+ - **Improved Developer Productivity**: Simplified APIs and tools reduce the learning curve and development time.
+
+ - **Cross-Framework Compatibility**: AnyIO ensures that our code can run on different async backends without modification.
+
+ - **Enhanced Safety**: Trio’s structured concurrency model reduces the likelihood of subtle bugs in concurrent code.
+
+
+
+## Structured Concurrency Design Pattern
+As Jan Plesnik explains [here](https://applifting.io/blog/python-structured-concurrency),
+to avoid orphaned tasks—tasks that lose their reference—we need to embrace structured concurrency.
+In Python 3.11, the introduction of `asyncio.TaskGroup` provides a way to manage this effectively.
+Similarly, Trio offers nurseries, which serve the same purpose.
+An example of an orphaned task can be seen in the following case, where `task_b` loses its reference.
+(Example from Jan's article.)
+
+```python
+# ex_8_1
+{% include_relative ex_8_1.py %}
+```
+This image illustrates what happens under the hood
+(from [here](https://belief-driven-design.com/looking-at-java-21-structured-concurrency-39a81/)):
+![test1](https://github.com/user-attachments/assets/48215a3a-538f-4a0b-8143-34268958d794)
+
+And now imagine this example with `asyncio.TaskGroup` (which is similar to example_2_8).
+As you see, both `task_a` and `test_b` will finish and then the task-group context manager exits.
+
+```python
+# ex_8_2
+{% include_relative ex_8_2.py %}
+```
+
+And now we have full control over tasks and this is how it will look like.
+![test2](https://github.com/user-attachments/assets/3d82ae86-3fc2-42e6-b342-94bfea9f342b)
+
+## Exploring Trio
+`Trio`'s primary aim is to simplify the comprehension and enhance the performance of concurrency operations.
+It offers a more efficient GIL and higher-level APIs, resulting in code that is easier to understand and troubleshoot.
+
+Now let's see our first example from [trio's official document](https://trio.readthedocs.io/en/stable/)
+and get familiar with it.
+As you can see, there is a parent async function which uses nurseries to spawn two child tasks and run them.
+```python
+# ex_8_3
+{% include_relative ex_8_3.py %}
+```
+
+A very interesting topic would be to see how `consumer-producer` is handled in `trio`, described in official document
+[here](https://trio.readthedocs.io/en/stable/reference-core.html#using-channels-to-pass-values-between-tasks)
+and compare it with our `ex_5_5`, a consumer-producer variant in `asyncio`.
+`open_memory_channel` is an API used to create queue and manage consumer-producer in `trio`.
+Let's rewrite our `ex_5_5` in `trio` syntax:
+```python
+# ex_8_4
+{% include_relative ex_8_4.py %}
+```
+By utilizing `open_memory_channel`, we get two channels initiated and then call consumer/producer with their respective channels.
+Also, the `consumer` and `producer` async functions contain a context manager to signal the completion of the production/consumption processes.
+
+
+## Getting Started with AnyIO
+AnyIO is a handy library that makes async programming easier by letting you write code that works with both `asyncio` and `Trio`.
+It hides the differences between these frameworks, so your code runs smoothly no matter which event loop you use.
+
+
+The starter example from [AnyIO official document](https://anyio.readthedocs.io/en/stable/tasks.html#creating-and-managing-tasks) is provided here:
+```python
+# ex_8_5
+{% include_relative ex_8_5.py %}
+```
+
+It runs on top of `asyncio` and if you want to run it on top of `Trio` just do this in run section:
+```python
+run(main, backend='trio')
+```
+
+
+And let's see a typical `consumer-producer` pattern in `AnyIO` which  looks like `Trio`'s example:
+```python
+# ex_8_6
+{% include_relative ex_8_6.py %}
+```
+
+If you want to do some blocking task, `anyio.to_thread` API seem do to a good job.
+One example would be to read the file names in the current path.
+[from this article](https://lewoudar.medium.com/anyio-all-you-need-for-async-programming-stuff-4cd084d0f6bd)
+```python
+# ex_8_7
+{% include_relative ex_8_7.py %}
+```
+
+## When to Choose AnyIO or Trio for Your Projects
+Choosing between AnyIO and Trio often depends on the goals of your project:
+
+ - **AnyIO** is perfect when you need a framework-agnostic approach,
+ letting you write code compatible with `asyncio` and `Trio`.
+ - **Trio** shines when you want a structured concurrency model
+ with a focus on reliability and simplicity.
+
+If you're already familiar with `asyncio`, `AnyIO` offers a smooth transition to explore `Trio`'s advantages.
+If you're starting fresh, `Trio`’s user-friendly design makes it a great first choice.