Add futures and loop inspections.

Author: toddbirchard

asyncio_tutorial/__init__.py

@@ -3,11 +3,16 @@
 
 from asyncio_tutorial.logger import LOGGER
 
-from .part_I_asyncio_intro import intro_tutorial
+from .part_I_asyncio_intro import asyncio_intro_tutorial
 from .part_II_aiohttp_aiofiles import aiohttp_aiofiles_tutorial
 
 
 def init_script():
-    asyncio.run(intro_tutorial())
-    LOGGER.info("-------------------------------------------")
+    """
+    Run source code found in Hackersandslackers asyncio tutorials.
+
+    1. Intro to Async Python: https://hackersandslackers.com/python-concurrency-asyncio/
+    2. Intro to Async Python: https://hackersandslackers.com/async-requests-with-aiohttp/
+    """
+    asyncio.run(asyncio_intro_tutorial())
     asyncio.run(aiohttp_aiofiles_tutorial())

asyncio_tutorial/part_II_aiohttp_aiofiles/__init__.py

@@ -7,26 +7,17 @@
 from config import EXPORT_DIR, HTML_HEADERS
 from data import urls
 
+from .futures import register_future
+from .loops import inspect_event_loop
 from .tasks import create_tasks
 
 
 async def aiohttp_aiofiles_tutorial():
     """Open async HTTP session & execute created tasks."""
     LOGGER.info(f"Asyncio tutorial Part II: HTTP Requests with Aiohttp & Aiofiles.")
+    future = register_future()
     async with ClientSession(headers=HTML_HEADERS) as session:
         tasks = await create_tasks(session, urls, EXPORT_DIR)
+        inspect_event_loop()
         await asyncio.gather(*tasks)
-        await inspect_loop()
-        LOGGER.success(f"Saved {len(urls)} files to `{EXPORT_DIR}`")
-
-
-async def inspect_loop() -> str:
-    """
-    Get event loop info.
-
-    :param: List[Task] tasks
-
-    :return: str
-    """
-    loop = asyncio.get_event_loop()
-    return LOGGER.info(f"Loop finished in {loop.time()} seconds.")
+    future.set_result(f"Saved {len(urls)} files to `{EXPORT_DIR}`")

asyncio_tutorial/part_II_aiohttp_aiofiles/futures.py

@@ -0,0 +1,26 @@
+"""Create a Future (callback): an action to be taken when loop is completed."""
+import asyncio
+from asyncio import Future
+
+from asyncio_tutorial.logger import LOGGER
+
+
+def register_future() -> Future:
+    """
+    Create a Future to log when loop is completed.
+
+    :returns: Future
+    """
+    loop = asyncio.get_event_loop()
+    future = loop.create_future()
+    future.add_done_callback(loop_completed)
+    return future
+
+
+def loop_completed(result: str):
+    """
+    Callback to be called when loop is complete.
+
+    :param str result: Simple string describing the state of the loop
+    """
+    LOGGER.success(result)

asyncio_tutorial/part_II_aiohttp_aiofiles/loops.py

@@ -0,0 +1,13 @@
+import asyncio
+
+from asyncio_tutorial.logger import LOGGER
+
+
+def inspect_event_loop():
+    """Get event loop info."""
+    loop = asyncio.get_event_loop()
+    thread_id = loop.__dict__.get("_thread_id")
+    if loop.is_running():
+        LOGGER.info(
+            f"Loop has been running {loop.time()} seconds. (Thread ID #{thread_id})"
+        )

asyncio_tutorial/part_I_asyncio_intro/__init__.py

@@ -4,16 +4,19 @@
 from asyncio_tutorial.logger import LOGGER
 
 from .coroutines import simple_coroutine
+from .futures import register_future
+from .loops import inspect_event_loop
 from .tasks import create_task
 
 
-async def intro_tutorial():
+async def asyncio_intro_tutorial():
     """Simple demonstration of a async script lifecycle"""
     LOGGER.info(f"Asyncio tutorial Part I: Intro to Asyncio.")
     tasks = []
+    future = register_future()
     for i in range(3):
         task = await create_task(simple_coroutine(i, delay=1))
         tasks.append(task)
-        LOGGER.info(type(task))
+    inspect_event_loop()
     await asyncio.gather(*tasks)
-    LOGGER.info("-------------------------------------------")
+    future.set_result("Done")

asyncio_tutorial/part_I_asyncio_intro/coroutines.py

@@ -6,7 +6,7 @@
 
 async def simple_coroutine(number: int, delay=1):
     """
-    Wait for a period of time before logging the coro number.
+    Wait for a time delay, log number associated with the coroutine.
 
     :param int number: Number to identify the current coroutine.
     :param int delay: Time delay to simulate a function which takes time to complete.

asyncio_tutorial/part_I_asyncio_intro/futures.py

@@ -0,0 +1,29 @@
+"""Create a Future (callback): an action to be taken when loop is completed."""
+import asyncio
+from asyncio import Future
+
+from asyncio_tutorial.logger import LOGGER
+
+
+def register_future() -> Future:
+    """
+    Create a Future to log when loop is completed.
+
+    :returns: Future
+    """
+    loop = asyncio.get_event_loop()
+    future = loop.create_future()
+    future.add_done_callback(loop_completed)
+    return future
+
+
+def loop_completed(result: str):
+    """
+    Callback to be called when loop is complete.
+
+    :param str result: Simple string describing the state of the loop
+    """
+    LOGGER.success(
+        f"Loop completed with result: {result} \
+    \n-------------------------------------------------"
+    )

asyncio_tutorial/part_I_asyncio_intro/loops.py

@@ -0,0 +1,13 @@
+import asyncio
+
+from asyncio_tutorial.logger import LOGGER
+
+
+def inspect_event_loop():
+    """Get event loop info."""
+    loop = asyncio.get_event_loop()
+    thread_id = loop.__dict__.get("_thread_id")
+    if loop.is_running():
+        LOGGER.info(
+            f"Loop has been running {loop.time()} seconds. (Thread ID #{thread_id})"
+        )

asyncio_tutorial/part_I_asyncio_intro/tasks.py

@@ -2,8 +2,6 @@
 import asyncio
 from asyncio import Task
 
-from asyncio_tutorial.logger import LOGGER
-
 
 async def create_task(coroutine) -> Task:
     """
@@ -13,5 +11,4 @@ async def create_task(coroutine) -> Task:
 
     :returns: Task
     """
-    LOGGER.info(type(coroutine))
     return asyncio.create_task(coroutine)

data/__init__.py

@@ -1,6 +1,6 @@
 """Parse data from local files."""
-from .parser import parse_urls
 from config import CSV_FILEPATH
 
+from .parser import parse_urls
 
-urls = parse_urls(CSV_FILEPATH)
+urls = parse_urls(CSV_FILEPATH)