haiway 0.5.3__py3-none-any.whl → 0.6.1__py3-none-any.whl

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/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/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/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/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/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/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/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/state/validation.py

@@ -1,119 +1,107 @@
-import types
-import typing
-from collections.abc import Callable, Sequence
-from typing import Any
+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 import types as _types
 from haiway.state.attributes import AttributeAnnotation
+from haiway.types import MISSING, Missing
 
 __all__ = [
-    "attribute_type_validator",
+    "attribute_validator",
 ]
 
 
-def attribute_type_validator(  # noqa: PLR0911
+def attribute_validator(
     annotation: AttributeAnnotation,
     /,
 ) -> Callable[[Any], Any]:
-    match annotation.origin:
-        case types.NoneType:
-            return _none_validator
+    if validator := VALIDATORS.get(annotation.origin):
+        return validator(annotation)
 
-        case _types.Missing:
-            return _missing_validator
+    elif hasattr(annotation.origin, "__IMMUTABLE__"):
+        return _prepare_validator_of_type(annotation)
 
-        case types.UnionType:
-            return _prepare_union_validator(annotation.arguments)
+    elif issubclass(annotation.origin, Protocol):
+        return _prepare_validator_of_type(annotation)
 
-        case typing.Literal:
-            return _prepare_literal_validator(annotation.arguments)
+    elif issubclass(annotation.origin, Enum):
+        return _prepare_validator_of_type(annotation)
 
-        case typing.Any:
-            return _any_validator
+    else:
+        raise TypeError(f"Unsupported type annotation: {annotation}")
 
-        # 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 _prepare_validator_of_any(
+    annotation: AttributeAnnotation,
+    /,
+) -> Callable[[Any], Any]:
+    def validator(
+        value: Any,
+    ) -> Any:
+        return value  # any is always valid
 
+    return validator
 
-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 _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'")
 
-def _any_validator(
-    value: Any,
-) -> Any:
-    return value  # any is always valid
+    return validator
 
 
-def _prepare_union_validator(
-    elements: Sequence[AttributeAnnotation],
+def _prepare_validator_of_missing(
+    annotation: AttributeAnnotation,
     /,
 ) -> Callable[[Any], Any]:
-    validators: list[Callable[[Any], Any]] = [
-        attribute_type_validator(alternative) for alternative in elements
-    ]
-
-    def union_validator(
+    def validator(
         value: Any,
     ) -> Any:
-        errors: list[Exception] = []
-        for validator in validators:
-            try:
-                return validator(value)
-
-            except Exception as exc:
-                errors.append(exc)
+        if value is MISSING:
+            return value
 
-        raise ExceptionGroup("Multiple errors", errors)
+        else:
+            raise TypeError(f"'{value}' is not matching expected type of 'Missing'")
 
-    return union_validator
+    return validator
 
 
-def _prepare_literal_validator(
-    elements: Sequence[Any],
+def _prepare_validator_of_literal(
+    annotation: AttributeAnnotation,
     /,
 ) -> Callable[[Any], Any]:
-    def literal_validator(
+    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 '{value}' is not matching expected '{elements}'")
+            raise ValueError(f"'{value}' is not matching expected values of '{formatted_type}'")
 
-    return literal_validator
+    return validator
 
 
-def _prepare_type_validator(
-    validated_type: type[Any],
+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:
@@ -122,28 +110,188 @@ def _prepare_type_validator(
                 return value
 
             case _:
-                raise TypeError(
-                    f"Type '{type(value)}' is not matching expected type '{validated_type}'"
-                )
+                raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
 
     return type_validator
 
 
-def _prepare_typed_dict_validator(
-    validated_type: type[Any],
+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]:
-    def typed_dict_validator(
+    element_validator: Callable[[Any], Any] = attribute_validator(annotation.arguments[0])
+    formatted_type: str = str(annotation)
+
+    def 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 [*elements]:
+                return tuple(element_validator(element) for element in elements)
 
             case _:
-                raise TypeError(
-                    f"Type '{type(value)}' is not matching expected type '{validated_type}'"
+                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}
                 )
 
-    return typed_dict_validator
+            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/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/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/utils/env.py

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

{haiway-0.5.3.dist-info → haiway-0.6.1.dist-info}/METADATA

@@ -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.dist-info → haiway-0.6.1.dist-info}/RECORD

@@ -1,36 +1,36 @@
-haiway/__init__.py,sha256=ll2vI5w5LYylT0jdTE8_clfQJ2rpL4GKh8tR3Lr80j0,1301
+haiway/__init__.py,sha256=QksN9EkQrmsYuOhkrKNYr-RMLDT7hixuplkLmJntIfc,1301
 haiway/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-haiway/context/__init__.py,sha256=21Y3zvRo1bHASZD6B_FNkU28k1-g88RdmUyqxvYXJxg,336
-haiway/context/access.py,sha256=zPQcQBp5XMlNuszbxhtzi-5mNpDLpZ6PT-gVFDBH0dA,14115
+haiway/context/__init__.py,sha256=ZgQoQFUqfPDqeIbhS898C3dP02QzOCRmClVQpHaPTBA,336
+haiway/context/access.py,sha256=CB-F9Yd6EAoJIqzMQGid9szww7aFiti5z6x0T79LV7k,14098
 haiway/context/disposables.py,sha256=DZjnMp-wMfF-em2Wjhbm1MvXubNpuzFBT70BQNIxC7M,2019
 haiway/context/metrics.py,sha256=z5p5ItzXhrYoF8lgC8u179oABBy66mPeCEJR_GKmrLg,10882
 haiway/context/state.py,sha256=GxGwPQTK8FdSprBd83lQbA9veubp0o93_1Yk3gb7HMc,3000
 haiway/context/tasks.py,sha256=xXtXIUwXOra0EePTdkcEbMOmpWwFcO3hCRfR_IfvAHk,1978
 haiway/context/types.py,sha256=VvJA7wAPZ3ISpgyThVguioYUXqhHf0XkPfRd0M1ERiQ,142
-haiway/helpers/__init__.py,sha256=ZKa1_xreEVRcYrPTuPn5MRe-WrVFZ_FojswEtMqD5Qw,473
+haiway/helpers/__init__.py,sha256=iiFTjGnVf6dB7Gry5FuS5SFiU1lGI09JBTGoa3sozLI,473
 haiway/helpers/asynchrony.py,sha256=rh_Hwo0MQHfKnw5dLUCFTAm3Fk3SVS8Or8cTcQFdPA8,6042
 haiway/helpers/caching.py,sha256=Ok_WE5Whe7XqnIuLZo4rNNBFeWap-aUWX799s4b1JAQ,9536
 haiway/helpers/retries.py,sha256=gIkyUlqJLDYaxIZd3qzeqGFY9y5Gp8dgZLlZ6hs8hoc,7538
 haiway/helpers/throttling.py,sha256=zo0OwFq64si5KUwhd58cFHLmGAmYwRbFRJMbv9suhPs,3844
 haiway/helpers/timeouted.py,sha256=1xU09hQnFdj6p48BwZl5xUvtIr3zC0ZUXehkdrduCjs,3074
-haiway/helpers/tracing.py,sha256=yiK8MdDyX_fmpK9Zu5-IiZae5E8ReKQtRBBenXIPVqQ,3326
-haiway/state/__init__.py,sha256=dh7l_ZImy0uHHDGD-fzMhQFmz_ej8WU8WEE2OmIoyVM,204
-haiway/state/attributes.py,sha256=kkIYNlvWCM1NkgiCbE6gZDwgBVOk_TkmqWv67MmU0to,13399
-haiway/state/structure.py,sha256=l8iYMCLEg5v1JVMwZ4R-YAXoQQZWkbWZyN6LcnzKqPQ,7237
-haiway/state/validation.py,sha256=Z6kp_KjTnnP9eVWsLmzKkEQLZkhFCOSphjdbr6VxLFQ,3628
-haiway/types/__init__.py,sha256=cAJQzDgFi8AKRqpzY3HWrutaPR69tnJqeJK_mQVtYUk,252
+haiway/helpers/tracing.py,sha256=eQpkIoGSB51jRF8RcLaihvHX3VzJIRdyRxTx3I14Pzg,3346
+haiway/state/__init__.py,sha256=nPVHBySLuOdIL1VSIs-mo64s53xYHIbieELhw8mQgyc,204
+haiway/state/attributes.py,sha256=gS4sEp50bDLAb3Y477BvagobvgMekUkiZZ64ZX6Avac,13613
+haiway/state/structure.py,sha256=r8q2d3ro3C0kKYrdx9IE-bY2mKMVRwYC7d5Oeazj83Y,7289
+haiway/state/validation.py,sha256=3vCXvr6dBBOS5W482PsLLY801jq2NMgEc-EVkg6LzUA,8264
+haiway/types/__init__.py,sha256=00Ulp2BxcIWm9vWXKQPodpFEwE8hpqj6OYgrNxelp5s,252
 haiway/types/frozen.py,sha256=CZhFCXnWAKEhuWSfILxA8smfdpMd5Ku694ycfLh98R8,76
 haiway/types/missing.py,sha256=JiXo5xdi7H-PbIJr0fuK5wpOuQZhjrDYUkMlfIFcsaE,1705
-haiway/utils/__init__.py,sha256=UA9h8YDvYI5rYujvsIS9t5Q-SWYImmk30uhR_42flqs,608
+haiway/utils/__init__.py,sha256=2-qlRK876IIfLIn24SxZ_8zKvkmTmBimurNOQLN9rNw,608
 haiway/utils/always.py,sha256=2abp8Lm9rQkrfS3rm1Iqhb-IcWyVfH1BULab3KMxgOw,1234
-haiway/utils/env.py,sha256=lKPOBZWyRD_gQariDGBjVLYTm0740nytPCSQpK2oRyE,3136
+haiway/utils/env.py,sha256=lhJZphHhb32jgbTrMO58g-tK_UDTulAP-rhpJMFdfGQ,3136
 haiway/utils/immutable.py,sha256=K34ZIMzbkpgkHKH-KF73plEbXExsajNRkRTYp9nJEf4,620
 haiway/utils/logs.py,sha256=oDsc1ZdqKDjlTlctLbDcp9iX98Acr-1tdw-Pyg3DElo,1577
 haiway/utils/mimic.py,sha256=BkVjTVP2TxxC8GChPGyDV6UXVwJmiRiSWeOYZNZFHxs,1828
 haiway/utils/noop.py,sha256=qgbZlOKWY6_23Zs43OLukK2HagIQKRyR04zrFVm5rWI,344
 haiway/utils/queue.py,sha256=oQ3GXCJ-PGNtMEr6EPdgqAvYZoj8lAa7Z2drBKBEoBM,2345
-haiway-0.5.3.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
-haiway-0.5.3.dist-info/METADATA,sha256=EIKsHf3PK90WS36SFw_O25suR9ko6Te59KooRXCQFf8,3860
-haiway-0.5.3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-haiway-0.5.3.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
-haiway-0.5.3.dist-info/RECORD,,
+haiway-0.6.1.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
+haiway-0.6.1.dist-info/METADATA,sha256=IGAF9VfS0SEIyN8N6JUnuCcpPQNY7A9fovFapfJ6_ck,3898
+haiway-0.6.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+haiway-0.6.1.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
+haiway-0.6.1.dist-info/RECORD,,