dycw-utilities 0.115.1__tar.gz → 0.116.0__tar.gz

{dycw_utilities-0.115.1 → dycw_utilities-0.116.0}/PKG-INFO

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

{dycw_utilities-0.115.1 → dycw_utilities-0.116.0}/pyproject.toml

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

{dycw_utilities-0.115.1 → dycw_utilities-0.116.0}/src/tests/test_asyncio.py

@@ -12,6 +12,7 @@ from asyncio import (
 )
 from collections import Counter
 from dataclasses import dataclass, field
+from functools import partial
 from itertools import chain, count
 from re import search
 from typing import TYPE_CHECKING, Self, override
@@ -37,6 +38,7 @@ from utilities.asyncio import (
     InfiniteLooper,
     InfiniteLooperError,
     InfiniteQueueLooper,
+    InfiniteQueueLooperError,
     QueueProcessor,
     UniquePriorityQueue,
     UniqueQueue,
@@ -58,7 +60,7 @@ from utilities.sentinel import Sentinel, sentinel
 from utilities.timer import Timer
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
+    from collections.abc import Callable, Iterator
 
     from utilities.types import Coroutine1, Duration, MaybeCallableEvent, MaybeType
 
@@ -274,12 +276,12 @@ class TestEnhancedTaskGroup:
 
     async def test_timeout_pass(self) -> None:
         async with EnhancedTaskGroup(timeout=0.2) as tg:
-            _ = tg.create_task(sleep_dur(duration=0.1))
+            _ = tg.create_task(sleep(0.1))
 
     async def test_timeout_fail(self) -> None:
         with raises(ExceptionGroup) as exc_info:
             async with EnhancedTaskGroup(timeout=0.05) as tg:
-                _ = tg.create_task(sleep_dur(duration=0.1))
+                _ = tg.create_task(sleep(0.1))
         assert len(exc_info.value.exceptions) == 1
         error = one(exc_info.value.exceptions)
         assert isinstance(error, TimeoutError)
@@ -289,7 +291,7 @@ class TestEnhancedTaskGroup:
 
         with raises(ExceptionGroup) as exc_info:
             async with EnhancedTaskGroup(timeout=0.05, error=CustomError) as tg:
-                _ = tg.create_task(sleep_dur(duration=0.1))
+                _ = tg.create_task(sleep(0.1))
         assert len(exc_info.value.exceptions) == 1
         error = one(exc_info.value.exceptions)
         assert isinstance(error, CustomError)
@@ -376,19 +378,50 @@ class TestInfiniteLooper:
                     _ = await looper()
 
     async def test_hashable(self) -> None:
-        class CustomError(BaseException): ...
+        class CustomError(Exception): ...
 
         @dataclass(kw_only=True, unsafe_hash=True)
         class Example(InfiniteLooper[None]):
+            @override
+            def _yield_events_and_exceptions(
+                self,
+            ) -> Iterator[tuple[None, MaybeType[Exception]]]:
+                yield (None, CustomError)
+
+        looper = Example(sleep_core=0.1)
+        _ = hash(looper)
+
+    async def test_with_coroutine_self_set_event(self) -> None:
+        external: int = 0
+
+        async def inc_external(obj: Example, /) -> None:
+            nonlocal external
+            while True:
+                external += 1
+                obj.counter += 1
+                await sleep(0.05)
+
+        class CustomError(Exception): ...
+
+        @dataclass(kw_only=True)
+        class Example(InfiniteLooper[None]):
+            initializations: int = 0
             counter: int = 0
 
             @override
             async def _initialize(self) -> None:
+                self.initializations += 1
                 self.counter = 0
 
             @override
             async def _core(self) -> None:
                 self.counter += 1
+                if self.counter >= 5:
+                    self._set_event(None)
+
+            @override
+            def _yield_coroutines(self) -> Iterator[Callable[[], Coroutine1[None]]]:
+                yield partial(inc_external, self)
 
             @override
             def _yield_events_and_exceptions(
@@ -396,68 +429,95 @@ class TestInfiniteLooper:
             ) -> Iterator[tuple[None, MaybeType[BaseException]]]:
                 yield (None, CustomError)
 
-        looper = Example(sleep_core=0.1)
-        _ = hash(looper)
+        looper = Example(sleep_core=0.05, sleep_restart=0.05)
+        with raises(TimeoutError):
+            async with timeout_dur(duration=1.0):
+                await looper()
+        assert 4 <= looper.initializations <= 6
+        assert 0 <= looper.counter <= 7
+        assert 17 <= external <= 21
 
-    async def test_with_coroutines(self) -> None:
-        class ChildError(BaseException): ...
+    async def test_with_coroutine_self_error(self) -> None:
+        class CustomError(Exception): ...
+
+        async def dummy() -> None:
+            _ = await Event().wait()
 
         @dataclass(kw_only=True)
-        class Child(InfiniteLooper[None]):
+        class Example(InfiniteLooper[None]):
+            initializations: int = 0
             counter: int = 0
 
             @override
             async def _initialize(self) -> None:
+                self.initializations += 1
                 self.counter = 0
 
             @override
             async def _core(self) -> None:
                 self.counter += 1
-                if self.counter >= 10:
-                    self._set_event(None)
+                if self.counter >= 5:
+                    raise CustomError
+
+            @override
+            def _yield_coroutines(self) -> Iterator[Callable[[], Coroutine1[None]]]:
+                yield dummy
 
             @override
             def _yield_events_and_exceptions(
                 self,
             ) -> Iterator[tuple[None, MaybeType[BaseException]]]:
-                yield (None, ChildError)
+                yield (None, CustomError)
+
+        looper = Example(sleep_core=0.05, sleep_restart=0.05)
+        with raises(TimeoutError):
+            async with timeout_dur(duration=1.0):
+                await looper()
+        assert 3 <= looper.initializations <= 5
+        assert 0 <= looper.counter <= 5
 
-        class ParentError(BaseException): ...
+    @given(logger=just("logger") | none())
+    async def test_with_coroutine_other_coroutine_error(
+        self, *, logger: str | None
+    ) -> None:
+        class CustomError(Exception): ...
+
+        async def dummy() -> None:
+            for i in count():
+                if i >= 5:
+                    raise CustomError
+                await sleep(0.05)
 
         @dataclass(kw_only=True)
-        class Parent(InfiniteLooper[None]):
+        class Example(InfiniteLooper[None]):
+            initializations: int = 0
             counter: int = 0
-            child: Child
 
             @override
             async def _initialize(self) -> None:
+                self.initializations += 1
                 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_coroutines(self) -> Iterator[Coroutine1[None]]:
-                yield self.child()
+            def _yield_coroutines(self) -> Iterator[Callable[[], Coroutine1[None]]]:
+                yield dummy
 
             @override
             def _yield_events_and_exceptions(
                 self,
             ) -> Iterator[tuple[None, MaybeType[BaseException]]]:
-                yield (None, ParentError)
+                yield (None, CustomError)
 
-        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
+        looper = Example(sleep_core=0.05, sleep_restart=0.05, logger=logger)
+        with raises(CancelledError):
+            async with timeout_dur(duration=1.0):
+                await looper()
+        assert 3 <= looper.initializations <= 5
+        assert 1 <= looper.counter <= 5
 
     @given(logger=just("logger") | none())
     async def test_error_upon_initialize(self, *, logger: str | None) -> None:
@@ -473,12 +533,13 @@ class TestInfiniteLooper:
             async def _core(self) -> None:
                 raise NotImplementedError
 
+        looper = Example(sleep_core=0.1, logger=logger)
         with raises(TimeoutError):
             async with timeout_dur(duration=0.5):
-                _ = await Example(sleep_core=0.1, logger=logger)()
+                _ = await looper()
 
     @given(logger=just("logger") | none())
-    async def test_error_upon_core(self, *, logger: str | None) -> None:
+    async def test_error_group_upon_coroutines(self, *, logger: str | None) -> None:
         class CustomError(Exception): ...
 
         @dataclass(kw_only=True)
@@ -493,9 +554,10 @@ class TestInfiniteLooper:
             ) -> Iterator[tuple[None, MaybeType[BaseException]]]:
                 yield (None, CustomError)
 
+        looper = Example(sleep_core=0.1, logger=logger)
         with raises(TimeoutError):
             async with timeout_dur(duration=0.5):
-                _ = await Example(sleep_core=0.1, logger=logger)()
+                _ = await looper()
 
     async def test_error_no_event_found(self) -> None:
         @dataclass(kw_only=True)
@@ -513,7 +575,7 @@ class TestInfiniteLooper:
                     self._set_event(None)
 
         looper = Example(sleep_core=0.1)
-        with raises(InfiniteLooperError, match="No event None found"):
+        with raises(InfiniteLooperError, match="'Example' does not have an event None"):
             _ = await looper()
 
 
@@ -527,18 +589,18 @@ class TestInfiniteQueueLooper:
             async def _process_items(self, *items: int) -> None:
                 self.output.update(items)
 
-        processor = Example(sleep_core=0.1)
+        looper = Example(sleep_core=0.05)
 
         async def add_items() -> None:
             for i in count():
-                processor.put_items_nowait(i)
-                await sleep(0.1)
+                looper.put_items_nowait(i)
+                await sleep(0.05)
 
         with raises(ExceptionGroup):  # noqa: PT012
             async with EnhancedTaskGroup(timeout=1.0) as tg:
-                _ = tg.create_task(processor())
+                _ = tg.create_task(looper())
                 _ = tg.create_task(add_items())
-        assert 5 <= len(processor.output) <= 15
+        assert 15 <= len(looper.output) <= 20
 
     async def test_no_items(self) -> None:
         @dataclass(kw_only=True)
@@ -549,12 +611,13 @@ class TestInfiniteQueueLooper:
             async def _process_items(self, *items: int) -> None:
                 self.output.update(items)
 
-        processor = Example(sleep_core=0.1)
+        looper = Example(sleep_core=0.05)
         with raises(TimeoutError):
             async with timeout_dur(duration=0.5):
-                _ = await processor()
+                _ = await looper()
 
-    async def test_error_process_items(self) -> None:
+    @given(logger=just("logger") | none())
+    async def test_error_process_items(self, *, logger: str | None) -> None:
         class CustomError(Exception): ...
 
         @dataclass(kw_only=True)
@@ -565,11 +628,28 @@ class TestInfiniteQueueLooper:
             async def _process_items(self, *items: int) -> None:
                 raise CustomError(*items)
 
-        processor = Example(sleep_core=0.1)
-        processor.put_items_nowait(1)
+        looper = Example(sleep_core=0.05, logger=logger)
+        looper.put_items_nowait(1)
         with raises(TimeoutError):
             async with timeout_dur(duration=0.5):
-                _ = await processor()
+                _ = await looper()
+
+    async def test_error_infinite_queue_looper(self) -> None:
+        class CustomError(Exception): ...
+
+        @dataclass(kw_only=True)
+        class Example(InfiniteQueueLooper[None, int]):
+            @override
+            async def _process_items(self, *items: int) -> None:
+                raise CustomError(*items)
+
+        looper = Example(sleep_core=0.1)
+        looper.put_items_nowait(1)
+        with raises(
+            InfiniteQueueLooperError,
+            match=r"'Example' encountered CustomError\(1\) whilst processing 1 item\(s\): \[1\]",
+        ):
+            _ = await looper._core()
 
 
 class TestPutAndGetItems:
@@ -852,19 +932,19 @@ class TestStreamCommand:
 class TestTimeoutDur:
     async def test_pass(self) -> None:
         async with timeout_dur(duration=0.2):
-            await sleep_dur(duration=0.1)
+            await sleep(0.1)
 
     async def test_fail(self) -> None:
         with raises(TimeoutError):
             async with timeout_dur(duration=0.05):
-                await sleep_dur(duration=0.1)
+                await sleep(0.1)
 
     async def test_custom_error(self) -> None:
         class CustomError(Exception): ...
 
         with raises(CustomError):
             async with timeout_dur(duration=0.05, error=CustomError):
-                await sleep_dur(duration=0.1)
+                await sleep(0.1)
 
 
 if __name__ == "__main__":

dycw_utilities-0.116.0/src/tests/test_errors.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from pytest import raises
+
+from utilities.errors import ImpossibleCaseError, repr_error
+
+
+class TestImpossibleCaseError:
+    def test_main(self) -> None:
+        x = None
+        with raises(ImpossibleCaseError, match=r"Case must be possible: x=None\."):
+            raise ImpossibleCaseError(case=[f"{x=}"])
+
+
+class TestReprError:
+    def test_class(self) -> None:
+        class CustomError(Exception): ...
+
+        result = repr_error(CustomError)
+        expected = "CustomError"
+        assert result == expected
+
+    def test_instance(self) -> None:
+        class CustomError(Exception): ...
+
+        result = repr_error(CustomError())
+        expected = "CustomError()"
+        assert result == expected

{dycw_utilities-0.115.1 → dycw_utilities-0.116.0}/src/tests/test_slack_sdk.py

@@ -155,10 +155,12 @@ class TestSlackHandlerIQL:
             messages.append(text)
 
         logger = getLogger(str(tmp_path))
-        logger.addHandler(handler := SlackHandlerIQL("url", sender=sender))
+        logger.addHandler(
+            handler := SlackHandlerIQL("url", sleep_core=0.05, sender=sender)
+        )
 
         async def sleep_then_log() -> None:
-            await sleep_dur(duration=0.1)
+            await sleep_dur(duration=0.05)
             logger.warning("message")
 
         with raises(ExceptionGroup):  # noqa: PT012
@@ -173,10 +175,10 @@ class TestSlackHandlerIQL:
     async def test_real(self, *, tmp_path: Path) -> None:
         url = get_env_var("SLACK")
         logger = getLogger(str(tmp_path))
-        logger.addHandler(handler := SlackHandlerIQL(url))
+        logger.addHandler(handler := SlackHandlerIQL(url, sleep_core=0.05))
 
         async def sleep_then_log() -> None:
-            await sleep_dur(duration=0.1)
+            await sleep_dur(duration=0.05)
             for i in range(10):
                 logger.warning(
                     "message %d from %s", i, TestSlackHandlerIQL.test_real.__qualname__

{dycw_utilities-0.115.1 → dycw_utilities-0.116.0}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.115.1"
+__version__ = "0.116.0"

{dycw_utilities-0.115.1 → dycw_utilities-0.116.0}/src/utilities/asyncio.py

@@ -30,6 +30,7 @@ from subprocess import PIPE
 from sys import stderr, stdout
 from typing import (
     TYPE_CHECKING,
+    Any,
     Generic,
     NoReturn,
     Self,
@@ -41,8 +42,9 @@ from typing import (
 )
 
 from utilities.datetime import MILLISECOND, MINUTE, SECOND, datetime_duration_to_float
-from utilities.errors import ImpossibleCaseError
+from utilities.errors import ImpossibleCaseError, repr_error
 from utilities.functions import ensure_int, ensure_not_none, get_class_name
+from utilities.reprlib import get_repr
 from utilities.sentinel import Sentinel, sentinel
 from utilities.types import (
     Coroutine1,
@@ -379,17 +381,19 @@ class InfiniteLooper(ABC, Generic[THashable]):
                 self._error_upon_core(error)
                 await sleep_dur(duration=self.sleep_restart)
 
-    async def _run_looper_with_coroutines(self, *coroutines: Coroutine1) -> None:
+    async def _run_looper_with_coroutines(
+        self, *coroutines: Callable[[], Coroutine1[None]]
+    ) -> None:
         """Run multiple loopers."""
         while True:
             self._reset_events()
             try:
                 async with TaskGroup() as tg:
                     _ = tg.create_task(self._run_looper())
-                    _ = list(map(tg.create_task, coroutines))
-            except Exception as error:  # noqa: BLE001
-                self._error_upon_core(error)  # pragma: no cover
-                await sleep_dur(duration=self.sleep_restart)  # pragma: no cover
+                    _ = [tg.create_task(c()) for c in coroutines]
+            except ExceptionGroup as error:
+                self._error_group_upon_coroutines(error)
+                await sleep_dur(duration=self.sleep_restart)
 
     async def _initialize(self) -> None:
         """Initialize the loop."""
@@ -401,9 +405,9 @@ class InfiniteLooper(ABC, Generic[THashable]):
         """Handle any errors upon initializing the looper."""
         if self.logger is not None:
             getLogger(name=self.logger).error(
-                "Error initializing %r due to %r; sleeping for %s...",
+                "%r encountered %r whilst initializing; sleeping for %s...",
                 get_class_name(self),
-                repr(error),
+                repr_error(error),
                 self.sleep_restart,
             )
 
@@ -411,12 +415,25 @@ class InfiniteLooper(ABC, Generic[THashable]):
         """Handle any errors upon running the core function."""
         if self.logger is not None:
             getLogger(name=self.logger).error(
-                "Error running %r due to %r; sleeping for %s...",
+                "%r encountered %r; sleeping for %s...",
                 get_class_name(self),
-                repr(error),
+                repr_error(error),
                 self.sleep_restart,
             )
 
+    def _error_group_upon_coroutines(self, group: ExceptionGroup, /) -> None:
+        """Handle any errors upon running the core function."""
+        if self.logger is not None:
+            errors = group.exceptions
+            n = len(errors)
+            msgs = [f"{get_class_name(self)!r} encountered {n} error(s):"]
+            msgs.extend(
+                f"- Error #{i}/{n}: {repr_error(e)}"
+                for i, e in enumerate(errors, start=1)
+            )
+            msgs.append(f"Sleeping for {self.sleep_restart}...")
+            getLogger(name=self.logger).error("\n".join(msgs))
+
     def _raise_error(self, event: THashable, /) -> NoReturn:
         """Raise the error corresponding to given event."""
         mapping = dict(self._yield_events_and_exceptions())
@@ -434,10 +451,10 @@ class InfiniteLooper(ABC, Generic[THashable]):
         try:
             event_obj = self._events[event]
         except KeyError:
-            raise InfiniteLooperError(event=event) from None
+            raise InfiniteLooperError(looper=self, event=event) from None
         event_obj.set()
 
-    def _yield_coroutines(self) -> Iterator[Coroutine1[None]]:
+    def _yield_coroutines(self) -> Iterator[Callable[[], Coroutine1[None]]]:
         """Yield any other coroutines which must also be run."""
         yield from []
 
@@ -450,11 +467,12 @@ class InfiniteLooper(ABC, Generic[THashable]):
 
 @dataclass(kw_only=True, slots=True)
 class InfiniteLooperError(Exception):
+    looper: InfiniteLooper[Any]
     event: Hashable
 
     @override
     def __str__(self) -> str:
-        return f"No event {self.event!r} found"
+        return f"{get_class_name(self.looper)!r} does not have an event {self.event!r}"
 
 
 ##
@@ -466,25 +484,24 @@ class InfiniteQueueLooper(InfiniteLooper[THashable], Generic[THashable, _T]):
 
     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)
+        items = get_items_nowait(self._queue)
+        if len(items) == 0:
+            return
         try:
             await self._process_items(*items)
-        except Exception:
-            put_items_nowait(items, self._queue)
-            raise
+        except Exception as error:  # noqa: BLE001
+            raise InfiniteQueueLooperError(
+                looper=self, items=items, error=error
+            ) from None
 
     @abstractmethod
     async def _process_items(self, *items: _T) -> None:
@@ -494,6 +511,33 @@ class InfiniteQueueLooper(InfiniteLooper[THashable], Generic[THashable, _T]):
         """Put items into the queue."""
         put_items_nowait(items, self._queue)
 
+    @override
+    def _error_upon_core(self, error: Exception, /) -> None:
+        """Handle any errors upon running the core function."""
+        if self.logger is not None:
+            if isinstance(error, InfiniteQueueLooperError):
+                getLogger(name=self.logger).error(
+                    "%r encountered %s whilst processing %d item(s) %s; sleeping for %s...",
+                    get_class_name(self),
+                    repr_error(error.error),
+                    len(error.items),
+                    get_repr(error.items),
+                    self.sleep_restart,
+                )
+            else:
+                super()._error_upon_core(error)  # pragma: no cover
+
+
+@dataclass(kw_only=True, slots=True)
+class InfiniteQueueLooperError(Exception, Generic[_T]):
+    looper: InfiniteQueueLooper[Any, Any]
+    items: Sequence[_T]
+    error: Exception
+
+    @override
+    def __str__(self) -> str:
+        return f"{get_class_name(self.looper)!r} encountered {repr_error(self.error)} whilst processing {len(self.items)} item(s): {get_repr(self.items)}"
+
 
 ##
 
@@ -703,6 +747,7 @@ __all__ = [
     "InfiniteLooper",
     "InfiniteLooperError",
     "InfiniteQueueLooper",
+    "InfiniteQueueLooperError",
     "QueueProcessor",
     "StreamCommandOutput",
     "UniquePriorityQueue",

dycw_utilities-0.116.0/src/utilities/errors.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, assert_never, override
+
+if TYPE_CHECKING:
+    from utilities.types import MaybeType
+
+
+@dataclass(kw_only=True, slots=True)
+class ImpossibleCaseError(Exception):
+    case: list[str]
+
+    @override
+    def __str__(self) -> str:
+        desc = ", ".join(self.case)
+        return f"Case must be possible: {desc}."
+
+
+##
+
+
+def repr_error(error: MaybeType[Exception], /) -> str:
+    """Get a string representation of an error."""
+    match error:
+        case Exception() as error_obj:
+            return f"{error_obj.__class__.__name__}({error_obj})"
+        case type() as error_cls:
+            return error_cls.__name__
+        case _ as never:
+            assert_never(never)
+
+
+__all__ = ["ImpossibleCaseError", "repr_error"]

dycw_utilities-0.115.1/src/tests/test_errors.py

@@ -1,12 +0,0 @@
-from __future__ import annotations
-
-from pytest import raises
-
-from utilities.errors import ImpossibleCaseError
-
-
-class TestImpossibleCaseError:
-    def test_main(self) -> None:
-        x = None
-        with raises(ImpossibleCaseError, match=r"Case must be possible: x=None\."):
-            raise ImpossibleCaseError(case=[f"{x=}"])