haiway 0.4.0__tar.gz → 0.5.0__tar.gz

{haiway-0.4.0/src/haiway.egg-info → haiway-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: haiway
-Version: 0.4.0
+Version: 0.5.0
 Summary: Framework for dependency injection and state management within structured concurrency model.
 Maintainer-email: Kacper Kaliński <kacper.kalinski@miquido.com>
 License: MIT License

{haiway-0.4.0 → haiway-0.5.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "haiway"
 description = "Framework for dependency injection and state management within structured concurrency model."
-version = "0.4.0"
+version = "0.5.0"
 readme = "README.md"
 maintainers = [
   { name = "Kacper Kaliński", email = "kacper.kalinski@miquido.com" },

haiway-0.5.0/src/haiway/context/disposables.py

@@ -0,0 +1,78 @@
+from asyncio import gather
+from collections.abc import Iterable
+from contextlib import AbstractAsyncContextManager
+from itertools import chain
+from types import TracebackType
+from typing import final
+
+from haiway.state import State
+from haiway.utils import freeze
+
+__all__ = [
+    "Disposable",
+    "Disposables",
+]
+
+type Disposable = AbstractAsyncContextManager[Iterable[State] | State | None]
+
+
+@final
+class Disposables:
+    def __init__(
+        self,
+        *disposables: Disposable,
+    ) -> None:
+        self._disposables: tuple[Disposable, ...] = disposables
+
+        freeze(self)
+
+    def __bool__(self) -> bool:
+        return len(self._disposables) > 0
+
+    async def _initialize(
+        self,
+        disposable: Disposable,
+        /,
+    ) -> Iterable[State]:
+        match await disposable.__aenter__():
+            case None:
+                return ()
+
+            case State() as single:
+                return (single,)
+
+            case multiple:
+                return multiple
+
+    async def __aenter__(self) -> Iterable[State]:
+        return [
+            *chain.from_iterable(
+                state
+                for state in await gather(
+                    *[self._initialize(disposable) for disposable in self._disposables],
+                )
+            )
+        ]
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        results: list[bool | BaseException | None] = await gather(
+            *[
+                disposable.__aexit__(
+                    exc_type,
+                    exc_val,
+                    exc_tb,
+                )
+                for disposable in self._disposables
+            ],
+            return_exceptions=True,
+        )
+
+        exceptions: list[BaseException] = [exc for exc in results if isinstance(exc, BaseException)]
+
+        if len(exceptions) > 1:
+            raise BaseExceptionGroup("Disposing errors", exceptions)

{haiway-0.4.0 → haiway-0.5.0}/src/haiway/utils/queue.py

@@ -1,7 +1,6 @@
 from asyncio import AbstractEventLoop, CancelledError, Future, get_running_loop
 from collections import deque
 from collections.abc import AsyncIterator
-from typing import Self
 
 __all__ = [
     "AsyncQueue",
@@ -63,9 +62,6 @@ class AsyncQueue[Element](AsyncIterator[Element]):
     def cancel(self) -> None:
         self.finish(exception=CancelledError())
 
-    def __aiter__(self) -> Self:
-        return self
-
     async def __anext__(self) -> Element:
         assert self._waiting is None, "Only a single queue consumer is supported!"  # nosec: B101
 

{haiway-0.4.0 → haiway-0.5.0/src/haiway.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: haiway
-Version: 0.4.0
+Version: 0.5.0
 Summary: Framework for dependency injection and state management within structured concurrency model.
 Maintainer-email: Kacper Kaliński <kacper.kalinski@miquido.com>
 License: MIT License

haiway-0.4.0/src/haiway/context/disposables.py

@@ -1,68 +0,0 @@
-from asyncio import gather, shield
-from collections.abc import Iterable
-from types import TracebackType
-from typing import Protocol, final, runtime_checkable
-
-from haiway.state import State
-
-__all__ = [
-    "Disposable",
-    "Disposables",
-]
-
-
-@runtime_checkable
-class Disposable(Protocol):
-    async def initialize(self) -> State | None: ...
-    async def dispose(self) -> None: ...
-
-
-@final
-class Disposables:
-    def __init__(
-        self,
-        *disposables: Disposable,
-    ) -> None:
-        self._disposables: tuple[Disposable, ...] = disposables
-
-    async def initialize(self) -> Iterable[State]:
-        return [
-            state
-            for state in await gather(
-                *[disposable.initialize() for disposable in self._disposables],
-            )
-            if state is not None
-        ]
-
-    async def dispose(self) -> None:
-        results: list[BaseException | None] = await shield(
-            gather(
-                *[disposable.dispose() for disposable in self._disposables],
-                return_exceptions=True,
-            ),
-        )
-
-        self._disposables = ()
-        exceptions: list[BaseException] = [
-            exception for exception in results if exception is not None
-        ]
-
-        if len(exceptions) > 1:
-            raise BaseExceptionGroup("Disposing errors", exceptions)
-
-        elif exceptions:
-            raise exceptions[0]
-
-    def __bool__(self) -> bool:
-        return len(self._disposables) > 0
-
-    async def __aenter__(self) -> Iterable[State]:
-        return await self.initialize()
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> None:
-        await self.dispose()