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

haiway/__init__.py

@@ -17,7 +17,7 @@ from haiway.helpers import (
     traced,
     wrap_async,
 )
-from haiway.state import State
+from haiway.state import AttributePath, AttributeRequirement, State
 from haiway.types import (
     MISSING,
     Missing,
@@ -46,6 +46,8 @@ __all__ = [
     "MISSING",
     "ArgumentsTrace",
     "AsyncQueue",
+    "AttributePath",
+    "AttributeRequirement",
     "Disposable",
     "Disposables",
     "Missing",

haiway/state/__init__.py

@@ -1,8 +1,12 @@
 from haiway.state.attributes import AttributeAnnotation, attribute_annotations
+from haiway.state.path import AttributePath
+from haiway.state.requirement import AttributeRequirement
 from haiway.state.structure import State
 
 __all__ = [
     "AttributeAnnotation",
+    "AttributePath",
+    "AttributeRequirement",
     "State",
     "attribute_annotations",
 ]

haiway/state/attributes.py

@@ -19,6 +19,7 @@ from typing import (
 __all__ = [
     "AttributeAnnotation",
     "attribute_annotations",
+    "resolve_attribute_annotation",
 ]
 
 
@@ -68,7 +69,7 @@ def attribute_annotations(
         if ((get_origin(annotation) or annotation) is ClassVar) or key.startswith("_"):
             continue
 
-        attributes[key] = _resolve_attribute_annotation(
+        attributes[key] = resolve_attribute_annotation(
             annotation,
             self_annotation=self_annotation,
             type_parameters=type_parameters,
@@ -80,7 +81,7 @@ def attribute_annotations(
     return attributes
 
 
-def _resolve_attribute_annotation(  # noqa: C901, PLR0911, PLR0912, PLR0913
+def resolve_attribute_annotation(  # noqa: C901, PLR0911, PLR0912, PLR0913
     annotation: Any,
     /,
     self_annotation: AttributeAnnotation | None,
@@ -100,7 +101,7 @@ def _resolve_attribute_annotation(  # noqa: C901, PLR0911, PLR0912, PLR0913
 
         # forward reference through string
         case str() as forward_ref:
-            return _resolve_attribute_annotation(
+            return resolve_attribute_annotation(
                 ForwardRef(forward_ref, module=module)._evaluate(
                     globalns=None,
                     localns=localns,
@@ -115,7 +116,7 @@ def _resolve_attribute_annotation(  # noqa: C901, PLR0911, PLR0912, PLR0913
 
         # forward reference directly
         case typing.ForwardRef() as reference:
-            return _resolve_attribute_annotation(
+            return resolve_attribute_annotation(
                 reference._evaluate(
                     globalns=None,
                     localns=localns,
@@ -137,7 +138,7 @@ def _resolve_attribute_annotation(  # noqa: C901, PLR0911, PLR0912, PLR0913
                         origin=TypeAliasType,
                         arguments=[],
                     )
-                    resolved: AttributeAnnotation = _resolve_attribute_annotation(
+                    resolved: AttributeAnnotation = resolve_attribute_annotation(
                         alias.__value__,
                         self_annotation=None,
                         type_parameters=type_parameters,
@@ -169,7 +170,7 @@ def _resolve_attribute_annotation(  # noqa: C901, PLR0911, PLR0912, PLR0913
                             return AttributeAnnotation(
                                 origin=parametrized,
                                 arguments=[
-                                    _resolve_attribute_annotation(
+                                    resolve_attribute_annotation(
                                         argument,
                                         self_annotation=self_annotation,
                                         type_parameters=type_parameters,
@@ -193,7 +194,7 @@ def _resolve_attribute_annotation(  # noqa: C901, PLR0911, PLR0912, PLR0913
                     return AttributeAnnotation(
                         origin=origin,
                         arguments=[
-                            _resolve_attribute_annotation(
+                            resolve_attribute_annotation(
                                 argument,
                                 self_annotation=self_annotation,
                                 type_parameters=type_parameters,
@@ -211,7 +212,7 @@ def _resolve_attribute_annotation(  # noqa: C901, PLR0911, PLR0912, PLR0913
                 origin=TypeAliasType,
                 arguments=[],
             )
-            resolved: AttributeAnnotation = _resolve_attribute_annotation(
+            resolved: AttributeAnnotation = resolve_attribute_annotation(
                 alias.__value__,
                 self_annotation=None,
                 type_parameters=type_parameters,
@@ -225,7 +226,7 @@ def _resolve_attribute_annotation(  # noqa: C901, PLR0911, PLR0912, PLR0913
 
         # type parameter
         case typing.TypeVar():
-            return _resolve_attribute_annotation(
+            return resolve_attribute_annotation(
                 # try to resolve it from current parameters if able
                 type_parameters.get(
                     annotation.__name__,
@@ -270,7 +271,7 @@ def _resolve_attribute_annotation(  # noqa: C901, PLR0911, PLR0912, PLR0913
                 arguments=[
                     recursion_guard.get(
                         argument,
-                        _resolve_attribute_annotation(
+                        resolve_attribute_annotation(
                             argument,
                             self_annotation=self_annotation,
                             type_parameters=type_parameters,
@@ -287,7 +288,7 @@ def _resolve_attribute_annotation(  # noqa: C901, PLR0911, PLR0912, PLR0913
             return AttributeAnnotation(
                 origin=typing.Callable,
                 arguments=[
-                    _resolve_attribute_annotation(
+                    resolve_attribute_annotation(
                         argument,
                         self_annotation=self_annotation,
                         type_parameters=type_parameters,
@@ -314,7 +315,7 @@ def _resolve_attribute_annotation(  # noqa: C901, PLR0911, PLR0912, PLR0913
 
         # unwrap from irrelevant type wrappers
         case typing.Annotated | typing.Final | typing.Required | typing.NotRequired:
-            return _resolve_attribute_annotation(
+            return resolve_attribute_annotation(
                 get_args(annotation)[0],
                 self_annotation=self_annotation,
                 type_parameters=type_parameters,
@@ -327,7 +328,7 @@ def _resolve_attribute_annotation(  # noqa: C901, PLR0911, PLR0912, PLR0913
             return AttributeAnnotation(
                 origin=UnionType,  # pyright: ignore[reportArgumentType]
                 arguments=[
-                    _resolve_attribute_annotation(
+                    resolve_attribute_annotation(
                         get_args(annotation)[0],
                         self_annotation=self_annotation,
                         type_parameters=type_parameters,
@@ -352,7 +353,7 @@ def _resolve_attribute_annotation(  # noqa: C901, PLR0911, PLR0912, PLR0913
             return AttributeAnnotation(
                 origin=other,
                 arguments=[
-                    _resolve_attribute_annotation(
+                    resolve_attribute_annotation(
                         argument,
                         self_annotation=self_annotation,
                         type_parameters=type_parameters,

haiway/state/path.py

@@ -0,0 +1,524 @@
+import builtins
+import types
+import typing
+from abc import ABC, abstractmethod
+from collections import abc as collections_abc
+from collections import deque
+from collections.abc import Callable, Mapping, Sequence
+from copy import copy
+from typing import Any, final, get_args, get_origin, overload
+
+from haiway.types import MISSING, Missing, not_missing
+
+__all__ = [
+    "AttributePath",
+]
+
+
+class AttributePathComponent(ABC):
+    @abstractmethod
+    def path_str(
+        self,
+        current: str | None = None,
+        /,
+    ) -> str: ...
+
+    @abstractmethod
+    def access(
+        self,
+        subject: Any,
+        /,
+    ) -> Any: ...
+
+    @abstractmethod
+    def assigning(
+        self,
+        subject: Any,
+        /,
+        value: Any,
+    ) -> Any: ...
+
+
+@final
+class PropertyAttributePathComponent(AttributePathComponent):
+    def __init__[Root, Attribute](
+        self,
+        root: type[Root],
+        *,
+        attribute: type[Attribute],
+        name: str,
+    ) -> None:
+        root_origin: Any = get_origin(root) or root
+        attribute_origin: Any = get_origin(attribute) or attribute
+
+        def access(
+            subject: Root,
+            /,
+        ) -> Attribute:
+            assert isinstance(subject, root_origin), (  # nosec: B101
+                f"AttributePath used on unexpected subject of"
+                f" '{type(subject).__name__}' instead of '{root.__name__}' for '{name}'"
+            )
+
+            assert hasattr(subject, name), (  # nosec: B101
+                f"AttributePath pointing to attribute '{name}'"
+                f" which is not available in subject '{type(subject).__name__}'"
+            )
+
+            resolved: Any = getattr(subject, name)
+
+            assert isinstance(resolved, attribute_origin), (  # nosec: B101
+                f"AttributePath pointing to unexpected value of"
+                f" '{type(resolved).__name__}' instead of '{attribute.__name__}' for '{name}'"
+            )
+            return resolved
+
+        def assigning(
+            subject: Root,
+            /,
+            value: Attribute,
+        ) -> Root:
+            assert isinstance(subject, root_origin), (  # nosec: B101
+                f"AttributePath used on unexpected subject of"
+                f" '{type(subject).__name__}' instead of '{root.__name__}' for '{name}'"
+            )
+
+            assert hasattr(subject, name), (  # nosec: B101
+                f"AttributePath pointing to attribute '{name}'"
+                f" which is not available in subject '{type(subject).__name__}'"
+            )
+
+            assert isinstance(value, attribute_origin), (  # nosec: B101
+                f"AttributePath assigning unexpected value of "
+                f"'{type(value).__name__}' instead of '{attribute.__name__}' for '{name}'"
+            )
+
+            updated: Root
+            # python 3.13 introduces __replace__, we are already implementing it for our types
+            if hasattr(subject, "__replace__"):  # can't check full type here
+                updated = subject.__replace__(**{name: value})  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType, reportAttributeAccessIssue]
+
+            else:
+                updated = copy(subject)
+                setattr(updated, name, value)
+
+            return updated  # pyright: ignore[reportUnknownVariableType]
+
+        self._access: Callable[[Any], Any] = access
+        self._assigning: Callable[[Any, Any], Any] = assigning
+        self._name: str = name
+
+    def path_str(
+        self,
+        current: str | None = None,
+        /,
+    ) -> str:
+        if current:
+            return f"{current}.{self._name}"
+
+        else:
+            return self._name
+
+    def access(
+        self,
+        subject: Any,
+        /,
+    ) -> Any:
+        return self._access(subject)
+
+    def assigning(
+        self,
+        subject: Any,
+        /,
+        value: Any,
+    ) -> Any:
+        return self._assigning(subject, value)
+
+
+@final
+class SequenceItemAttributePathComponent(AttributePathComponent):
+    def __init__[Root: Sequence[Any], Attribute](
+        self,
+        root: type[Root],
+        *,
+        attribute: type[Attribute],
+        index: int,
+    ) -> None:
+        root_origin: Any = get_origin(root) or root
+        attribute_origin: Any = get_origin(attribute) or attribute
+
+        def access(
+            subject: Root,
+            /,
+        ) -> Attribute:
+            assert isinstance(subject, root_origin), (  # nosec: B101
+                f"AttributePathComponent used on unexpected root of "
+                f"'{type(root).__name__}' instead of '{root.__name__}' for '{index}'"
+            )
+
+            resolved: Any = subject.__getitem__(index)  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+
+            assert isinstance(resolved, attribute_origin), (  # nosec: B101
+                f"AttributePath pointing to unexpected value of "
+                f"'{type(resolved).__name__}' instead of '{attribute.__name__}' for '{index}'"
+            )
+            return resolved
+
+        def assigning(
+            subject: Root,
+            /,
+            value: Attribute,
+        ) -> Root:
+            assert isinstance(subject, root_origin), (  # nosec: B101
+                f"AttributePath used on unexpected root of "
+                f"'{type(subject).__name__}' instead of '{root.__name__}' for '{index}'"
+            )
+            assert isinstance(value, attribute_origin), (  # nosec: B101
+                f"AttributePath assigning to unexpected value of "
+                f"'{type(value).__name__}' instead of '{attribute.__name__}' for '{index}'"
+            )
+
+            temp_list: list[Any] = list(subject)  # pyright: ignore[reportUnknownArgumentType]
+            temp_list[index] = value
+            return subject.__class__(temp_list)  # pyright: ignore[reportCallIssue, reportUnknownVariableType, reportUnknownMemberType]
+
+        self._access: Callable[[Any], Any] = access
+        self._assigning: Callable[[Any, Any], Any] = assigning
+        self._index: Any = index
+
+    def path_str(
+        self,
+        current: str | None = None,
+        /,
+    ) -> str:
+        return f"{current or ''}[{self._index}]"
+
+    def access(
+        self,
+        subject: Any,
+        /,
+    ) -> Any:
+        return self._access(subject)
+
+    def assigning(
+        self,
+        subject: Any,
+        /,
+        value: Any,
+    ) -> Any:
+        return self._assigning(subject, value)
+
+
+@final
+class MappingItemAttributePathComponent(AttributePathComponent):
+    def __init__[Root: Mapping[Any, Any], Attribute](
+        self,
+        root: type[Root],
+        *,
+        attribute: type[Attribute],
+        key: str | int,
+    ) -> None:
+        root_origin: Any = get_origin(root) or root
+        attribute_origin: Any = get_origin(attribute) or attribute
+
+        def access(
+            subject: Root,
+            /,
+        ) -> Attribute:
+            assert isinstance(subject, root_origin), (  # nosec: B101
+                f"AttributePathComponent used on unexpected root of "
+                f"'{type(root).__name__}' instead of '{root.__name__}' for '{key}'"
+            )
+
+            resolved: Any = subject.__getitem__(key)  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+
+            assert isinstance(resolved, attribute_origin), (  # nosec: B101
+                f"AttributePath pointing to unexpected value of "
+                f"'{type(resolved).__name__}' instead of '{attribute.__name__}' for '{key}'"
+            )
+            return resolved
+
+        def assigning(
+            subject: Root,
+            /,
+            value: Attribute,
+        ) -> Root:
+            assert isinstance(subject, root_origin), (  # nosec: B101
+                f"AttributePath used on unexpected root of "
+                f"'{type(subject).__name__}' instead of '{root.__name__}' for '{key}'"
+            )
+            assert isinstance(value, attribute_origin), (  # nosec: B101
+                f"AttributePath assigning to unexpected value of "
+                f"'{type(value).__name__}' instead of '{attribute.__name__}' for '{key}'"
+            )
+
+            temp_dict: dict[Any, Any] = dict(subject)  # pyright: ignore[reportUnknownArgumentType]
+            temp_dict[key] = value
+            return subject.__class__(temp_dict)  # pyright: ignore[reportCallIssue, reportUnknownVariableType, reportUnknownMemberType]
+
+        self._access: Callable[[Any], Any] = access
+        self._assigning: Callable[[Any, Any], Any] = assigning
+        self._key: Any = key
+
+    def path_str(
+        self,
+        current: str | None = None,
+        /,
+    ) -> str:
+        return f"{current or ''}[{self._key}]"
+
+    def access(
+        self,
+        subject: Any,
+        /,
+    ) -> Any:
+        return self._access(subject)
+
+    def assigning(
+        self,
+        subject: Any,
+        /,
+        value: Any,
+    ) -> Any:
+        return self._assigning(subject, value)
+
+
+@final
+class AttributePath[Root, Attribute]:
+    @overload
+    def __init__(
+        self,
+        root: type[Root],
+        /,
+        *,
+        attribute: type[Root],
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        root: type[Root],
+        /,
+        *components: AttributePathComponent,
+        attribute: type[Attribute],
+    ) -> None: ...
+
+    def __init__(
+        self,
+        root: type[Root],
+        /,
+        *components: AttributePathComponent,
+        attribute: type[Attribute],
+    ) -> None:
+        assert components or root == attribute  # nosec: B101
+        self.__root__: type[Root] = root
+        self.__attribute__: type[Attribute] = attribute
+        self.__components__: tuple[AttributePathComponent, ...] = components
+
+    @property
+    def components(self) -> Sequence[str]:
+        return tuple(component.path_str() for component in self.__components__)
+
+    def __str__(self) -> str:
+        path: str = ""
+        for component in self.__components__:
+            path = component.path_str(path)
+
+        return path
+
+    def __repr__(self) -> str:
+        path: str = self.__root__.__name__
+        for component in self.__components__:
+            path = component.path_str(path)
+
+        return path
+
+    def __getattr__(
+        self,
+        name: str,
+    ) -> Any:
+        try:
+            return object.__getattribute__(self, name)
+
+        except (AttributeError, KeyError):
+            pass  # continue
+
+        assert not name.startswith(  # nosec: B101
+            "_"
+        ), f"Accessing private/special attribute paths ({name}) is forbidden"
+
+        try:
+            annotation: Any = self.__attribute__.__annotations__[name]
+
+        except Exception as exc:
+            raise AttributeError(
+                f"Failed to prepare AttributePath caused by inaccessible"
+                f" type annotation for '{name}' within '{self.__attribute__.__name__}'"
+            ) from exc
+
+        return AttributePath[Root, Any](
+            self.__root__,
+            *(
+                *self.__components__,
+                PropertyAttributePathComponent(
+                    root=self.__attribute__,
+                    attribute=annotation,
+                    name=name,
+                ),
+            ),
+            attribute=annotation,
+        )
+
+    def __getitem__(
+        self,
+        key: str | int,
+    ) -> Any:
+        match get_origin(self.__attribute__) or self.__attribute__:
+            case collections_abc.Mapping | typing.Mapping | builtins.dict:
+                match get_args(self.__attribute__):
+                    case (builtins.str | builtins.int, element_annotation):
+                        return AttributePath[Root, Any](
+                            self.__root__,
+                            *(
+                                *self.__components__,
+                                MappingItemAttributePathComponent(
+                                    root=self.__attribute__,  # pyright: ignore[reportArgumentType]
+                                    attribute=element_annotation,
+                                    key=key,
+                                ),
+                            ),
+                            attribute=element_annotation,
+                        )
+
+                    case other:
+                        raise TypeError(
+                            "Unsupported Mapping type annotation",
+                            self.__attribute__.__name__,
+                        )
+
+            case builtins.tuple:
+                if not isinstance(key, int):
+                    raise TypeError(
+                        "Unsupported tuple type annotation",
+                        self.__attribute__.__name__,
+                    )
+
+                match get_args(self.__attribute__):
+                    case (element_annotation, builtins.Ellipsis | types.EllipsisType):
+                        return AttributePath[Root, Any](
+                            self.__root__,
+                            *(
+                                *self.__components__,
+                                SequenceItemAttributePathComponent(
+                                    root=self.__attribute__,  # pyright: ignore[reportArgumentType]
+                                    attribute=element_annotation,
+                                    index=key,
+                                ),
+                            ),
+                            attribute=element_annotation,
+                        )
+
+                    case other:
+                        return AttributePath[Root, Any](
+                            self.__root__,
+                            *(
+                                *self.__components__,
+                                SequenceItemAttributePathComponent(
+                                    root=self.__attribute__,  # pyright: ignore[reportArgumentType]
+                                    attribute=other[key],
+                                    index=key,
+                                ),
+                            ),
+                            attribute=other[key],
+                        )
+
+            case collections_abc.Sequence | typing.Sequence | builtins.list:
+                if not isinstance(key, int):
+                    raise TypeError(
+                        "Unsupported Sequence type annotation",
+                        self.__attribute__.__name__,
+                    )
+
+                match get_args(self.__attribute__):
+                    case (element_annotation,):
+                        return AttributePath[Root, Any](
+                            self.__root__,
+                            *(
+                                *self.__components__,
+                                SequenceItemAttributePathComponent(
+                                    root=self.__attribute__,  # pyright: ignore[reportArgumentType]
+                                    attribute=element_annotation,
+                                    index=key,
+                                ),
+                            ),
+                            attribute=element_annotation,
+                        )
+
+                    case other:
+                        raise TypeError(
+                            "Unsupported Seqence type annotation",
+                            self.__attribute__.__name__,
+                        )
+
+            case other:
+                raise TypeError("Unsupported type annotation", other)
+
+    @overload
+    def __call__(
+        self,
+        root: Root,
+        /,
+    ) -> Attribute: ...
+
+    @overload
+    def __call__(
+        self,
+        root: Root,
+        /,
+        updated: Attribute,
+    ) -> Root: ...
+
+    def __call__(
+        self,
+        root: Root,
+        /,
+        updated: Attribute | Missing = MISSING,
+    ) -> Root | Attribute:
+        assert isinstance(root, get_origin(self.__root__) or self.__root__), (  # nosec: B101
+            f"AttributePath '{self.__repr__()}' used on unexpected root of "
+            f"'{type(root).__name__}' instead of '{self.__root__.__name__}'"
+        )
+
+        if not_missing(updated):
+            assert isinstance(updated, get_origin(self.__attribute__) or self.__attribute__), (  # nosec: B101
+                f"AttributePath '{self.__repr__()}' assigning to unexpected value of "
+                f"'{type(updated).__name__}' instead of '{self.__attribute__.__name__}'"
+            )
+
+            resolved: Any = root
+            updates_stack: deque[tuple[Any, AttributePathComponent]] = deque()
+            for component in self.__components__:
+                updates_stack.append((resolved, component))
+                resolved = component.access(resolved)
+
+            updated_value: Any = updated
+            while updates_stack:
+                subject, component = updates_stack.pop()
+                updated_value = component.assigning(
+                    subject,
+                    value=updated_value,
+                )
+
+            return updated_value
+
+        else:
+            resolved: Any = root
+            for component in self.__components__:
+                resolved = component.access(resolved)
+
+            assert isinstance(resolved, get_origin(self.__attribute__) or self.__attribute__), (  # nosec: B101
+                f"AttributePath '{self.__repr__()}' pointing to unexpected value of "
+                f"'{type(resolved).__name__}' instead of '{self.__attribute__.__name__}'"
+            )
+
+            return resolved

haiway/state/requirement.py

@@ -0,0 +1,229 @@
+from collections.abc import Callable, Collection, Iterable
+from typing import Any, Literal, Self, cast, final
+
+from haiway.state.path import AttributePath
+from haiway.utils import freeze
+
+__all__ = [
+    "AttributeRequirement",
+]
+
+
+@final
+class AttributeRequirement[Root]:
+    @classmethod
+    def equal[Parameter](
+        cls,
+        value: Parameter,
+        /,
+        path: AttributePath[Root, Parameter] | Parameter,
+    ) -> Self:
+        assert isinstance(  # nosec: B101
+            path, AttributePath
+        ), "Prepare attribute path by using Self._.path.to.property or explicitly"
+
+        def check_equal(root: Root) -> None:
+            checked: Any = cast(AttributePath[Root, Parameter], path)(root)
+            if checked != value:
+                raise ValueError(f"{checked} is not equal {value} for '{path.__repr__()}'")
+
+        return cls(
+            path,
+            "equal",
+            value,
+            check=check_equal,
+        )
+
+    @classmethod
+    def not_equal[Parameter](
+        cls,
+        value: Parameter,
+        /,
+        path: AttributePath[Root, Parameter] | Parameter,
+    ) -> Self:
+        assert isinstance(  # nosec: B101
+            path, AttributePath
+        ), "Prepare attribute path by using Self._.path.to.property or explicitly"
+
+        def check_not_equal(root: Root) -> None:
+            checked: Any = cast(AttributePath[Root, Parameter], path)(root)
+            if checked == value:
+                raise ValueError(f"{checked} is equal {value} for '{path.__repr__()}'")
+
+        return cls(
+            path,
+            "not_equal",
+            value,
+            check=check_not_equal,
+        )
+
+    @classmethod
+    def contains[Parameter](
+        cls,
+        value: Parameter,
+        /,
+        path: AttributePath[
+            Root,
+            Collection[Parameter] | tuple[Parameter, ...] | list[Parameter] | set[Parameter],
+        ]
+        | Collection[Parameter]
+        | tuple[Parameter, ...]
+        | list[Parameter]
+        | set[Parameter],
+    ) -> Self:
+        assert isinstance(  # nosec: B101
+            path, AttributePath
+        ), "Prepare attribute path by using Self._.path.to.property or explicitly"
+
+        def check_contains(root: Root) -> None:
+            checked: Any = cast(AttributePath[Root, Parameter], path)(root)
+            if value not in checked:
+                raise ValueError(f"{checked} does not contain {value} for '{path.__repr__()}'")
+
+        return cls(
+            path,
+            "contains",
+            value,
+            check=check_contains,
+        )
+
+    @classmethod
+    def contains_any[Parameter](
+        cls,
+        value: Collection[Parameter],
+        /,
+        path: AttributePath[
+            Root,
+            Collection[Parameter] | tuple[Parameter, ...] | list[Parameter] | set[Parameter],
+        ]
+        | Collection[Parameter]
+        | tuple[Parameter, ...]
+        | list[Parameter]
+        | set[Parameter],
+    ) -> Self:
+        assert isinstance(  # nosec: B101
+            path, AttributePath
+        ), "Prepare attribute path by using Self._.path.to.property or explicitly"
+
+        def check_contains_any(root: Root) -> None:
+            checked: Any = cast(AttributePath[Root, Parameter], path)(root)
+            if any(element in checked for element in value):
+                raise ValueError(
+                    f"{checked} does not contain any of {value} for '{path.__repr__()}'"
+                )
+
+        return cls(
+            path,
+            "contains_any",
+            value,
+            check=check_contains_any,
+        )
+
+    @classmethod
+    def contained_in[Parameter](
+        cls,
+        value: Collection[Parameter],
+        /,
+        path: AttributePath[Root, Parameter] | Parameter,
+    ) -> Self:
+        assert isinstance(  # nosec: B101
+            path, AttributePath
+        ), "Prepare attribute path by using Self._.path.to.property or explicitly"
+
+        def check_contained_in(root: Root) -> None:
+            checked: Any = cast(AttributePath[Root, Parameter], path)(root)
+            if checked not in value:
+                raise ValueError(f"{value} does not contain {checked} for '{path.__repr__()}'")
+
+        return cls(
+            value,
+            "contained_in",
+            path,
+            check=check_contained_in,
+        )
+
+    def __init__(
+        self,
+        lhs: Any,
+        operator: Literal[
+            "equal",
+            "not_equal",
+            "contains",
+            "contains_any",
+            "contained_in",
+            "and",
+            "or",
+        ],
+        rhs: Any,
+        check: Callable[[Root], None],
+    ) -> None:
+        self.lhs: Any = lhs
+        self.operator: Literal[
+            "equal",
+            "not_equal",
+            "contains",
+            "contains_any",
+            "contained_in",
+            "and",
+            "or",
+        ] = operator
+        self.rhs: Any = rhs
+        self._check: Callable[[Root], None] = check
+
+        freeze(self)
+
+    def __and__(
+        self,
+        other: Self,
+    ) -> Self:
+        def check_and(root: Root) -> None:
+            self.check(root)
+            other.check(root)
+
+        return self.__class__(
+            self,
+            "and",
+            other,
+            check=check_and,
+        )
+
+    def __or__(
+        self,
+        other: Self,
+    ) -> Self:
+        def check_or(root: Root) -> None:
+            try:
+                self.check(root)
+            except ValueError:
+                other.check(root)
+
+        return self.__class__(
+            self,
+            "or",
+            other,
+            check=check_or,
+        )
+
+    def check(
+        self,
+        root: Root,
+        /,
+        *,
+        raise_exception: bool = True,
+    ) -> bool:
+        try:
+            self._check(root)
+            return True
+
+        except Exception as exc:
+            if raise_exception:
+                raise exc
+
+            else:
+                return False
+
+    def filter(
+        self,
+        values: Iterable[Root],
+    ) -> list[Root]:
+        return [value for value in values if self.check(value, raise_exception=False)]

haiway/state/structure.py

@@ -15,6 +15,7 @@ from typing import (
 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.types import MISSING, Missing, not_missing
 
@@ -86,6 +87,7 @@ class StateMeta(type):
         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]
 
         return state_type
 
@@ -104,6 +106,7 @@ class State(metaclass=StateMeta):
     Base class for immutable data structures.
     """
 
+    _: ClassVar[Self]
     __IMMUTABLE__: ClassVar[EllipsisType] = ...
     __ATTRIBUTES__: ClassVar[dict[str, StateAttribute[Any]]]
 
@@ -178,6 +181,18 @@ class State(metaclass=StateMeta):
                 ),
             )
 
+    def updating[Value](
+        self,
+        path: AttributePath[Self, Value] | Value,
+        /,
+        value: Value,
+    ) -> Self:
+        assert isinstance(  # nosec: B101
+            path, AttributePath
+        ), "Prepare parameter path by using Self._.path.to.property or explicitly"
+
+        return cast(AttributePath[Self, Value], path)(self, updated=value)
+
     def updated(
         self,
         **kwargs: Any,

haiway/state/validation.py

@@ -5,6 +5,9 @@ from pathlib import Path
 from re import Pattern
 from types import MappingProxyType, NoneType, UnionType
 from typing import Any, Literal, Protocol, Union
+from typing import Mapping as MappingType  # noqa: UP035
+from typing import Sequence as SequenceType  # noqa: UP035
+from typing import Sequence as SetType  # noqa: UP035
 from uuid import UUID
 
 from haiway.state.attributes import AttributeAnnotation
@@ -128,7 +131,7 @@ def _prepare_validator_of_set(
     def validator(
         value: Any,
     ) -> Any:
-        if isinstance(value, Set):
+        if isinstance(value, set):
             return frozenset(element_validator(element) for element in value)  # pyright: ignore[reportUnknownVariableType]
 
         else:
@@ -171,7 +174,7 @@ def _prepare_validator_of_mapping(
         match value:
             case {**elements}:
                 return MappingProxyType(
-                    {key_validator(key): value_validator(value) for key, value in elements}
+                    {key_validator(key): value_validator(value) for key, value in elements.items()}
                 )
 
             case _:
@@ -291,9 +294,13 @@ VALIDATORS: Mapping[Any, Callable[[AttributeAnnotation], Callable[[Any], Any]]]
     tuple: _prepare_validator_of_tuple,
     frozenset: _prepare_validator_of_set,
     Literal: _prepare_validator_of_literal,
+    set: _prepare_validator_of_set,
     Set: _prepare_validator_of_set,
+    SetType: _prepare_validator_of_set,
     Sequence: _prepare_validator_of_sequence,
+    SequenceType: _prepare_validator_of_sequence,
     Mapping: _prepare_validator_of_mapping,
+    MappingType: _prepare_validator_of_mapping,
     range: _prepare_validator_of_type,
     UUID: _prepare_validator_of_type,
     date: _prepare_validator_of_type,

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

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

@@ -1,4 +1,4 @@
-haiway/__init__.py,sha256=QksN9EkQrmsYuOhkrKNYr-RMLDT7hixuplkLmJntIfc,1301
+haiway/__init__.py,sha256=GslXcxpiKSKmcWlsvj25X7uDZzuUDUUL8pxAKFqbvIs,1387
 haiway/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 haiway/context/__init__.py,sha256=ZgQoQFUqfPDqeIbhS898C3dP02QzOCRmClVQpHaPTBA,336
 haiway/context/access.py,sha256=CB-F9Yd6EAoJIqzMQGid9szww7aFiti5z6x0T79LV7k,14098
@@ -14,10 +14,12 @@ haiway/helpers/retries.py,sha256=gIkyUlqJLDYaxIZd3qzeqGFY9y5Gp8dgZLlZ6hs8hoc,753
 haiway/helpers/throttling.py,sha256=zo0OwFq64si5KUwhd58cFHLmGAmYwRbFRJMbv9suhPs,3844
 haiway/helpers/timeouted.py,sha256=1xU09hQnFdj6p48BwZl5xUvtIr3zC0ZUXehkdrduCjs,3074
 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=dC4m3a8HfC7c3slBpFbyYfIRnzl0QrmUSUb6MokAajY,8737
+haiway/state/__init__.py,sha256=emTuwGFn7HyjyTJ_ass69J5jQIA7_WHO4teZz_dR05Y,355
+haiway/state/attributes.py,sha256=OVUHp0_OwDwqJa-4Rk_diQhIpBYg0PW9APU3p_UTjd0,13635
+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/types/__init__.py,sha256=00Ulp2BxcIWm9vWXKQPodpFEwE8hpqj6OYgrNxelp5s,252
 haiway/types/frozen.py,sha256=CZhFCXnWAKEhuWSfILxA8smfdpMd5Ku694ycfLh98R8,76
 haiway/types/missing.py,sha256=JiXo5xdi7H-PbIJr0fuK5wpOuQZhjrDYUkMlfIFcsaE,1705
@@ -29,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.2.dist-info/LICENSE,sha256=GehQEW_I1pkmxkkj3NEa7rCTQKYBn7vTPabpDYJlRuo,1063
-haiway-0.6.2.dist-info/METADATA,sha256=pHxz4V97cT3so3DTs5fNhVrKjP7L2_63UsPX6GK7aSk,3898
-haiway-0.6.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-haiway-0.6.2.dist-info/top_level.txt,sha256=_LdXVLzUzgkvAGQnQJj5kQfoFhpPW6EF4Kj9NapniLg,7
-haiway-0.6.2.dist-info/RECORD,,
+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,,