haiway 0.4.0__tar.gz → 0.5.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: haiway
-Version: 0.4.0
+Version: 0.5.1
 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.1}/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.1"
 readme = "README.md"
 maintainers = [
   { name = "Kacper Kaliński", email = "kacper.kalinski@miquido.com" },

{haiway-0.4.0 → haiway-0.5.1}/src/haiway/__init__.py

@@ -15,6 +15,7 @@ from haiway.helpers import (
     throttle,
     timeout,
     traced,
+    wrap_async,
 )
 from haiway.state import State
 from haiway.types import (
@@ -76,4 +77,5 @@ __all__ = [
     "timeout",
     "traced",
     "when_missing",
+    "wrap_async",
 ]

haiway-0.5.1/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.1}/src/haiway/helpers/__init__.py

@@ -1,4 +1,4 @@
-from haiway.helpers.asynchrony import asynchronous
+from haiway.helpers.asynchrony import asynchronous, wrap_async
 from haiway.helpers.caching import cache
 from haiway.helpers.retries import retry
 from haiway.helpers.throttling import throttle
@@ -14,4 +14,5 @@ __all__ = [
     "throttle",
     "timeout",
     "traced",
+    "wrap_async",
 ]

{haiway-0.4.0 → haiway-0.5.1}/src/haiway/helpers/asynchrony.py

@@ -9,9 +9,26 @@ from haiway.types.missing import MISSING, Missing
 
 __all__ = [
     "asynchronous",
+    "wrap_async",
 ]
 
 
+def wrap_async[**Args, Result](
+    function: Callable[Args, Coroutine[None, None, Result]] | Callable[Args, Result],
+    /,
+) -> Callable[Args, Coroutine[None, None, Result]]:
+    if iscoroutinefunction(function):
+        return function
+
+    else:
+
+        async def async_function(*args: Args.args, **kwargs: Args.kwargs) -> Result:
+            return cast(Callable[Args, Result], function)(*args, **kwargs)
+
+        _mimic_async(function, within=async_function)
+        return async_function
+
+
 @overload
 def asynchronous[**Args, Result]() -> (
     Callable[

{haiway-0.4.0 → haiway-0.5.1}/src/haiway/state/structure.py

@@ -16,7 +16,7 @@ from weakref import WeakValueDictionary
 
 from haiway.state.attributes import AttributeAnnotation, attribute_annotations
 from haiway.state.validation import attribute_type_validator
-from haiway.types.missing import MISSING, Missing
+from haiway.types import MISSING, Missing, not_missing
 
 __all__ = [
     "State",
@@ -184,7 +184,13 @@ class State(metaclass=StateMeta):
         return self.__replace__(**kwargs)
 
     def as_dict(self) -> dict[str, Any]:
-        return vars(self)
+        dict_result: dict[str, Any] = {}
+        for key in self.__ATTRIBUTES__.keys():
+            value: Any | Missing = getattr(self, key, MISSING)
+            if not_missing(value):
+                dict_result[key] = value
+
+        return dict_result
 
     def __str__(self) -> str:
         attributes: str = ", ".join([f"{key}: {value}" for key, value in vars(self).items()])

{haiway-0.4.0 → haiway-0.5.1}/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.1/src/haiway.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: haiway
-Version: 0.4.0
+Version: 0.5.1
 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.1}/tests/test_state.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable
 from typing import Literal, Protocol, Self, TypedDict, runtime_checkable
 
-from haiway import State, frozenlist
+from haiway import MISSING, Missing, State, frozenlist
 
 
 def test_basic_initializes_with_arguments() -> None:
@@ -63,6 +63,17 @@ def test_basic_initializes_with_defaults() -> None:
     assert basic.optional is None
 
 
+def test_basic_equals_checks_properties() -> None:
+    class Basics(State):
+        string: str
+        integer: int
+
+    assert Basics(string="a", integer=1) == Basics(string="a", integer=1)
+    assert Basics(string="a", integer=1) != Basics(string="b", integer=1)
+    assert Basics(string="a", integer=1) != Basics(string="a", integer=2)
+    assert Basics(string="a", integer=1) != Basics(string="b", integer=2)
+
+
 def test_basic_initializes_with_arguments_and_defaults() -> None:
     class Basics(State):
         string: str
@@ -119,3 +130,23 @@ def test_nested_initializes_with_proper_arguments() -> None:
         recursion=None,
         self_recursion=None,
     )
+
+
+def test_dict_skips_missing_properties() -> None:
+    class Basics(State):
+        string: str
+        integer: int | Missing | None
+
+    assert Basics(string="a", integer=1).as_dict() == {"string": "a", "integer": 1}
+    assert Basics(string="a", integer=MISSING).as_dict() == {"string": "a"}
+    assert Basics(string="a", integer=None).as_dict() == {"string": "a", "integer": None}
+
+
+def test_initialization_allows_missing_properties() -> None:
+    class Basics(State):
+        string: str
+        integer: int | Missing | None
+
+    assert Basics(**{"string": "a", "integer": 1}) == Basics(string="a", integer=1)
+    assert Basics(**{"string": "a", "integer": None}) == Basics(string="a", integer=None)
+    assert Basics(**{"string": "a"}) == Basics(string="a", integer=MISSING)

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()