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

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

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

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

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

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

@@ -60,7 +60,7 @@ from utilities.timer import Timer
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
-    from utilities.types import Duration, MaybeCallableEvent, MaybeType
+    from utilities.types import Coroutine1, Duration, MaybeCallableEvent, MaybeType
 
 
 class TestAsyncLoopingService:
@@ -393,13 +393,13 @@ class TestInfiniteLooper:
             @override
             def _yield_events_and_exceptions(
                 self,
-            ) -> Iterator[tuple[bool, MaybeType[BaseException]]]:
+            ) -> Iterator[tuple[None, MaybeType[BaseException]]]:
                 yield (None, CustomError)
 
         looper = Example(sleep_core=0.1)
         _ = hash(looper)
 
-    async def test_multiple(self) -> None:
+    async def test_with_coroutines(self) -> None:
         class ChildError(BaseException): ...
 
         @dataclass(kw_only=True)
@@ -440,16 +440,16 @@ class TestInfiniteLooper:
                 if self.counter >= 10:
                     self._set_event(None)
 
+            @override
+            def _yield_coroutines(self) -> Iterator[Coroutine1[None]]:
+                yield self.child()
+
             @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):

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

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

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

@@ -45,6 +45,7 @@ from utilities.errors import ImpossibleCaseError
 from utilities.functions import ensure_int, ensure_not_none, get_class_name
 from utilities.sentinel import Sentinel, sentinel
 from utilities.types import (
+    Coroutine1,
     MaybeCallableEvent,
     MaybeType,
     THashable,
@@ -344,10 +345,10 @@ class InfiniteLooper(ABC, Generic[THashable]):
 
     async def __call__(self) -> None:
         """Create a coroutine to run the looper."""
-        loopers = list(self._yield_loopers())
-        if len(loopers) == 0:
+        coroutines = list(self._yield_coroutines())
+        if len(coroutines) == 0:
             return await self._run_looper()
-        return await self._run_multiple_loopers(*loopers)
+        return await self._run_looper_with_coroutines(*coroutines)
 
     async def _run_looper(self) -> None:
         """Run the looper by itself."""
@@ -378,14 +379,14 @@ class InfiniteLooper(ABC, Generic[THashable]):
                 self._error_upon_core(error)
                 await sleep_dur(duration=self.sleep_restart)
 
-    async def _run_multiple_loopers(self, *loopers: InfiniteLooper) -> None:
+    async def _run_looper_with_coroutines(self, *coroutines: Coroutine1) -> 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]
+                    _ = 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
@@ -436,16 +437,16 @@ class InfiniteLooper(ABC, Generic[THashable]):
             raise InfiniteLooperError(event=event) from None
         event_obj.set()
 
+    def _yield_coroutines(self) -> Iterator[Coroutine1[None]]:
+        """Yield any other coroutines which must also be run."""
+        yield from []
+
     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):

{dycw_utilities-0.114.7 → dycw_utilities-0.115.1}/src/utilities/redis.py

@@ -648,7 +648,7 @@ _SUBSCRIBE_SLEEP: Duration = MILLISECOND
 
 
 @overload
-async def subscribe(
+def subscribe(
     pubsub: PubSub,
     channels: MaybeIterable[str],
     /,
@@ -658,7 +658,7 @@ async def subscribe(
     sleep: Duration = _SUBSCRIBE_SLEEP,
 ) -> AsyncIterator[_T]: ...
 @overload
-async def subscribe(
+def subscribe(
     pubsub: PubSub,
     channels: MaybeIterable[str],
     /,
@@ -667,7 +667,7 @@ async def subscribe(
     timeout: Duration | None = _SUBSCRIBE_TIMEOUT,
     sleep: Duration = _SUBSCRIBE_SLEEP,
 ) -> AsyncIterator[bytes]: ...
-async def subscribe(
+async def subscribe(  # pyright: ignore[reportInconsistentOverload]
     pubsub: PubSub,
     channels: MaybeIterable[str],
     /,
@@ -675,7 +675,7 @@ async def subscribe(
     deserializer: Callable[[bytes], _T] | None = None,
     timeout: Duration | None = _SUBSCRIBE_TIMEOUT,
     sleep: Duration = _SUBSCRIBE_SLEEP,
-) -> AsyncIterator[Any]:
+) -> AsyncIterator[_T] | AsyncIterator[bytes]:
     """Subscribe to the data of a given channel(s)."""
     channels = list(always_iterable(channels))  # skipif-ci-and-not-linux
     messages = subscribe_messages(  # skipif-ci-and-not-linux