haiway 0.5.0__tar.gz → 0.5.2__tar.gz

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

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

{haiway-0.5.0 → haiway-0.5.2}/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.0 → haiway-0.5.2}/src/haiway/context/metrics.py

@@ -48,14 +48,14 @@ class ScopeMetrics:
         self._logger: Logger = logger or getLogger(name=scope)
         self._parent: Self | None = parent if parent else None
         self._metrics: dict[type[State], State] = {}
-        self._nested: set[ScopeMetrics] = set()
+        self._nested: list[ScopeMetrics] = []
         self._timestamp: float = monotonic()
         self._finished: bool = False
         self._loop: AbstractEventLoop = get_event_loop()
         self._completed: Future[float] = self._loop.create_future()
 
         if parent := parent:
-            parent._nested.add(self)
+            parent._nested.append(self)
 
         freeze(self)
 

{haiway-0.5.0 → haiway-0.5.2}/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.5.0 → haiway-0.5.2}/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.5.0 → haiway-0.5.2}/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.5.0 → haiway-0.5.2/src/haiway.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: haiway
-Version: 0.5.0
+Version: 0.5.2
 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.5.0 → haiway-0.5.2}/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)