haiway 0.6.4__py3-none-any.whl → 0.7.1__py3-none-any.whl

haiway/state/structure.py

@@ -1,4 +1,5 @@
-from collections.abc import Callable
+import typing
+from collections.abc import Mapping
 from copy import deepcopy
 from types import EllipsisType, GenericAlias
 from typing import (
@@ -10,13 +11,15 @@ from typing import (
     cast,
     dataclass_transform,
     final,
-    get_origin,
 )
 from weakref import WeakValueDictionary
 
 from haiway.state.attributes import AttributeAnnotation, attribute_annotations
 from haiway.state.path import AttributePath
-from haiway.state.validation import attribute_validator
+from haiway.state.validation import (
+    AttributeValidation,
+    AttributeValidator,
+)
 from haiway.types import MISSING, Missing, not_missing
 
 __all__ = [
@@ -28,13 +31,15 @@ __all__ = [
 class StateAttribute[Value]:
     def __init__(
         self,
+        name: str,
         annotation: AttributeAnnotation,
         default: Value | Missing,
-        validator: Callable[[Any], Value],
+        validator: AttributeValidation[Value],
     ) -> None:
+        self.name: str = name
         self.annotation: AttributeAnnotation = annotation
         self.default: Value | Missing = default
-        self.validator: Callable[[Any], Value] = validator
+        self.validator: AttributeValidation[Value] = validator
 
     def validated(
         self,
@@ -69,28 +74,119 @@ class StateMeta(type):
 
         attributes: dict[str, StateAttribute[Any]] = {}
 
-        if bases:  # handle base class
-            for key, annotation in attribute_annotations(
-                state_type,
-                type_parameters=type_parameters,
-            ).items():
-                # do not include ClassVars and dunder items
-                if ((get_origin(annotation) or annotation) is ClassVar) or key.startswith("__"):
-                    continue
-
-                attributes[key] = StateAttribute(
-                    annotation=annotation,
-                    default=getattr(state_type, key, MISSING),
-                    validator=attribute_validator(annotation),
-                )
+        for key, annotation in attribute_annotations(
+            state_type,
+            type_parameters=type_parameters or {},
+        ).items():
+            default: Any = getattr(state_type, key, MISSING)
+            attributes[key] = StateAttribute(
+                name=key,
+                annotation=annotation.update_required(default is MISSING),
+                default=default,
+                validator=AttributeValidator.of(
+                    annotation,
+                    recursion_guard={
+                        str(AttributeAnnotation(origin=state_type)): state_type.validator
+                    },
+                ),
+            )
 
+        state_type.__PARAMETERS__ = type_parameters  # pyright: ignore[reportAttributeAccessIssue]
         state_type.__ATTRIBUTES__ = attributes  # pyright: ignore[reportAttributeAccessIssue]
         state_type.__slots__ = frozenset(attributes.keys())  # pyright: ignore[reportAttributeAccessIssue]
         state_type.__match_args__ = state_type.__slots__  # pyright: ignore[reportAttributeAccessIssue]
-        state_type._ = AttributePath(state_type, attribute=state_type)  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+        state_type._ = AttributePath(state_type, attribute=state_type)  # pyright: ignore[reportCallIssue, reportUnknownMemberType, reportAttributeAccessIssue]
 
         return state_type
 
+    def validator(
+        cls,
+        value: Any,
+        /,
+    ) -> Any: ...
+
+    def __instancecheck__(
+        self,
+        instance: Any,
+    ) -> bool:
+        # check for type match
+        if self.__subclasscheck__(type(instance)):  # pyright: ignore[reportUnknownArgumentType]
+            return True
+
+        # otherwise check if we are dealing with unparametrized base
+        # against the parametrized one, our generic subtypes have base of unparametrized type
+        if type(instance) not in self.__bases__:
+            return False
+
+        try:
+            # validate instance to check unparametrized fields
+            _ = self(**vars(instance))
+
+        except Exception:
+            return False
+
+        else:
+            return True
+
+    def __subclasscheck__(  # noqa: C901, PLR0911, PLR0912
+        self,
+        subclass: type[Any],
+    ) -> bool:
+        # check if we are the same class for early exit
+        if self == subclass:
+            return True
+
+        # then check if we are parametrized
+        checked_parameters: Mapping[str, Any] | None = getattr(
+            self,
+            "__PARAMETERS__",
+            None,
+        )
+        if checked_parameters is None:
+            # if we are not parametrized allow any subclass
+            return self in subclass.__bases__
+
+        # verify if we have common base next - our generic subtypes have the same base
+        if self.__bases__ == subclass.__bases__:
+            # if we have the same bases we have different generic subtypes
+            # we can verify all of the attributes to check if we have common base
+            available_parameters: Mapping[str, Any] | None = getattr(
+                subclass,
+                "__PARAMETERS__",
+                None,
+            )
+
+            if available_parameters is None:
+                # if we have no parameters at this stage this is a serious bug
+                raise RuntimeError("Invalid type parametrization for %s", subclass)
+
+            for key, param in checked_parameters.items():
+                match available_parameters.get(key):
+                    case None:  # if any parameter is missing we should not be there already
+                        return False
+
+                    case typing.Any:
+                        continue  # Any ignores type checks
+
+                    case checked:
+                        if param is Any:
+                            continue  # Any ignores type checks
+
+                        elif issubclass(checked, param):
+                            continue  # if we have matching type we are fine
+
+                        else:
+                            return False  # types are not matching
+
+            return True  # when all parameters were matching we have matching subclass
+
+        elif subclass in self.__bases__:  # our generic subtypes have base of unparametrized type
+            # if subclass parameters were not provided then we can be valid ony if all were Any
+            return all(param is Any for param in checked_parameters.values())
+
+        else:
+            return False  # we have different base / comparing to not parametrized
+
 
 _types_cache: WeakValueDictionary[
     tuple[
@@ -108,13 +204,16 @@ class State(metaclass=StateMeta):
 
     _: ClassVar[Self]
     __IMMUTABLE__: ClassVar[EllipsisType] = ...
+    __PARAMETERS__: ClassVar[Mapping[str, Any] | None] = None
     __ATTRIBUTES__: ClassVar[dict[str, StateAttribute[Any]]]
 
+    @classmethod
     def __class_getitem__(
         cls,
         type_argument: tuple[type[Any], ...] | type[Any],
     ) -> type[Self]:
         assert Generic in cls.__bases__, "Can't specialize non generic type!"  # nosec: B101
+        assert cls.__PARAMETERS__ is None, "Can't specialize already specialized type!"  # nosec: B101
 
         type_arguments: tuple[type[Any], ...]
         match type_argument:
@@ -165,6 +264,22 @@ class State(metaclass=StateMeta):
         _types_cache[(cls, type_arguments)] = parametrized_type
         return parametrized_type
 
+    @classmethod
+    def validator(
+        cls,
+        value: Any,
+        /,
+    ) -> Self:
+        match value:
+            case validated if isinstance(validated, cls):
+                return validated
+
+            case {**values}:
+                return cls(**values)
+
+            case _:
+                raise TypeError(f"Expected '{cls.__name__}', received '{type(value).__name__}'")
+
     def __init__(
         self,
         **kwargs: Any,

haiway/state/validation.py

@@ -1,10 +1,10 @@
-from collections.abc import Callable, Mapping, Sequence, Set
+from collections.abc import Callable, Mapping, MutableMapping, Sequence, Set
 from datetime import date, datetime, time, timedelta, timezone
 from enum import Enum
 from pathlib import Path
 from re import Pattern
-from types import MappingProxyType, NoneType, UnionType
-from typing import Any, Literal, Protocol, Union
+from types import EllipsisType, NoneType, UnionType
+from typing import Any, Literal, Protocol, Self, Union, is_typeddict
 from typing import Mapping as MappingType  # noqa: UP035
 from typing import Sequence as SequenceType  # noqa: UP035
 from typing import Sequence as SetType  # noqa: UP035
@@ -14,36 +14,90 @@ from haiway.state.attributes import AttributeAnnotation
 from haiway.types import MISSING, Missing
 
 __all__ = [
-    "attribute_validator",
+    "AttributeValidation",
+    "AttributeValidationError",
+    "AttributeValidator",
 ]
 
 
-def attribute_validator(
-    annotation: AttributeAnnotation,
-    /,
-) -> Callable[[Any], Any]:
-    if validator := VALIDATORS.get(annotation.origin):
-        return validator(annotation)
+class AttributeValidation[Type](Protocol):
+    def __call__(
+        self,
+        value: Any,
+        /,
+    ) -> Type: ...
 
-    elif hasattr(annotation.origin, "__IMMUTABLE__"):
-        return _prepare_validator_of_type(annotation)
 
-    elif issubclass(annotation.origin, Protocol):
-        return _prepare_validator_of_type(annotation)
+class AttributeValidationError(Exception):
+    pass
 
-    elif issubclass(annotation.origin, Enum):
-        return _prepare_validator_of_type(annotation)
 
-    else:
-        raise TypeError(f"Unsupported type annotation: {annotation}")
+class AttributeValidator[Type]:
+    @classmethod
+    def of(
+        cls,
+        annotation: AttributeAnnotation,
+        /,
+        *,
+        recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+    ) -> AttributeValidation[Any]:
+        if isinstance(annotation.origin, NotImplementedError | RuntimeError):
+            raise annotation.origin  # raise an error if origin was not properly resolved
+
+        if recursive := recursion_guard.get(str(annotation)):
+            return recursive
+
+        validator: Self = cls(
+            annotation,
+            validation=MISSING,
+        )
+        recursion_guard[str(annotation)] = validator
+
+        if common := VALIDATORS.get(annotation.origin):
+            validator.validation = common(annotation, recursion_guard)
+
+        elif hasattr(annotation.origin, "__IMMUTABLE__"):
+            validator.validation = _prepare_validator_of_type(annotation, recursion_guard)
+
+        elif is_typeddict(annotation.origin):
+            validator.validation = _prepare_validator_of_typed_dict(annotation, recursion_guard)
+
+        elif issubclass(annotation.origin, Protocol):
+            validator.validation = _prepare_validator_of_type(annotation, recursion_guard)
+
+        elif issubclass(annotation.origin, Enum):
+            validator.validation = _prepare_validator_of_type(annotation, recursion_guard)
+
+        else:
+            raise TypeError(f"Unsupported type annotation: {annotation}")
+
+        return validator
+
+    def __init__(
+        self,
+        annotation: AttributeAnnotation,
+        validation: AttributeValidation[Type] | Missing,
+    ) -> None:
+        self.annotation: AttributeAnnotation = annotation
+        self.validation: AttributeValidation[Type] | Missing = validation
+
+    def __call__(
+        self,
+        value: Any,
+        /,
+    ) -> Any:
+        assert self.validation is not MISSING  # nosec: B101
+        return self.validation(value)  # pyright: ignore[reportCallIssue, reportUnknownVariableType]
 
 
 def _prepare_validator_of_any(
     annotation: AttributeAnnotation,
     /,
-) -> Callable[[Any], Any]:
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
     def validator(
         value: Any,
+        /,
     ) -> Any:
         return value  # any is always valid
 
@@ -53,9 +107,11 @@ def _prepare_validator_of_any(
 def _prepare_validator_of_none(
     annotation: AttributeAnnotation,
     /,
-) -> Callable[[Any], Any]:
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
     def validator(
         value: Any,
+        /,
     ) -> Any:
         if value is None:
             return value
@@ -69,9 +125,11 @@ def _prepare_validator_of_none(
 def _prepare_validator_of_missing(
     annotation: AttributeAnnotation,
     /,
-) -> Callable[[Any], Any]:
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
     def validator(
         value: Any,
+        /,
     ) -> Any:
         if value is MISSING:
             return value
@@ -85,12 +143,14 @@ def _prepare_validator_of_missing(
 def _prepare_validator_of_literal(
     annotation: AttributeAnnotation,
     /,
-) -> Callable[[Any], Any]:
-    elements: list[Any] = annotation.arguments
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    elements: Sequence[Any] = annotation.arguments
     formatted_type: str = str(annotation)
 
     def validator(
         value: Any,
+        /,
     ) -> Any:
         if value in elements:
             return value
@@ -104,12 +164,14 @@ def _prepare_validator_of_literal(
 def _prepare_validator_of_type(
     annotation: AttributeAnnotation,
     /,
-) -> Callable[[Any], Any]:
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
     validated_type: type[Any] = annotation.origin
     formatted_type: str = str(annotation)
 
-    def type_validator(
+    def validator(
         value: Any,
+        /,
     ) -> Any:
         match value:
             case value if isinstance(value, validated_type):
@@ -118,18 +180,23 @@ def _prepare_validator_of_type(
             case _:
                 raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
 
-    return type_validator
+    return validator
 
 
 def _prepare_validator_of_set(
     annotation: AttributeAnnotation,
     /,
-) -> Callable[[Any], Any]:
-    element_validator: Callable[[Any], Any] = attribute_validator(annotation.arguments[0])
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    element_validator: AttributeValidation[Any] = AttributeValidator.of(
+        annotation.arguments[0],
+        recursion_guard=recursion_guard,
+    )
     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]
@@ -143,12 +210,17 @@ def _prepare_validator_of_set(
 def _prepare_validator_of_sequence(
     annotation: AttributeAnnotation,
     /,
-) -> Callable[[Any], Any]:
-    element_validator: Callable[[Any], Any] = attribute_validator(annotation.arguments[0])
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    element_validator: AttributeValidation[Any] = AttributeValidator.of(
+        annotation.arguments[0],
+        recursion_guard=recursion_guard,
+    )
     formatted_type: str = str(annotation)
 
     def validator(
         value: Any,
+        /,
     ) -> Any:
         match value:
             case [*elements]:
@@ -163,19 +235,29 @@ def _prepare_validator_of_sequence(
 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])
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    key_validator: AttributeValidation[Any] = AttributeValidator.of(
+        annotation.arguments[0],
+        recursion_guard=recursion_guard,
+    )
+    value_validator: AttributeValidation[Any] = AttributeValidator.of(
+        annotation.arguments[1],
+        recursion_guard=recursion_guard,
+    )
     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.items()}
-                )
+                # TODO: make sure dict is not mutable with MappingProxyType?
+                return {
+                    key_validator(key): value_validator(element)
+                    for key, element in elements.items()
+                }
 
             case _:
                 raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
@@ -186,13 +268,21 @@ def _prepare_validator_of_mapping(
 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])
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    if (
+        annotation.arguments[-1].origin == Ellipsis
+        or annotation.arguments[-1].origin == EllipsisType
+    ):
+        element_validator: AttributeValidation[Any] = AttributeValidator.of(
+            annotation.arguments[0],
+            recursion_guard=recursion_guard,
+        )
         formatted_type: str = str(annotation)
 
         def validator(
             value: Any,
+            /,
         ) -> Any:
             match value:
                 case [*elements]:
@@ -206,14 +296,16 @@ def _prepare_validator_of_tuple(
         return validator
 
     else:
-        element_validators: list[Callable[[Any], Any]] = [
-            attribute_validator(alternative) for alternative in annotation.arguments
+        element_validators: list[AttributeValidation[Any]] = [
+            AttributeValidator.of(alternative, recursion_guard=recursion_guard)
+            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]:
@@ -223,7 +315,7 @@ def _prepare_validator_of_tuple(
                         )
 
                     return tuple(
-                        element_validators[idx](value) for idx, value in enumerate(elements)
+                        element_validators[idx](element) for idx, element in enumerate(elements)
                     )
 
                 case _:
@@ -237,14 +329,17 @@ def _prepare_validator_of_tuple(
 def _prepare_validator_of_union(
     annotation: AttributeAnnotation,
     /,
-) -> Callable[[Any], Any]:
-    validators: list[Callable[[Any], Any]] = [
-        attribute_validator(alternative) for alternative in annotation.arguments
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    validators: list[AttributeValidation[Any]] = [
+        AttributeValidator.of(alternative, recursion_guard=recursion_guard)
+        for alternative in annotation.arguments
     ]
     formatted_type: str = str(annotation)
 
     def validator(
         value: Any,
+        /,
     ) -> Any:
         errors: list[Exception] = []
         for validator in validators:
@@ -265,13 +360,16 @@ def _prepare_validator_of_union(
 def _prepare_validator_of_callable(
     annotation: AttributeAnnotation,
     /,
-) -> Callable[[Any], Any]:
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
     formatted_type: str = str(annotation)
 
     def validator(
         value: Any,
+        /,
     ) -> Any:
         if callable(value):
+            # TODO: we could verify callable signature here
             return value
 
         else:
@@ -280,7 +378,59 @@ def _prepare_validator_of_callable(
     return validator
 
 
-VALIDATORS: Mapping[Any, Callable[[AttributeAnnotation], Callable[[Any], Any]]] = {
+def _prepare_validator_of_typed_dict(
+    annotation: AttributeAnnotation,
+    /,
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    def key_validator(
+        value: Any,
+        /,
+    ) -> Any:
+        match value:
+            case value if isinstance(value, str):
+                return value
+
+            case _:
+                raise TypeError(f"'{value}' is not matching expected type of 'str'")
+
+    values_validators: dict[str, AttributeValidation[Any]] = {
+        key: AttributeValidator.of(element, recursion_guard=recursion_guard)
+        for key, element in annotation.extra.items()
+    }
+    formatted_type: str = str(annotation)
+
+    def validator(
+        value: Any,
+        /,
+    ) -> Any:
+        match value:
+            case {**elements}:
+                validated: MutableMapping[str, Any] = {}
+                for key, validator in values_validators.items():
+                    element: Any = elements.get(key, MISSING)
+                    if element is not MISSING:
+                        validated[key_validator(key)] = validator(element)
+
+                # TODO: make sure dict is not mutable with MappingProxyType?
+                return validated
+
+            case _:
+                raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+
+    return validator
+
+
+VALIDATORS: Mapping[
+    Any,
+    Callable[
+        [
+            AttributeAnnotation,
+            MutableMapping[str, AttributeValidation[Any]],
+        ],
+        AttributeValidation[Any],
+    ],
+] = {
     Any: _prepare_validator_of_any,
     NoneType: _prepare_validator_of_none,
     Missing: _prepare_validator_of_missing,

{haiway-0.6.4.dist-info → haiway-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: haiway
-Version: 0.6.4
+Version: 0.7.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.6.4.dist-info → haiway-0.7.1.dist-info}/RECORD

@@ -15,11 +15,11 @@ haiway/helpers/throttling.py,sha256=zo0OwFq64si5KUwhd58cFHLmGAmYwRbFRJMbv9suhPs,
 haiway/helpers/timeouted.py,sha256=1xU09hQnFdj6p48BwZl5xUvtIr3zC0ZUXehkdrduCjs,3074
 haiway/helpers/tracing.py,sha256=eQpkIoGSB51jRF8RcLaihvHX3VzJIRdyRxTx3I14Pzg,3346
 haiway/state/__init__.py,sha256=emTuwGFn7HyjyTJ_ass69J5jQIA7_WHO4teZz_dR05Y,355
-haiway/state/attributes.py,sha256=OVUHp0_OwDwqJa-4Rk_diQhIpBYg0PW9APU3p_UTjd0,13635
+haiway/state/attributes.py,sha256=iQ7TJHnT3hlcYwKcxchXE56zU8WbOTJZhsVn_HocXBc,22903
 haiway/state/path.py,sha256=4vh-fYQv8_xRWjS0ErMQslKDWRI6-KVECAr8JhYk0UY,17503
 haiway/state/requirement.py,sha256=3iQqzp5Q7w6y5uClamJGH7S5Hib9pciuTAV27PP5lS8,6161
-haiway/state/structure.py,sha256=_1K_RSqA20ufcMay6i2CthMkgJeF1gZi7Hr4rUiCJs0,7869
-haiway/state/validation.py,sha256=l3NHHYVEr1M9F3HrV4hXA1gCibp7Uj5_nZWXMuy2tsU,9089
+haiway/state/structure.py,sha256=dqLXUJPnaQqdRxbNwtGgUqGNCA8EDPj16M3Ob_sEz5U,11837
+haiway/state/validation.py,sha256=n5cHcJTbv3Zf-qs05yzuLJIMBReV_4yYVwcH6IL58N0,13836
 haiway/types/__init__.py,sha256=00Ulp2BxcIWm9vWXKQPodpFEwE8hpqj6OYgrNxelp5s,252
 haiway/types/frozen.py,sha256=CZhFCXnWAKEhuWSfILxA8smfdpMd5Ku694ycfLh98R8,76
 haiway/types/missing.py,sha256=JiXo5xdi7H-PbIJr0fuK5wpOuQZhjrDYUkMlfIFcsaE,1705
@@ -31,8 +31,8 @@ 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.6.4.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
-haiway-0.6.4.dist-info/METADATA,sha256=Vx_AwXB2HZvP8BIN3EdA9l4gk7YdeILRy72qZ3yPgf8,3898
-haiway-0.6.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-haiway-0.6.4.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
-haiway-0.6.4.dist-info/RECORD,,
+haiway-0.7.1.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
+haiway-0.7.1.dist-info/METADATA,sha256=XacjUXNqPQaTSoCxEcqcOcGgjAGr6uxBguhLwrEaIMM,3898
+haiway-0.7.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+haiway-0.7.1.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
+haiway-0.7.1.dist-info/RECORD,,