init and async functions

Author: Kinetics20

.gitignore

@@ -0,0 +1,11 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+.idea

.python-version

@@ -0,0 +1 @@
+3.13

README.md

@@ -0,0 +1,36 @@
+# 🐍 Python Async Programming Sessions
+
+A repository for exploring **asynchronous programming in Python**. This collection of examples demonstrates various concurrency models, ranging from simple synchronous HTTP requests to advanced async patterns using decorators, futures, and more.
+
+## What is Asynchronous Programming?
+
+Asynchronous programming enables you to write non-blocking, concurrent code using constructs like `async/await` and event loops. It is ideal for I/O-bound tasks and improves the performance of network and parallel operations without relying solely on multi-threading or multi-processing.
+
+## Key Imports & Modules
+
+These examples utilize several Python modules, including:
+
+- **Core Async Tools:** `asyncio`
+- **HTTP Clients:** `aiohttp`, `requests`
+- **Concurrency:** `threading`, `multiprocessing`
+- **Utilities:** `time`, `functools`, `os`
+
+## Examples Included
+
+- **Synchronous Requests:**  
+  Simple HTTP requests using the `requests` library.
+
+- **Threading & Multiprocessing:**  
+  Demonstrations of running tasks concurrently using threads and processes.
+
+- **Asyncio Basics:**  
+  Creating async functions, using `asyncio.sleep`, and managing tasks with the event loop.
+
+- **Advanced Async Techniques:**  
+  Handling timeouts, cancellation, and using custom decorators (e.g., for timing execution).
+
+---
+
+👤 **Author:** Piotr Lipinski  
+🗓 **Date:** March 2025  
+💬 **Feedback:** Contributions and suggestions are welcome!

intro/__init__.py

@@ -0,0 +1,13 @@
+import requests
+
+response = requests.get("http://www.example.com")
+
+
+items = response.headers.items()
+
+headers = [f'{key}: header{header}' for key, header in items]
+
+formatted_headers = '\n'.join(headers)
+
+with open('headers.txt', 'w') as file:
+    file.write(formatted_headers)

intro/example_1.py

@@ -0,0 +1,10 @@
+from asyncio import Future
+
+my_future: Future = Future()
+
+print(f'Is my_future done? {my_future.done()}')
+
+my_future.set_result(42)
+
+print(f'Is my_future done? {my_future.done()}')
+print(f'What is the result of my_future? {my_future.result()}')

intro/example_10.py

@@ -0,0 +1,24 @@
+from asyncio import Future
+import asyncio
+
+
+def make_request() -> Future:
+    future: Future = Future()
+    asyncio.create_task(set_future_value(future))
+    return future
+
+
+async def set_future_value(future: Future) -> None:
+    await asyncio.sleep(1)
+    future.set_result(42)
+
+
+async def main() -> None:
+    future = make_request()
+    print(f'Is the future done? {future.done()}')
+    value = await future
+    print(f'Is the future done? {future.done()}')
+    print(value)
+
+
+asyncio.run(main())

intro/example_11.py

@@ -0,0 +1,21 @@
+import asyncio
+
+from util import async_timed
+
+
+@async_timed()
+async def delay(delay_second: int) -> int:
+    print(f'sleeping for {delay_second} seconds')
+    await asyncio.sleep(delay_second)
+    print(f'finishing for {delay_second} seconds')
+    return delay_second
+
+@async_timed()
+async def main() -> None:
+    task_one = asyncio.create_task(delay(2))
+    task_two = asyncio.create_task(delay(3))
+
+    await task_one
+    await task_two
+
+asyncio.run(main())

intro/example_12.py

@@ -0,0 +1,21 @@
+import asyncio
+from util import async_timed
+
+
+@async_timed()
+async def cpu_bound_work() -> int:
+    counter = 0
+    for i in range(100000000):
+        counter = counter + 1
+    return counter
+
+
+@async_timed()
+async def main() -> None:
+    task_one = asyncio.create_task(cpu_bound_work())
+    task_two = asyncio.create_task(cpu_bound_work())
+    await task_one
+    await task_two
+
+
+asyncio.run(main())

intro/example_13.py

@@ -0,0 +1,23 @@
+import asyncio
+from util import async_timed, delay
+
+
+@async_timed()
+async def cpu_bound_work() -> int:
+    counter = 0
+    for i in range(100000000):
+        counter = counter + 1
+    return counter
+
+
+@async_timed()
+async def main() -> None:
+    task_one = asyncio.create_task(cpu_bound_work())
+    task_two = asyncio.create_task(cpu_bound_work())
+    task_three = asyncio.create_task(delay(4))
+    await task_one
+    await task_two
+    await task_three
+
+
+asyncio.run(main())

intro/example_14.py

@@ -0,0 +1,13 @@
+async def coroutine_add_one(number: int) -> int:
+    return number + 1
+
+
+def add_one(number: int) -> int:
+    return number + 1
+
+
+function_result = add_one(1)
+coroutine_result = coroutine_add_one(1)
+
+print(f'Function result is {function_result} and the type is {type(function_result)}')
+print(f'Coroutine result is {coroutine_result} and the type is {type(coroutine_result)}')

intro/example_15.py

@@ -0,0 +1,20 @@
+import asyncio
+import requests
+from util import async_timed
+
+
+@async_timed()
+async def get_example_status() -> int:
+    return requests.get('https://www.example.com').status_code
+
+
+@async_timed()
+async def main() -> None:
+    task_1 = asyncio.create_task(get_example_status())
+    task_2 = asyncio.create_task(get_example_status())
+    task_3 = asyncio.create_task(get_example_status())
+    await task_1
+    await task_2
+    await task_3
+
+asyncio.run(main())

intro/example_16.py

@@ -0,0 +1,12 @@
+import asyncio
+
+async def main() -> None:
+    await asyncio.sleep(1)
+
+loop = asyncio.new_event_loop()
+
+try:
+    loop.run_until_complete(main())
+finally:
+    loop.close()
+

intro/example_17.py

@@ -0,0 +1,15 @@
+import asyncio
+
+from util import delay
+
+
+def call_later() -> None:
+    print("Calling in future")
+
+async def main() -> None:
+    loop = asyncio.get_running_loop()
+    loop.call_soon(call_later)
+    await delay(1)
+    await delay(2)
+
+asyncio.run(main())

intro/example_18.py

@@ -0,0 +1,24 @@
+import os
+import threading
+
+
+
+def hello() -> None:
+    # sleep(3)
+    print(f'Hello from {threading.current_thread()}')
+
+t1 = threading.Thread(target=hello)
+t1.start()
+
+
+print(f'Python process running with id: {os.getpid()}')
+
+
+
+total_threads = threading.active_count()
+thread_name = threading.current_thread().name
+
+print(f'Total threads : {total_threads}')
+print(f'Current thread name: {thread_name}')
+
+t1.join()

intro/example_2.py

@@ -0,0 +1,16 @@
+import multiprocessing
+import os
+
+
+def hello() -> None:
+    print(f'Hello from {os.getpid()}')
+
+if __name__ == '__main__':
+    p1 = multiprocessing.Process(target=hello)
+    p1.start()
+    print(f'Hello from {os.getpid()}')
+    p1.join()
+
+
+
+

intro/example_3.py

@@ -0,0 +1,35 @@
+import threading
+import time
+
+def print_fib(number: int) -> None:
+    def fib(n: int) -> int:
+        if n == 1:
+            return 1
+        if n == 2:
+            return 1
+        else:
+            return fib(n - 1) + fib(n - 2)
+
+    print(f'fib({number}) = {fib(number)}')
+
+def fibs_no_threading() -> None:
+    print_fib(40)
+    print_fib(41)
+
+def fibs_with_threading() -> None:
+    t1 = threading.Thread(target=print_fib, args=(40,))
+    t2 = threading.Thread(target=print_fib, args=(41,))
+
+    t1.start()
+    t2.start()
+
+    t1.join()
+    t2.join()
+
+
+start = time.time()
+fibs_with_threading()
+# fibs_no_threading()
+end = time.time()
+
+print(f'Completed in {end - start} seconds')

intro/example_4_fib_.py

@@ -0,0 +1,6 @@
+async def my_coroutine() -> None:
+    print('Hello world')
+
+
+print(my_coroutine())
+

intro/example_5.py

@@ -0,0 +1,22 @@
+import asyncio
+
+async def delay(delay_second: int) -> int:
+    print(f'sleeping for {delay_second} seconds')
+    await asyncio.sleep(delay_second)
+    print(f'finishing for {delay_second} seconds')
+    return delay_second
+
+async def hello_every_second() -> None:
+    for i in range(2):
+        await asyncio.sleep(1)
+        print('Running other code while I am waiting')
+
+
+async def main():
+    first_delay = asyncio.create_task(delay(3))
+    second_delay = asyncio.create_task(delay(3))
+    await hello_every_second()
+    await first_delay
+    await second_delay
+
+asyncio.run(main())

intro/example_6.py

@@ -0,0 +1,26 @@
+import asyncio
+
+
+from util import delay
+
+
+async def main() -> None:
+    long_task = asyncio.create_task(delay(10))
+
+    seconds_elapsed = 0
+
+    while not long_task.done():
+        print('Task not finished')
+        await asyncio.sleep(1)
+        seconds_elapsed += 1
+        if seconds_elapsed > 5:
+            long_task.cancel()
+
+    try:
+        await long_task
+    except asyncio.CancelledError:
+        print('Cancelled')
+
+
+asyncio.run(main())
+

intro/example_7.py

@@ -0,0 +1,20 @@
+import asyncio
+
+
+from util import delay
+
+
+async def main() -> None:
+    long_task = asyncio.create_task(delay(10))
+
+    try:
+        result = await asyncio.wait_for(long_task, timeout=1)
+        print(result)
+    except asyncio.TimeoutError:
+        print("Timed out")
+        print(long_task.cancelled())
+
+
+
+asyncio.run(main())
+