dycw-utilities 0.113.4__tar.gz → 0.113.5__tar.gz

{dycw_utilities-0.113.4 → dycw_utilities-0.113.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.113.4
+Version: 0.113.5
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12

{dycw_utilities-0.113.4 → dycw_utilities-0.113.5}/pyproject.toml

@@ -92,7 +92,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.113.4"
+version = "0.113.5"
 
 [project.optional-dependencies]
 test = [
@@ -334,7 +334,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.113.4"
+current_version = "0.113.5"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.113.4 → dycw_utilities-0.113.5}/src/tests/test_asyncio.py

@@ -35,6 +35,7 @@ from utilities.asyncio import (
     AsyncService,
     EnhancedTaskGroup,
     ExceptionProcessor,
+    InfiniteLooper,
     QueueProcessor,
     UniquePriorityQueue,
     UniqueQueue,
@@ -54,7 +55,9 @@ from utilities.sentinel import Sentinel, sentinel
 from utilities.timer import Timer
 
 if TYPE_CHECKING:
-    from utilities.types import Duration, MaybeCallableEvent
+    from collections.abc import Mapping
+
+    from utilities.types import Duration, MaybeCallableEvent, MaybeType
 
 
 class TestAsyncLoopingService:
@@ -401,6 +404,89 @@ class TestGetItemsNoWait:
             assert result == xs[:max_size]
 
 
+class TestInfiniteLooper:
+    @given(n=integers(10, 11))
+    async def test_main(self, *, n: int) -> None:
+        class CustomTrueError(BaseException): ...
+
+        class CustomFalseError(BaseException): ...
+
+        @dataclass(kw_only=True)
+        class Example(InfiniteLooper[bool]):
+            counter: int = field(init=False, repr=False)
+
+            @override
+            async def initialize(self) -> None:
+                self.counter = 0
+
+            @override
+            async def core(self) -> None:
+                self.counter += 1
+                if self.counter >= n:
+                    self.events[n % 2 == 0].set()
+
+            @property
+            @override
+            def events_and_exceptions(self) -> Mapping[bool, MaybeType[BaseException]]:
+                return {True: CustomTrueError, False: CustomFalseError}
+
+        looper = Example(sleep_core=0.1)
+        match n % 2 == 0:
+            case True:
+                with raises(CustomTrueError):
+                    _ = await looper()
+            case False:
+                with raises(CustomFalseError):
+                    _ = await looper()
+
+    async def test_error_upon_initialize(self) -> None:
+        class CustomError(Exception): ...
+
+        @dataclass(kw_only=True)
+        class Example(InfiniteLooper[None]):
+            counter: int = field(init=False, repr=False)
+
+            @override
+            async def initialize(self) -> None:
+                raise CustomError
+
+            @override
+            async def core(self) -> None:
+                raise NotImplementedError
+
+            @property
+            @override
+            def events_and_exceptions(self) -> Mapping[None, MaybeType[BaseException]]:
+                return {None: CustomError}
+
+        with raises(TimeoutError):
+            async with timeout_dur(duration=0.5):
+                _ = await Example(sleep_core=0.1)()
+
+    async def test_error_upon_core(self) -> None:
+        class CustomError(Exception): ...
+
+        @dataclass(kw_only=True)
+        class Example(InfiniteLooper[None]):
+            counter: int = field(init=False, repr=False)
+
+            @override
+            async def initialize(self) -> None: ...
+
+            @override
+            async def core(self) -> None:
+                raise CustomError
+
+            @property
+            @override
+            def events_and_exceptions(self) -> Mapping[None, MaybeType[BaseException]]:
+                return {None: CustomError}
+
+        with raises(TimeoutError):
+            async with timeout_dur(duration=0.5):
+                _ = await Example(sleep_core=0.1)()
+
+
 class TestQueueProcessor:
     async def test_one_processor_slow_tasks(self) -> None:
         @dataclass(kw_only=True)

{dycw_utilities-0.113.4 → dycw_utilities-0.113.5}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.113.4"
+__version__ = "0.113.5"

{dycw_utilities-0.113.4 → dycw_utilities-0.113.5}/src/utilities/asyncio.py

@@ -17,7 +17,7 @@ from asyncio import (
     sleep,
     timeout,
 )
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from contextlib import (
     AsyncExitStack,
     _AsyncGeneratorContextManager,
@@ -39,11 +39,17 @@ from typing import (
     override,
 )
 
-from utilities.datetime import MILLISECOND, datetime_duration_to_float
+from utilities.datetime import MILLISECOND, MINUTE, SECOND, datetime_duration_to_float
 from utilities.errors import ImpossibleCaseError
 from utilities.functions import ensure_int, ensure_not_none
 from utilities.sentinel import Sentinel, sentinel
-from utilities.types import MaybeCallableEvent, THashable, TSupportsRichComparison
+from utilities.types import (
+    Coroutine1,
+    MaybeCallableEvent,
+    MaybeType,
+    THashable,
+    TSupportsRichComparison,
+)
 
 if TYPE_CHECKING:
     from asyncio import _CoroutineLike
@@ -320,6 +326,70 @@ class ExceptionProcessor(QueueProcessor[Exception | type[Exception]]):
 ##
 
 
+@dataclass(kw_only=True)
+class InfiniteLooper(ABC, Generic[THashable]):
+    """An infinite loop which can throw exceptions by setting events."""
+
+    events: Mapping[THashable, Event] = field(
+        default_factory=dict, init=False, repr=False
+    )
+    sleep_core: Duration = SECOND
+    sleep_restart: Duration = MINUTE
+
+    def __post_init__(self) -> None:
+        self._reset_events()
+
+    async def __call__(self) -> Coroutine1[None]:
+        while True:
+            try:
+                self._reset_events()
+                try:
+                    await self.initialize()
+                except Exception as error:  # noqa: BLE001
+                    self.error_upon_initialize(error)
+                    await sleep_dur(duration=self.sleep_restart)
+                else:
+                    while True:
+                        try:
+                            event = next(
+                                key
+                                for (key, value) in self.events.items()
+                                if value.is_set()
+                            )
+                        except StopIteration:
+                            await self.core()
+                            await sleep_dur(duration=self.sleep_core)
+                        else:
+                            raise self.events_and_exceptions[event]
+            except Exception as error:  # noqa: BLE001
+                self.error_upon_core(error)
+                await sleep_dur(duration=self.sleep_restart)
+
+    @property
+    @abstractmethod
+    def events_and_exceptions(self) -> Mapping[THashable, MaybeType[BaseException]]:
+        """A mapping of events to exceptions."""
+
+    async def initialize(self) -> None:
+        """Initialize the loop."""
+
+    async def core(self) -> None:
+        """Run the core."""
+
+    def error_upon_initialize(self, error: Exception, /) -> None:
+        _ = error
+
+    def error_upon_core(self, error: Exception, /) -> None:
+        _ = error
+
+    def _reset_events(self) -> None:
+        """Reset the events."""
+        self.events = {event: Event() for event in self.events_and_exceptions}
+
+
+##
+
+
 class UniquePriorityQueue(PriorityQueue[tuple[TSupportsRichComparison, THashable]]):
     """Priority queue with unique tasks."""