haiway 0.5.3__tar.gz → 0.6.1__tar.gz

{haiway-0.5.3/src/haiway.egg-info → haiway-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: haiway
-Version: 0.5.3
+Version: 0.6.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
@@ -36,7 +36,8 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
-Requires-Dist: ruff~=0.5.0; extra == "dev"
+Requires-Dist: haiway; extra == "dev"
+Requires-Dist: ruff~=0.8.0; extra == "dev"
 Requires-Dist: pyright~=1.1; extra == "dev"
 Requires-Dist: bandit~=1.7; extra == "dev"
 Requires-Dist: pytest~=7.4; extra == "dev"

{haiway-0.5.3 → haiway-0.6.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.5.3"
+version = "0.6.1"
 readme = "README.md"
 maintainers = [
   { name = "Kacper Kaliński", email = "kacper.kalinski@miquido.com" },
@@ -28,7 +28,8 @@ Repository = "https://github.com/miquido/haiway.git"
 
 [project.optional-dependencies]
 dev = [
-  "ruff~=0.5.0",
+  "haiway",
+  "ruff~=0.8.0",
   "pyright~=1.1",
   "bandit~=1.7",
   "pytest~=7.4",

{haiway-0.5.3 → haiway-0.6.1}/src/haiway/context/access.py

@@ -1,8 +1,4 @@
-from asyncio import (
-    CancelledError,
-    Task,
-    current_task,
-)
+from asyncio import CancelledError, Task, current_task
 from collections.abc import (
     AsyncGenerator,
     AsyncIterator,

{haiway-0.5.3 → haiway-0.6.1}/src/haiway/helpers/tracing.py

@@ -1,5 +1,5 @@
 from asyncio import iscoroutinefunction
-from collections.abc import Callable, Coroutine
+from collections.abc import Callable, Coroutine, Mapping, Sequence
 from typing import Any, Self, cast
 
 from haiway.context import ctx
@@ -8,9 +8,9 @@ from haiway.types import MISSING, Missing
 from haiway.utils import mimic_function
 
 __all__ = [
-    "traced",
     "ArgumentsTrace",
     "ResultTrace",
+    "traced",
 ]
 
 
@@ -33,8 +33,8 @@ class ArgumentsTrace(State):
                 kwargs=MISSING,
             )
 
-    args: tuple[Any, ...] | Missing
-    kwargs: dict[str, Any] | Missing
+    args: Sequence[Any] | Missing
+    kwargs: Mapping[str, Any] | Missing
 
 
 class ResultTrace(State):

{haiway-0.5.3 → haiway-0.6.1}/src/haiway/state/attributes.py

@@ -17,8 +17,8 @@ from typing import (
 )
 
 __all__ = [
-    "attribute_annotations",
     "AttributeAnnotation",
+    "attribute_annotations",
 ]
 
 
@@ -42,6 +42,11 @@ class AttributeAnnotation:
             and self.arguments == other.arguments
         )
 
+    def __str__(self) -> str:
+        return f"{getattr(self.origin, "__name__", str(self.origin))}" + (
+            ("[" + ", ".join(str(arg) for arg in self.arguments) + "]") if self.arguments else ""
+        )
+
 
 def attribute_annotations(
     cls: type[Any],

{haiway-0.5.3 → haiway-0.6.1}/src/haiway/state/structure.py

@@ -1,6 +1,6 @@
 from collections.abc import Callable
 from copy import deepcopy
-from types import GenericAlias
+from types import EllipsisType, GenericAlias
 from typing import (
     Any,
     ClassVar,
@@ -15,7 +15,7 @@ from typing import (
 from weakref import WeakValueDictionary
 
 from haiway.state.attributes import AttributeAnnotation, attribute_annotations
-from haiway.state.validation import attribute_type_validator
+from haiway.state.validation import attribute_validator
 from haiway.types import MISSING, Missing, not_missing
 
 __all__ = [
@@ -80,7 +80,7 @@ class StateMeta(type):
                 attributes[key] = StateAttribute(
                     annotation=annotation,
                     default=getattr(state_type, key, MISSING),
-                    validator=attribute_type_validator(annotation),
+                    validator=attribute_validator(annotation),
                 )
 
         state_type.__ATTRIBUTES__ = attributes  # pyright: ignore[reportAttributeAccessIssue]
@@ -104,6 +104,7 @@ class State(metaclass=StateMeta):
     Base class for immutable data structures.
     """
 
+    __IMMUTABLE__: ClassVar[EllipsisType] = ...
     __ATTRIBUTES__: ClassVar[dict[str, StateAttribute[Any]]]
 
     def __class_getitem__(

haiway-0.6.1/src/haiway/state/validation.py

@@ -0,0 +1,297 @@
+from collections.abc import Callable, Mapping, Sequence, Set
+from enum import Enum
+from types import MappingProxyType, NoneType, UnionType
+from typing import Any, Literal, Protocol, Union
+from uuid import UUID
+
+from haiway.state.attributes import AttributeAnnotation
+from haiway.types import MISSING, Missing
+
+__all__ = [
+    "attribute_validator",
+]
+
+
+def attribute_validator(
+    annotation: AttributeAnnotation,
+    /,
+) -> Callable[[Any], Any]:
+    if validator := VALIDATORS.get(annotation.origin):
+        return validator(annotation)
+
+    elif hasattr(annotation.origin, "__IMMUTABLE__"):
+        return _prepare_validator_of_type(annotation)
+
+    elif issubclass(annotation.origin, Protocol):
+        return _prepare_validator_of_type(annotation)
+
+    elif issubclass(annotation.origin, Enum):
+        return _prepare_validator_of_type(annotation)
+
+    else:
+        raise TypeError(f"Unsupported type annotation: {annotation}")
+
+
+def _prepare_validator_of_any(
+    annotation: AttributeAnnotation,
+    /,
+) -> Callable[[Any], Any]:
+    def validator(
+        value: Any,
+    ) -> Any:
+        return value  # any is always valid
+
+    return validator
+
+
+def _prepare_validator_of_none(
+    annotation: AttributeAnnotation,
+    /,
+) -> Callable[[Any], Any]:
+    def validator(
+        value: Any,
+    ) -> Any:
+        if value is None:
+            return value
+
+        else:
+            raise TypeError(f"'{value}' is not matching expected type of 'None'")
+
+    return validator
+
+
+def _prepare_validator_of_missing(
+    annotation: AttributeAnnotation,
+    /,
+) -> Callable[[Any], Any]:
+    def validator(
+        value: Any,
+    ) -> Any:
+        if value is MISSING:
+            return value
+
+        else:
+            raise TypeError(f"'{value}' is not matching expected type of 'Missing'")
+
+    return validator
+
+
+def _prepare_validator_of_literal(
+    annotation: AttributeAnnotation,
+    /,
+) -> Callable[[Any], Any]:
+    elements: list[Any] = annotation.arguments
+    formatted_type: str = str(annotation)
+
+    def validator(
+        value: Any,
+    ) -> Any:
+        if value in elements:
+            return value
+
+        else:
+            raise ValueError(f"'{value}' is not matching expected values of '{formatted_type}'")
+
+    return validator
+
+
+def _prepare_validator_of_type(
+    annotation: AttributeAnnotation,
+    /,
+) -> Callable[[Any], Any]:
+    validated_type: type[Any] = annotation.origin
+    formatted_type: str = str(annotation)
+
+    def type_validator(
+        value: Any,
+    ) -> Any:
+        match value:
+            case value if isinstance(value, validated_type):
+                return value
+
+            case _:
+                raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+
+    return type_validator
+
+
+def _prepare_validator_of_set(
+    annotation: AttributeAnnotation,
+    /,
+) -> Callable[[Any], Any]:
+    element_validator: Callable[[Any], Any] = attribute_validator(annotation.arguments[0])
+    formatted_type: str = str(annotation)
+
+    def validator(
+        value: Any,
+    ) -> Any:
+        if isinstance(value, Set):
+            return frozenset(element_validator(element) for element in value)  # pyright: ignore[reportUnknownVariableType]
+
+        else:
+            raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+
+    return validator
+
+
+def _prepare_validator_of_sequence(
+    annotation: AttributeAnnotation,
+    /,
+) -> Callable[[Any], Any]:
+    element_validator: Callable[[Any], Any] = attribute_validator(annotation.arguments[0])
+    formatted_type: str = str(annotation)
+
+    def validator(
+        value: Any,
+    ) -> Any:
+        match value:
+            case [*elements]:
+                return tuple(element_validator(element) for element in elements)
+
+            case _:
+                raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+
+    return validator
+
+
+def _prepare_validator_of_mapping(
+    annotation: AttributeAnnotation,
+    /,
+) -> Callable[[Any], Any]:
+    key_validator: Callable[[Any], Any] = attribute_validator(annotation.arguments[0])
+    value_validator: Callable[[Any], Any] = attribute_validator(annotation.arguments[1])
+    formatted_type: str = str(annotation)
+
+    def validator(
+        value: Any,
+    ) -> Any:
+        match value:
+            case {**elements}:
+                return MappingProxyType(
+                    {key_validator(key): value_validator(value) for key, value in elements}
+                )
+
+            case _:
+                raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+
+    return validator
+
+
+def _prepare_validator_of_tuple(
+    annotation: AttributeAnnotation,
+    /,
+) -> Callable[[Any], Any]:
+    if annotation.arguments[-1].origin == Ellipsis:
+        element_validator: Callable[[Any], Any] = attribute_validator(annotation.arguments[0])
+        formatted_type: str = str(annotation)
+
+        def validator(
+            value: Any,
+        ) -> Any:
+            match value:
+                case [*elements]:
+                    return tuple(element_validator(element) for element in elements)
+
+                case _:
+                    raise TypeError(
+                        f"'{value}' is not matching expected type of '{formatted_type}'"
+                    )
+
+        return validator
+
+    else:
+        element_validators: list[Callable[[Any], Any]] = [
+            attribute_validator(alternative) for alternative in annotation.arguments
+        ]
+        elements_count: int = len(element_validators)
+        formatted_type: str = str(annotation)
+
+        def validator(
+            value: Any,
+        ) -> Any:
+            match value:
+                case [*elements]:
+                    if len(elements) != elements_count:
+                        raise ValueError(
+                            f"'{value}' is not matching expected type of '{formatted_type}'"
+                        )
+
+                    return tuple(
+                        element_validators[idx](value) for idx, value in enumerate(elements)
+                    )
+
+                case _:
+                    raise TypeError(
+                        f"'{value}' is not matching expected type of '{formatted_type}'"
+                    )
+
+        return validator
+
+
+def _prepare_validator_of_union(
+    annotation: AttributeAnnotation,
+    /,
+) -> Callable[[Any], Any]:
+    validators: list[Callable[[Any], Any]] = [
+        attribute_validator(alternative) for alternative in annotation.arguments
+    ]
+    formatted_type: str = str(annotation)
+
+    def validator(
+        value: Any,
+    ) -> Any:
+        errors: list[Exception] = []
+        for validator in validators:
+            try:
+                return validator(value)
+
+            except Exception as exc:
+                errors.append(exc)
+
+        raise ExceptionGroup(
+            f"'{value}' is not matching expected type of '{formatted_type}'",
+            errors,
+        )
+
+    return validator
+
+
+def _prepare_validator_of_callable(
+    annotation: AttributeAnnotation,
+    /,
+) -> Callable[[Any], Any]:
+    formatted_type: str = str(annotation)
+
+    def validator(
+        value: Any,
+    ) -> Any:
+        if callable(value):
+            return value
+
+        else:
+            raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+
+    return validator
+
+
+VALIDATORS: Mapping[Any, Callable[[AttributeAnnotation], Callable[[Any], Any]]] = {
+    Any: _prepare_validator_of_any,
+    NoneType: _prepare_validator_of_none,
+    Missing: _prepare_validator_of_missing,
+    type: _prepare_validator_of_type,
+    bool: _prepare_validator_of_type,
+    int: _prepare_validator_of_type,
+    float: _prepare_validator_of_type,
+    bytes: _prepare_validator_of_type,
+    str: _prepare_validator_of_type,
+    tuple: _prepare_validator_of_tuple,
+    frozenset: _prepare_validator_of_set,
+    Literal: _prepare_validator_of_literal,
+    Set: _prepare_validator_of_set,
+    Sequence: _prepare_validator_of_sequence,
+    Mapping: _prepare_validator_of_mapping,
+    UUID: _prepare_validator_of_type,
+    Union: _prepare_validator_of_union,
+    UnionType: _prepare_validator_of_union,
+    Callable: _prepare_validator_of_callable,
+}

{haiway-0.5.3 → haiway-0.6.1/src/haiway.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: haiway
-Version: 0.5.3
+Version: 0.6.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
@@ -36,7 +36,8 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
-Requires-Dist: ruff~=0.5.0; extra == "dev"
+Requires-Dist: haiway; extra == "dev"
+Requires-Dist: ruff~=0.8.0; extra == "dev"
 Requires-Dist: pyright~=1.1; extra == "dev"
 Requires-Dist: bandit~=1.7; extra == "dev"
 Requires-Dist: pytest~=7.4; extra == "dev"

{haiway-0.5.3 → haiway-0.6.1}/src/haiway.egg-info/requires.txt

@@ -1,6 +1,7 @@
 
 [dev]
-ruff~=0.5.0
+haiway
+ruff~=0.8.0
 pyright~=1.1
 bandit~=1.7
 pytest~=7.4

{haiway-0.5.3 → haiway-0.6.1}/tests/test_async_queue.py

@@ -1,8 +1,9 @@
 from asyncio import CancelledError
 
-from haiway import AsyncQueue, ctx
 from pytest import mark, raises
 
+from haiway import AsyncQueue, ctx
+
 
 class FakeException(Exception):
     pass

{haiway-0.5.3 → haiway-0.6.1}/tests/test_auto_retry.py

@@ -2,9 +2,10 @@ from asyncio import CancelledError, Task, sleep
 from time import time
 from unittest import TestCase
 
-from haiway import retry
 from pytest import mark, raises
 
+from haiway import retry
+
 
 class FakeException(Exception):
     pass

{haiway-0.5.3 → haiway-0.6.1}/tests/test_cache.py

@@ -2,9 +2,10 @@ from asyncio import CancelledError, Task, sleep
 from collections.abc import Callable, Generator
 from time import sleep as sync_sleep
 
-from haiway import cache
 from pytest import fixture, mark, raises
 
+from haiway import cache
+
 
 class FakeException(Exception):
     pass

{haiway-0.5.3 → haiway-0.6.1}/tests/test_context.py

@@ -1,8 +1,9 @@
 from asyncio import get_running_loop
 
-from haiway import MissingContext, ScopeMetrics, State, ctx
 from pytest import mark, raises
 
+from haiway import MissingContext, ScopeMetrics, State, ctx
+
 
 class ExampleState(State):
     state: str = "default"

{haiway-0.5.3 → haiway-0.6.1}/tests/test_state.py

@@ -1,21 +1,26 @@
-from collections.abc import Callable
-from typing import Literal, Protocol, Self, TypedDict, runtime_checkable
+from collections.abc import Callable, Sequence, Set
+from enum import StrEnum
+from typing import Literal, Protocol, Self, runtime_checkable
+from uuid import UUID, uuid4
 
 from haiway import MISSING, Missing, State, frozenlist
 
 
 def test_basic_initializes_with_arguments() -> None:
-    class DictTyped(TypedDict):
-        value: str
+    class Selection(StrEnum):
+        A = "A"
+        B = "A"
 
     @runtime_checkable
     class Proto(Protocol):
         def __call__(self) -> None: ...
 
     class Basics(State):
+        uuid: UUID
         string: str
         literal: Literal["A", "B"]
-        sequence: list[str]
+        sequence: Sequence[str]
+        string_set: Set[str]
         frozen: frozenlist[int]
         integer: int
         union: str | int
@@ -23,12 +28,14 @@ def test_basic_initializes_with_arguments() -> None:
         none: None
         function: Callable[[], None]
         proto: Proto
-        dict_typed: DictTyped
+        selection: Selection
 
     basic = Basics(
+        uuid=uuid4(),
         string="string",
         literal="A",
         sequence=["a", "b", "c"],
+        string_set={"a", "b"},
         frozen=(1, 2, 3),
         integer=0,
         union="union",
@@ -36,17 +43,18 @@ def test_basic_initializes_with_arguments() -> None:
         none=None,
         function=lambda: None,
         proto=lambda: None,
-        dict_typed={"value": "42"},
+        selection=Selection.A,
     )
     assert basic.string == "string"
     assert basic.literal == "A"
-    assert basic.sequence == ["a", "b", "c"]
+    assert basic.sequence == ("a", "b", "c")
+    assert basic.string_set == {"a", "b"}
     assert basic.frozen == (1, 2, 3)
     assert basic.integer == 0
     assert basic.union == "union"
     assert basic.optional == "optional"
     assert basic.none is None
-    assert basic.dict_typed == {"value": "42"}
+    assert basic.selection == Selection.A
     assert callable(basic.function)
     assert isinstance(basic.proto, Proto)
 

{haiway-0.5.3 → haiway-0.6.1}/tests/test_streaming.py

@@ -1,10 +1,11 @@
 from asyncio import CancelledError, get_running_loop, sleep
 from collections.abc import AsyncGenerator, AsyncIterator
 
+from pytest import mark, raises
+
 from haiway import ctx
 from haiway.context.metrics import ScopeMetrics
 from haiway.state.structure import State
-from pytest import mark, raises
 
 
 class FakeException(Exception):

{haiway-0.5.3 → haiway-0.6.1}/tests/test_timeout.py

@@ -1,8 +1,9 @@
 from asyncio import CancelledError, Task, sleep
 
-from haiway import timeout
 from pytest import mark, raises
 
+from haiway import timeout
+
 
 class FakeException(Exception):
     pass

haiway-0.5.3/src/haiway/state/validation.py

@@ -1,149 +0,0 @@
-import types
-import typing
-from collections.abc import Callable, Sequence
-from typing import Any
-
-from haiway import types as _types
-from haiway.state.attributes import AttributeAnnotation
-
-__all__ = [
-    "attribute_type_validator",
-]
-
-
-def attribute_type_validator(  # noqa: PLR0911
-    annotation: AttributeAnnotation,
-    /,
-) -> Callable[[Any], Any]:
-    match annotation.origin:
-        case types.NoneType:
-            return _none_validator
-
-        case _types.Missing:
-            return _missing_validator
-
-        case types.UnionType:
-            return _prepare_union_validator(annotation.arguments)
-
-        case typing.Literal:
-            return _prepare_literal_validator(annotation.arguments)
-
-        case typing.Any:
-            return _any_validator
-
-        # typed dicts fail on type checks
-        case typed_dict if typing.is_typeddict(typed_dict):
-            return _prepare_typed_dict_validator(typed_dict)
-
-        case type() as other_type:
-            return _prepare_type_validator(other_type)
-
-        case other:
-            raise TypeError(f"Unsupported type annotation: {other}")
-
-
-def _none_validator(
-    value: Any,
-) -> Any:
-    match value:
-        case None:
-            return None
-
-        case _:
-            raise TypeError(f"Type '{type(value)}' is not matching expected type 'None'")
-
-
-def _missing_validator(
-    value: Any,
-) -> Any:
-    match value:
-        case _types.Missing():
-            return _types.MISSING
-
-        case _:
-            raise TypeError(f"Type '{type(value)}' is not matching expected type 'Missing'")
-
-
-def _any_validator(
-    value: Any,
-) -> Any:
-    return value  # any is always valid
-
-
-def _prepare_union_validator(
-    elements: Sequence[AttributeAnnotation],
-    /,
-) -> Callable[[Any], Any]:
-    validators: list[Callable[[Any], Any]] = [
-        attribute_type_validator(alternative) for alternative in elements
-    ]
-
-    def union_validator(
-        value: Any,
-    ) -> Any:
-        errors: list[Exception] = []
-        for validator in validators:
-            try:
-                return validator(value)
-
-            except Exception as exc:
-                errors.append(exc)
-
-        raise ExceptionGroup("Multiple errors", errors)
-
-    return union_validator
-
-
-def _prepare_literal_validator(
-    elements: Sequence[Any],
-    /,
-) -> Callable[[Any], Any]:
-    def literal_validator(
-        value: Any,
-    ) -> Any:
-        if value in elements:
-            return value
-
-        else:
-            raise ValueError(f"Value '{value}' is not matching expected '{elements}'")
-
-    return literal_validator
-
-
-def _prepare_type_validator(
-    validated_type: type[Any],
-    /,
-) -> Callable[[Any], Any]:
-    def type_validator(
-        value: Any,
-    ) -> Any:
-        match value:
-            case value if isinstance(value, validated_type):
-                return value
-
-            case _:
-                raise TypeError(
-                    f"Type '{type(value)}' is not matching expected type '{validated_type}'"
-                )
-
-    return type_validator
-
-
-def _prepare_typed_dict_validator(
-    validated_type: type[Any],
-    /,
-) -> Callable[[Any], Any]:
-    def typed_dict_validator(
-        value: Any,
-    ) -> Any:
-        match value:
-            case value if isinstance(value, dict):
-                # for typed dicts check only if that is a dict
-                return value  # pyright: ignore[reportUnknownVariableType]
-
-            case _:
-                raise TypeError(
-                    f"Type '{type(value)}' is not matching expected type '{validated_type}'"
-                )
-
-    return typed_dict_validator

{haiway-0.5.3 → haiway-0.6.1}/src/haiway/__init__.py

@@ -43,16 +43,23 @@ from haiway.utils import (
 )
 
 __all__ = [
-    "always",
+    "MISSING",
     "ArgumentsTrace",
+    "AsyncQueue",
+    "Disposable",
+    "Disposables",
+    "Missing",
+    "MissingContext",
+    "MissingState",
+    "ResultTrace",
+    "ScopeMetrics",
+    "State",
+    "always",
     "async_always",
     "async_noop",
     "asynchronous",
-    "AsyncQueue",
     "cache",
     "ctx",
-    "Disposable",
-    "Disposables",
     "freeze",
     "frozenlist",
     "getenv_bool",
@@ -62,17 +69,10 @@ __all__ = [
     "is_missing",
     "load_env",
     "mimic_function",
-    "Missing",
-    "MISSING",
-    "MissingContext",
-    "MissingState",
     "noop",
     "not_missing",
-    "ResultTrace",
     "retry",
-    "ScopeMetrics",
     "setup_logging",
-    "State",
     "throttle",
     "timeout",
     "traced",

{haiway-0.5.3 → haiway-0.6.1}/src/haiway/context/__init__.py

@@ -4,10 +4,10 @@ from haiway.context.metrics import ScopeMetrics
 from haiway.context.types import MissingContext, MissingState
 
 __all__ = [
-    "ctx",
     "Disposable",
     "Disposables",
     "MissingContext",
     "MissingState",
     "ScopeMetrics",
+    "ctx",
 ]

{haiway-0.5.3 → haiway-0.6.1}/src/haiway/helpers/__init__.py

@@ -7,9 +7,9 @@ from haiway.helpers.tracing import ArgumentsTrace, ResultTrace, traced
 
 __all__ = [
     "ArgumentsTrace",
+    "ResultTrace",
     "asynchronous",
     "cache",
-    "ResultTrace",
     "retry",
     "throttle",
     "timeout",

{haiway-0.5.3 → haiway-0.6.1}/src/haiway/state/__init__.py

@@ -2,7 +2,7 @@ from haiway.state.attributes import AttributeAnnotation, attribute_annotations
 from haiway.state.structure import State
 
 __all__ = [
-    "attribute_annotations",
     "AttributeAnnotation",
     "State",
+    "attribute_annotations",
 ]

{haiway-0.5.3 → haiway-0.6.1}/src/haiway/types/__init__.py

@@ -2,10 +2,10 @@ from haiway.types.frozen import frozenlist
 from haiway.types.missing import MISSING, Missing, is_missing, not_missing, when_missing
 
 __all__ = [
+    "MISSING",
+    "Missing",
     "frozenlist",
     "is_missing",
-    "Missing",
-    "MISSING",
     "not_missing",
     "when_missing",
 ]

{haiway-0.5.3 → haiway-0.6.1}/src/haiway/utils/__init__.py

@@ -7,10 +7,10 @@ from haiway.utils.noop import async_noop, noop
 from haiway.utils.queue import AsyncQueue
 
 __all__ = [
+    "AsyncQueue",
     "always",
     "async_always",
     "async_noop",
-    "AsyncQueue",
     "freeze",
     "getenv_bool",
     "getenv_float",

{haiway-0.5.3 → haiway-0.6.1}/src/haiway/utils/env.py

@@ -3,8 +3,8 @@ from typing import overload
 
 __all__ = [
     "getenv_bool",
-    "getenv_int",
     "getenv_float",
+    "getenv_int",
     "getenv_str",
     "load_env",
 ]