dycw-utilities 0.122.1__tar.gz → 0.123.0__tar.gz

{dycw_utilities-0.122.1 → dycw_utilities-0.123.0}/PKG-INFO

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

{dycw_utilities-0.122.1 → dycw_utilities-0.123.0}/pyproject.toml

@@ -92,7 +92,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.122.1"
+version = "0.123.0"
 
 [project.optional-dependencies]
 test = [
@@ -334,7 +334,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.122.1"
+current_version = "0.123.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"
@@ -433,6 +433,7 @@ addopts = [
   "--durations=10",
   "--durations-min=10",
   "--strict-markers",
+  "--timeout=300",
 ]
 asyncio_default_fixture_loop_scope = "function"
 asyncio_mode = "auto"

{dycw_utilities-0.122.1 → dycw_utilities-0.123.0}/src/tests/test_asyncio.py

@@ -66,40 +66,46 @@ if TYPE_CHECKING:
 
 
 class TestEnhancedTaskGroup:
-    async def test_context_managers(self) -> None:
-        first: bool = False
+    async def test_create_task_context_coroutine(self) -> None:
+        flag: bool = False
 
         @asynccontextmanager
-        async def yield_first() -> AsyncIterator[None]:
-            nonlocal first
+        async def yield_true() -> AsyncIterator[None]:
+            nonlocal flag
             try:
-                first = True
+                flag = True
                 yield
             finally:
-                first = False
+                flag = False
 
-        second: bool = False
+        assert not flag
+        async with EnhancedTaskGroup(timeout=0.1) as tg:
+            _ = tg.create_task_context(yield_true())
+            await sleep(0.05)
+            assert flag
+        assert not flag
 
-        @asynccontextmanager
-        async def yield_second() -> AsyncIterator[None]:
-            nonlocal second
-            try:
-                second = True
-                yield
-            finally:
-                second = False
-
-        async with EnhancedTaskGroup() as tg:
-            assert not first
-            assert not second
-            _ = await tg.enter_async_context(yield_first())
-            assert first
-            assert not second
-            _ = await tg.enter_async_context(yield_second())
-            assert first
-            assert second
-        assert not first
-        assert not second
+    async def test_create_task_context_looper(self) -> None:
+        @dataclass(kw_only=True)
+        class Example(InfiniteLooper[None]):
+            running: bool = False
+
+            @override
+            async def _initialize(self) -> None:
+                self.running = True
+
+            @override
+            async def _teardown(self) -> None:
+                self.running = False
+
+        looper = Example(duration=0.1)
+        assert not looper.running
+        async with EnhancedTaskGroup(timeout=0.1) as tg:
+            assert not looper.running
+            _ = tg.create_task_context(looper)
+            await sleep(0.05)
+            assert looper.running
+        assert not looper.running
 
     async def test_max_tasks_disabled(self) -> None:
         with Timer() as timer:
@@ -350,7 +356,7 @@ class TestInfiniteLooper:
 
         async def inc_external(obj: Example, /) -> None:
             nonlocal external
-            while True:
+            for _ in range(100):  # infinite doesn't work on CI
                 external += 1
                 obj.counter += 1
                 await sleep(0.05)

{dycw_utilities-0.122.1 → dycw_utilities-0.123.0}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.122.1"
+__version__ = "0.123.0"

{dycw_utilities-0.122.1 → dycw_utilities-0.123.0}/src/utilities/asyncio.py

@@ -87,7 +87,6 @@ class EnhancedTaskGroup(TaskGroup):
     _timeout: Duration | None
     _error: type[Exception]
     _stack: AsyncExitStack
-    _stack_entered: bool
     _timeout_cm: _AsyncGeneratorContextManager[None] | None
 
     @override
@@ -103,7 +102,6 @@ class EnhancedTaskGroup(TaskGroup):
         self._timeout = timeout
         self._error = error
         self._stack = AsyncExitStack()
-        self._stack_entered = False  # TOOD: no need
         self._timeout_cm = None
 
     @override
@@ -136,8 +134,10 @@ class EnhancedTaskGroup(TaskGroup):
         coroutine = self._wrap_with_timeout(coroutine)
         return super().create_task(coroutine, name=name, context=context)
 
-    async def enter_async_context(self, cm: AbstractAsyncContextManager[_T], /) -> _T:
-        return await self._stack.enter_async_context(cm)
+    def create_task_context(self, cm: AbstractAsyncContextManager[_T], /) -> Task[_T]:
+        """Have the TaskGroup start an asynchronous context manager."""
+        _ = self._stack.push_async_callback(cm.__aexit__, None, None, None)
+        return self.create_task(cm.__aenter__())
 
     async def _wrap_with_semaphore(
         self, semaphore: Semaphore, coroutine: _CoroutineLike[_T], /
@@ -178,18 +178,12 @@ class InfiniteLooper(ABC, Generic[THashable]):
 
     async def __aenter__(self) -> Self:
         """Context manager entry."""
-        if (self._task is None) and (self._depth == 0):
-            _ = await self._stack.__aenter__()
+        if self._depth == 0:
             self._task = create_task(self._run_looper())
             if self._await_upon_aenter:
                 with suppress(CancelledError):
                     await self._task
-        elif (self._task is not None) and (self._depth >= 1):
-            ...
-        else:
-            raise ImpossibleCaseError(  # pragma: no cover
-                case=[f"{self._task=}", f"{self._depth=}"]
-            )
+            _ = await self._stack.__aenter__()
         self._depth += 1
         return self
 
@@ -201,18 +195,16 @@ class InfiniteLooper(ABC, Generic[THashable]):
     ) -> None:
         """Context manager exit."""
         _ = (exc_type, exc_value, traceback)
-        if (self._task is None) or (self._depth == 0):
-            raise ImpossibleCaseError(  # pragma: no cover
-                case=[f"{self._task=}", f"{self._depth=}"]
-            )
-        self._depth -= 1
-        if self._depth == 0:
-            _ = await self._stack.__aexit__(exc_type, exc_value, traceback)
+        self._depth = max(self._depth - 1, 0)
+        if (self._depth == 0) and (self._task is not None):
             with suppress(CancelledError):
                 await self._task
             self._task = None
-            with suppress(Exception):
+            try:
                 await self._teardown()
+            except Exception as error:  # noqa: BLE001
+                self._error_upon_teardown(error)
+            _ = await self._stack.__aexit__(exc_type, exc_value, traceback)
 
     async def stop(self) -> None:
         """Stop the service."""