async-timer 1.1.0__tar.gz → 1.1.1__tar.gz

{async_timer-1.1.0 → async_timer-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: async-timer
-Version: 1.1.0
+Version: 1.1.1
 Summary: The missing Python async timer.
 License: MIT
 Keywords: async,timer

{async_timer-1.1.0 → async_timer-1.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "async-timer"
-version = "v1.1.0"
+version = "v1.1.1"
 description = "The missing Python async timer."
 authors = ["Ilya O. <vrghost@gmail.com>"]
 license = "MIT"

async_timer-1.1.1/src/async_timer/__init__.py

@@ -0,0 +1,2 @@
+from . import pacemaker, timer, traget_caller
+from .timer import Timer

{async_timer-1.1.0 → async_timer-1.1.1}/src/async_timer/timer.py

@@ -1,6 +1,5 @@
 """Utility async io functions"""
 import asyncio
-import inspect
 import logging
 import time
 import typing
@@ -14,6 +13,8 @@ TimerMainTaskT = typing.Union[
     typing.Callable[[], typing.Coroutine[typing.Any, typing.Any, T]],
     typing.Callable[[], typing.AsyncGenerator[T, typing.Any]],
     typing.Callable[[], typing.Generator[T, typing.Any, typing.Any]],
+    typing.AsyncGenerator[T, typing.Any],
+    typing.Generator[T, typing.Any, typing.Any],
 ]
 TimerCallbackT = typing.Callable[["Timer[T]", TimerMainTaskT[T]], None]
 
@@ -95,7 +96,7 @@ class Timer(typing.Generic[T]):
                             one resolving cancels the timer
         """
         self.iterator = async_timer.pacemaker.TimerPacemaker(delay)
-        self.target = target
+        self.target_caller = async_timer.traget_caller.Caller(target)
         self.result_fanout = FanoutRv()
         self.exception_callback = exc_cb
         self.cancel_callback = cancel_cb
@@ -189,63 +190,24 @@ class Timer(typing.Generic[T]):
         except asyncio.CancelledError as err:
             raise StopAsyncIteration() from err
 
-    def _maybe_detect_generator(
-        self, target_rv
-    ) -> typing.Tuple[T, typing.Callable[[], T]]:
-        """Check if the value returned by the `self.target` call is a
-        kind of generator (sync or async).
-
-        Returns a (this_iter_rv, new_callable) tuple
-        """
-        if inspect.isgenerator(target_rv):
-
-            def _lock_sync_gen_ctx(gen_src):
-                return lambda: next(gen_src)
-
-            get_next_val = _lock_sync_gen_ctx(target_rv)
-            rv = (get_next_val(), get_next_val)
-        elif inspect.isasyncgen(target_rv):
-
-            def _lock_async_gen_ctx(gen_src):
-                return lambda: gen_src.__anext__()
-
-            get_next_val = _lock_async_gen_ctx(target_rv)
-            rv = (get_next_val(), get_next_val)
-        else:
-            rv = (target_rv, None)
-        return rv
-
     async def _loop_callback_routine(self):
-        get_next_val = self.target
-        first_iter = True
         try:
             async for _ in self.iterator:
                 try:
-                    next_val = get_next_val()
-                    if first_iter:
-                        (next_val, updated_get_next_val) = self._maybe_detect_generator(
-                            next_val
-                        )
-                        if updated_get_next_val is not None:
-                            get_next_val = updated_get_next_val
-                    if inspect.isawaitable(next_val):
-                        rv = await next_val
-                    else:
-                        rv = next_val
-                except (StopIteration, StopAsyncIteration):
+                    rv = await self.target_caller.next()
+                except StopAsyncIteration:
                     break
                 except Exception as err:
                     await self.result_fanout.send_exception(err)
-                    self.exception_callback(self, self.target)
+                    self.exception_callback(self, self.target_caller.target)
                     break
                 else:
                     await self.result_fanout.send_result(rv)
-                first_iter = False
                 self.hit_count += 1
         finally:
             # Main loop finished - cancel all watchers
             await self.result_fanout.cancel()
-            self.cancel_callback(self, self.target)
+            self.cancel_callback(self, self.target_caller.target)
 
     async def cancel(self):
         """Unshedule the timer"""
@@ -261,7 +223,8 @@ class Timer(typing.Generic[T]):
 
     def __repr__(self) -> str:
         return (
-            f"<{self.__class__.__name__} target={self.target!r} delay={self.delay!r}"
+            f"<{self.__class__.__name__} target={self.target_caller.target!r}"
+            f" delay={self.delay!r}"
             f" hit_count={self.hit_count!r}"
             f" exception_callback={self.exception_callback!r}"
             f" cancel_callback={self.cancel_callback!r}"

async_timer-1.1.1/src/async_timer/traget_caller.py

@@ -0,0 +1,70 @@
+"""This module is responsible for the magic behaviour calling the `target` function."""
+
+import inspect
+from collections.abc import Iterator
+
+
+class Caller:
+    target = None
+    get_next_val = None
+    first_call: bool = True
+
+    def __init__(self, target):
+        self.target = target
+
+    def _wrap_generator(self, maybe_gen):
+        if inspect.isgenerator(maybe_gen):
+
+            def _lock_sync_gen_ctx():
+                return lambda: next(maybe_gen)
+
+            gen_next_val = _lock_sync_gen_ctx()
+        elif inspect.isasyncgen(maybe_gen):
+
+            def _lock_async_gen_ctx():
+                return lambda: maybe_gen.__anext__()
+
+            gen_next_val = _lock_async_gen_ctx()
+        elif isinstance(maybe_gen, Iterator):
+
+            def _lock_iterator_ctx():
+                return next(maybe_gen)
+
+            gen_next_val = _lock_iterator_ctx
+        else:
+            gen_next_val = None
+        return gen_next_val
+
+    def _setup(self, target):
+        """Configure `get_next_val` to return next value.
+
+        Return the first such next value.
+        """
+        self.get_next_val = self._wrap_generator(target)
+        if self.get_next_val:
+            # `target` is a generator and we now have the
+            # `get_next_val`
+            return self.get_next_val()
+        assert callable(target), "Otherwise target must be callable"
+        target_rv = target()
+        self.get_next_val = self._wrap_generator(target_rv)
+        if self.get_next_val:
+            # Tartget is a callable that returned a generator.
+            return self.get_next_val()
+        # Otherwise, target is just a callable that returns values
+        self.get_next_val = target
+        return target_rv
+
+    async def next(self):
+        """Call `target` one more time."""
+        try:
+            if self.first_call:
+                rv = self._setup(self.target)
+                self.first_call = False
+            else:
+                rv = self.get_next_val()
+        except StopIteration as _err:
+            raise StopAsyncIteration() from _err
+        if inspect.isawaitable(rv):
+            rv = await rv
+        return rv

async_timer-1.1.0/src/async_timer/__init__.py

@@ -1,2 +0,0 @@
-from . import pacemaker, timer
-from .timer import Timer