dycw-utilities 0.114.0__tar.gz → 0.114.1__tar.gz

{dycw_utilities-0.114.0 → dycw_utilities-0.114.1}/PKG-INFO

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

{dycw_utilities-0.114.0 → dycw_utilities-0.114.1}/pyproject.toml

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

{dycw_utilities-0.114.0 → dycw_utilities-0.114.1}/src/tests/test_asyncio.py

@@ -12,7 +12,7 @@ from asyncio import (
 )
 from collections import Counter
 from dataclasses import dataclass, field
-from itertools import chain
+from itertools import chain, count
 from re import search
 from typing import TYPE_CHECKING, Self, override
 
@@ -34,6 +34,8 @@ from utilities.asyncio import (
     EnhancedTaskGroup,
     ExceptionProcessor,
     InfiniteLooper,
+    InfiniteLooperError,
+    InfiniteQueueLooper,
     QueueProcessor,
     UniquePriorityQueue,
     UniqueQueue,
@@ -55,7 +57,7 @@ from utilities.sentinel import Sentinel, sentinel
 from utilities.timer import Timer
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping
+    from collections.abc import Iterator
 
     from utilities.types import Duration, MaybeCallableEvent, MaybeType
 
@@ -338,58 +340,113 @@ class TestGetEvent:
 class TestInfiniteLooper:
     @given(n=integers(10, 11))
     async def test_main(self, *, n: int) -> None:
-        class CustomTrueError(BaseException): ...
+        class TrueError(BaseException): ...
 
-        class CustomFalseError(BaseException): ...
+        class FalseError(BaseException): ...
 
         @dataclass(kw_only=True)
         class Example(InfiniteLooper[bool]):
-            counter: int = field(init=False, repr=False)
+            counter: int = 0
 
             @override
-            async def initialize(self) -> None:
+            async def _initialize(self) -> None:
                 self.counter = 0
 
             @override
-            async def core(self) -> None:
+            async def _core(self) -> None:
                 self.counter += 1
                 if self.counter >= n:
-                    self.events[n % 2 == 0].set()
+                    self._set_event(n % 2 == 0)
 
-            @property
             @override
-            def events_and_exceptions(self) -> Mapping[bool, MaybeType[BaseException]]:
-                return {True: CustomTrueError, False: CustomFalseError}
+            def _yield_events_and_exceptions(
+                self,
+            ) -> Iterator[tuple[bool, MaybeType[BaseException]]]:
+                yield (True, TrueError)
+                yield (False, FalseError)
 
         looper = Example(sleep_core=0.1)
         match n % 2 == 0:
             case True:
-                with raises(CustomTrueError):
+                with raises(TrueError):
                     _ = await looper()
             case False:
-                with raises(CustomFalseError):
+                with raises(FalseError):
                     _ = await looper()
 
+    async def test_multiple(self) -> None:
+        class ChildError(BaseException): ...
+
+        @dataclass(kw_only=True)
+        class Child(InfiniteLooper[None]):
+            counter: int = 0
+
+            @override
+            async def _initialize(self) -> None:
+                self.counter = 0
+
+            @override
+            async def _core(self) -> None:
+                self.counter += 1
+                if self.counter >= 10:
+                    self._set_event(None)
+
+            @override
+            def _yield_events_and_exceptions(
+                self,
+            ) -> Iterator[tuple[None, MaybeType[BaseException]]]:
+                yield (None, ChildError)
+
+        class ParentError(BaseException): ...
+
+        @dataclass(kw_only=True)
+        class Parent(InfiniteLooper[None]):
+            counter: int = 0
+            child: Child
+
+            @override
+            async def _initialize(self) -> None:
+                self.counter = 0
+
+            @override
+            async def _core(self) -> None:
+                self.counter += 1
+                self.child.counter += 1
+                if self.counter >= 10:
+                    self._set_event(None)
+
+            @override
+            def _yield_events_and_exceptions(
+                self,
+            ) -> Iterator[tuple[None, MaybeType[BaseException]]]:
+                yield (None, ParentError)
+
+            @override
+            def _yield_loopers(self) -> Iterator[InfiniteLooper]:
+                yield self.child
+
+        parent = Parent(sleep_core=0.1, child=Child(sleep_core=0.1))
+        with raises(BaseExceptionGroup) as error:
+            async with timeout_dur(duration=1.5):
+                await parent()
+        inner = one(error.value.exceptions)
+        assert isinstance(inner, ChildError)
+        assert 10 <= parent.child.counter <= 15
+        assert 3 <= parent.counter <= 7
+
     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:
+            async def _initialize(self) -> None:
                 raise CustomError
 
             @override
-            async def core(self) -> None:
+            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)()
@@ -399,23 +456,93 @@ class TestInfiniteLooper:
 
         @dataclass(kw_only=True)
         class Example(InfiniteLooper[None]):
-            counter: int = field(init=False, repr=False)
+            @override
+            async def _core(self) -> None:
+                raise CustomError
 
             @override
-            async def initialize(self) -> None: ...
+            def _yield_events_and_exceptions(
+                self,
+            ) -> Iterator[tuple[None, MaybeType[BaseException]]]:
+                yield (None, CustomError)
+
+        with raises(TimeoutError):
+            async with timeout_dur(duration=0.5):
+                _ = await Example(sleep_core=0.1)()
+
+    async def test_error_no_event_found(self) -> None:
+        @dataclass(kw_only=True)
+        class Example(InfiniteLooper[None]):
+            counter: int = 0
 
             @override
-            async def core(self) -> None:
-                raise CustomError
+            async def _initialize(self) -> None:
+                self.counter = 0
+
+            @override
+            async def _core(self) -> None:
+                self.counter += 1
+                if self.counter >= 10:
+                    self._set_event(None)
+
+        looper = Example(sleep_core=0.1)
+        with raises(InfiniteLooperError, match="No event None found"):
+            _ = await looper()
+
+
+class TestInfiniteQueueLooper:
+    async def test_main(self) -> None:
+        @dataclass(kw_only=True)
+        class Example(InfiniteQueueLooper[None, int]):
+            output: set[int] = field(default_factory=set)
+
+            @override
+            async def _process_items(self, *items: int) -> None:
+                self.output.update(items)
+
+        processor = Example(sleep_core=0.1)
+
+        async def add_items() -> None:
+            for i in count():
+                processor.put_items_nowait(i)
+                await sleep(0.1)
+
+        with raises(ExceptionGroup):  # noqa: PT012
+            async with EnhancedTaskGroup(timeout=1.0) as tg:
+                _ = tg.create_task(processor())
+                _ = tg.create_task(add_items())
+        assert 5 <= len(processor.output) <= 15
+
+    async def test_no_items(self) -> None:
+        @dataclass(kw_only=True)
+        class Example(InfiniteQueueLooper[None, int]):
+            output: set[int] = field(default_factory=set)
 
-            @property
             @override
-            def events_and_exceptions(self) -> Mapping[None, MaybeType[BaseException]]:
-                return {None: CustomError}
+            async def _process_items(self, *items: int) -> None:
+                self.output.update(items)
 
+        processor = Example(sleep_core=0.1)
         with raises(TimeoutError):
             async with timeout_dur(duration=0.5):
-                _ = await Example(sleep_core=0.1)()
+                _ = await processor()
+
+    async def test_error_process_items(self) -> None:
+        class CustomError(Exception): ...
+
+        @dataclass(kw_only=True)
+        class Example(InfiniteQueueLooper[None, int]):
+            output: set[int] = field(default_factory=set)
+
+            @override
+            async def _process_items(self, *items: int) -> None:
+                raise CustomError
+
+        processor = Example(sleep_core=0.1)
+        processor.put_items_nowait(1)
+        with raises(TimeoutError):
+            async with timeout_dur(duration=0.5):
+                _ = await processor()
 
 
 class TestPutAndGetItems:

{dycw_utilities-0.114.0 → dycw_utilities-0.114.1}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.114.0"
+__version__ = "0.114.1"

{dycw_utilities-0.114.0 → dycw_utilities-0.114.1}/src/utilities/asyncio.py

@@ -16,7 +16,7 @@ from asyncio import (
     sleep,
     timeout,
 )
-from collections.abc import Callable, Iterable, Mapping
+from collections.abc import Callable, Hashable, Iterable, Iterator, Mapping
 from contextlib import (
     AsyncExitStack,
     _AsyncGeneratorContextManager,
@@ -30,6 +30,7 @@ from sys import stderr, stdout
 from typing import (
     TYPE_CHECKING,
     Generic,
+    NoReturn,
     Self,
     TextIO,
     TypeVar,
@@ -43,7 +44,6 @@ from utilities.errors import ImpossibleCaseError
 from utilities.functions import ensure_int, ensure_not_none
 from utilities.sentinel import Sentinel, sentinel
 from utilities.types import (
-    Coroutine1,
     MaybeCallableEvent,
     MaybeType,
     THashable,
@@ -328,61 +328,155 @@ class ExceptionProcessor(QueueProcessor[Exception | type[Exception]]):
 class InfiniteLooper(ABC, Generic[THashable]):
     """An infinite loop which can throw exceptions by setting events."""
 
-    events: Mapping[THashable, Event] = field(
+    _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]:
+        self._events = {
+            event: Event() for event, _ in self._yield_events_and_exceptions()
+        }
+
+    async def __call__(self) -> None:
+        """Create a coroutine to run the looper."""
+        loopers = list(self._yield_loopers())
+        if len(loopers) == 0:
+            return await self._run_looper()
+        return await self._run_multiple_loopers(*loopers)
+
+    async def _run_looper(self) -> None:
+        """Run the looper by itself."""
         while True:
             try:
                 self._reset_events()
                 try:
-                    await self.initialize()
+                    await self._initialize()
                 except Exception as error:  # noqa: BLE001
-                    self.error_upon_initialize(error)
+                    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()
+                                for (key, value) in self._events.items()
                                 if value.is_set()
                             )
                         except StopIteration:
-                            await self.core()
+                            await self._core()
                             await sleep_dur(duration=self.sleep_core)
                         else:
-                            raise self.events_and_exceptions[event]
+                            self._raise_error(event)
+            except InfiniteLooperError:
+                raise
             except Exception as error:  # noqa: BLE001
-                self.error_upon_core(error)
+                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 _run_multiple_loopers(self, *loopers: InfiniteLooper) -> None:
+        """Run multiple loopers."""
+        while True:
+            self._reset_events()
+            try:
+                async with TaskGroup() as tg:
+                    _ = tg.create_task(self._run_looper())
+                    _ = [tg.create_task(looper()) for looper in loopers]
+            except Exception as error:  # noqa: BLE001
+                self._error_upon_core(error)  # pragma: no cover
+                await sleep_dur(duration=self.sleep_restart)  # pragma: no cover
 
-    async def initialize(self) -> None:
+    async def _initialize(self) -> None:
         """Initialize the loop."""
 
-    async def core(self) -> None:
-        """Run the core."""
+    async def _core(self) -> None:
+        """Run the core part of the loop."""
 
-    def error_upon_initialize(self, error: Exception, /) -> None:
+    def _error_upon_initialize(self, error: Exception, /) -> None:
+        """Handle any errors upon initializing the looper."""
         _ = error
 
-    def error_upon_core(self, error: Exception, /) -> None:
+    def _error_upon_core(self, error: Exception, /) -> None:
+        """Handle any errors upon running the core function."""
         _ = error
 
+    def _raise_error(self, event: THashable, /) -> NoReturn:
+        """Raise the error corresponding to given event."""
+        mapping = dict(self._yield_events_and_exceptions())
+        error = mapping.get(event, InfiniteLooperError)
+        raise error
+
     def _reset_events(self) -> None:
         """Reset the events."""
-        self.events = {event: Event() for event in self.events_and_exceptions}
+        self._events = {
+            event: Event() for event, _ in self._yield_events_and_exceptions()
+        }
+
+    def _set_event(self, event: THashable, /) -> None:
+        """Set the given event."""
+        try:
+            event_obj = self._events[event]
+        except KeyError:
+            raise InfiniteLooperError(event=event) from None
+        event_obj.set()
+
+    def _yield_events_and_exceptions(
+        self,
+    ) -> Iterator[tuple[THashable, MaybeType[BaseException]]]:
+        """Yield the events & exceptions."""
+        yield from []
+
+    def _yield_loopers(self) -> Iterator[InfiniteLooper]:
+        """Yield any other infinite loopers which must also be run."""
+        yield from []
+
+
+@dataclass(kw_only=True, slots=True)
+class InfiniteLooperError(Exception):
+    event: Hashable
+
+    @override
+    def __str__(self) -> str:
+        return f"No event {self.event!r} found"
+
+
+##
+
+
+@dataclass(kw_only=True)
+class InfiniteQueueLooper(InfiniteLooper[THashable], Generic[THashable, _T]):
+    """An infinite loop which processes a queue."""
+
+    queue_type: type[Queue[_T]] = field(default=Queue, repr=False)
+    _queue: Queue[_T] = field(init=False)
+    _current: Queue[_T] = field(init=False)
+
+    @override
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self._queue = self.queue_type()
+        self._current = self.queue_type()
+
+    @override
+    async def _core(self) -> None:
+        """Run the core part of the loop."""
+        items = await get_items(self._queue)
+        _ = get_items_nowait(self._current)
+        put_items_nowait(items, self._current)
+        try:
+            await self._process_items(*items)
+        except Exception:
+            put_items_nowait(items, self._queue)
+            raise
+
+    @abstractmethod
+    async def _process_items(self, *items: _T) -> None:
+        """Process the items."""
+
+    def put_items_nowait(self, *items: _T) -> None:
+        """Put items into the queue."""
+        put_items_nowait(items, self._queue)
 
 
 ##
@@ -590,6 +684,7 @@ __all__ = [
     "AsyncService",
     "EnhancedTaskGroup",
     "ExceptionProcessor",
+    "InfiniteLooperError",
     "QueueProcessor",
     "StreamCommandOutput",
     "UniquePriorityQueue",