dycw-utilities 0.115.1__py3-none-any.whl → 0.116.0__py3-none-any.whl

{dycw_utilities-0.115.1.dist-info → dycw_utilities-0.116.0.dist-info}/METADATA

@@ -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.dist-info → dycw_utilities-0.116.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-utilities/__init__.py,sha256=TbTtbGuM9AadB_WkxBUd94oWTm59iHPdjdluFVXZ-HI,60
+utilities/__init__.py,sha256=pLugaU63qZmC8Jq_ToL0O5damDhX5lVpukCAQ0DN0UA,60
 utilities/altair.py,sha256=Gpja-flOo-Db0PIPJLJsgzAlXWoKUjPU1qY-DQ829ek,9156
 utilities/astor.py,sha256=xuDUkjq0-b6fhtwjhbnebzbqQZAjMSHR1IIS5uOodVg,777
-utilities/asyncio.py,sha256=rDsYSQUhl2YZQKtkbeCNK4Mrbh5heVaqWLvLn2ppMJg,21534
+utilities/asyncio.py,sha256=NmAyhbOabek5LRagPcgTcSjjAZGK1yu5tLErWDdv5V0,23353
 utilities/atomicwrites.py,sha256=geFjn9Pwn-tTrtoGjDDxWli9NqbYfy3gGL6ZBctiqSo,5393
 utilities/atools.py,sha256=IYMuFSFGSKyuQmqD6v5IUtDlz8PPw0Sr87Cub_gRU3M,1168
 utilities/cachetools.py,sha256=C1zqOg7BYz0IfQFK8e3qaDDgEZxDpo47F15RTfJM37Q,2910
@@ -14,7 +14,7 @@ utilities/cvxpy.py,sha256=Rv1-fD-XYerosCavRF8Pohop2DBkU3AlFaGTfD8AEAA,13776
 utilities/dataclasses.py,sha256=iiC1wpGXWhaocIikzwBt8bbLWyImoUlOlcDZJGejaIg,33011
 utilities/datetime.py,sha256=PcN-4_sSPX1zbpdzBQRdo08pubCuGHyigxkV6SUnvlo,38733
 utilities/enum.py,sha256=HoRwVCWzsnH0vpO9ZEcAAIZLMv0Sn2vJxxA4sYMQgDs,5793
-utilities/errors.py,sha256=BtSNP0JC3ik536ddPyTerLomCRJV9f6kdMe6POz0QHM,361
+utilities/errors.py,sha256=gxsaa7eq7jbYl41Of40-ivjXqJB5gt4QAcJ0smZZMJE,829
 utilities/eventkit.py,sha256=6M5Xu1SzN-juk9PqBHwy5dS-ta7T0qA6SMpDsakOJ0E,13039
 utilities/fastapi.py,sha256=y-35at3005jzlNx2wJoiSvB1Ch5bMo30wgU_so3IDdI,2467
 utilities/fpdf2.py,sha256=y1NGXR5chWqLXWpewGV3hlRGMr_5yV1lVRkPBhPEgJI,1843
@@ -87,7 +87,7 @@ utilities/warnings.py,sha256=un1LvHv70PU-LLv8RxPVmugTzDJkkGXRMZTE2-fTQHw,1771
 utilities/whenever.py,sha256=iLRP_-8CZtBpHKbGZGu-kjSMg1ZubJ-VSmgSy7Eudxw,17787
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=-Xm57PMMwDTYpxJdkiJG13wnbwK--I7XItBh5WVhD-o,1874
-dycw_utilities-0.115.1.dist-info/METADATA,sha256=Bqi_67m9vtvYTiPadk63p01uSHmZlqyxM7_6YEuoo3A,12943
-dycw_utilities-0.115.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.115.1.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.115.1.dist-info/RECORD,,
+dycw_utilities-0.116.0.dist-info/METADATA,sha256=yAhNM7tqxJvQ36peel-0LjBpoJ-0nS9jT20DPZ9yBn4,12943
+dycw_utilities-0.116.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.116.0.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.116.0.dist-info/RECORD,,

utilities/__init__.py

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

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",

utilities/errors.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import override
+from typing import TYPE_CHECKING, assert_never, override
+
+if TYPE_CHECKING:
+    from utilities.types import MaybeType
 
 
 @dataclass(kw_only=True, slots=True)
@@ -14,4 +17,18 @@ class ImpossibleCaseError(Exception):
         return f"Case must be possible: {desc}."
 
 
-__all__ = ["ImpossibleCaseError"]
+##
+
+
+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"]