haiway 0.24.3__py3-none-any.whl → 0.25.1__py3-none-any.whl

haiway/state/immutable.py

@@ -0,0 +1,127 @@
+import inspect
+from types import EllipsisType
+from typing import Any, ClassVar, Self, dataclass_transform, final, get_origin, get_type_hints
+
+from haiway.types.default import DefaultValue
+
+__all__ = ("Immutable",)
+
+
+@dataclass_transform(
+    kw_only_default=True,
+    frozen_default=True,
+    field_specifiers=(),
+)
+class ImmutableMeta(type):
+    def __new__(
+        mcs,
+        name: str,
+        bases: tuple[type, ...],
+        namespace: dict[str, Any],
+        **kwargs: Any,
+    ) -> type:
+        state_type = type.__new__(
+            mcs,
+            name,
+            bases,
+            namespace,
+            **kwargs,
+        )
+
+        state_type.__ATTRIBUTES__ = _collect_attributes(state_type)  # pyright: ignore[reportAttributeAccessIssue]
+        state_type.__slots__ = tuple(state_type.__ATTRIBUTES__.keys())  # pyright: ignore[reportAttributeAccessIssue]
+        state_type.__match_args__ = state_type.__slots__  # pyright: ignore[reportAttributeAccessIssue]
+
+        # Only mark subclasses as final (not the base Immutable class itself)
+        if name != "Immutable":
+            state_type = final(state_type)
+
+        return state_type
+
+
+def _collect_attributes(
+    cls: type[Any],
+) -> dict[str, DefaultValue[Any] | None]:
+    attributes: dict[str, DefaultValue[Any] | None] = {}
+    for key, annotation in get_type_hints(cls, localns={cls.__name__: cls}).items():
+        # do not include ClassVars
+        if (get_origin(annotation) or annotation) is ClassVar:
+            continue
+
+        field_value: Any = getattr(cls, key, inspect.Parameter.empty)
+
+        # Create a Field instance with the default value
+        if field_value is inspect.Parameter.empty:
+            attributes[key] = None
+
+        elif isinstance(field_value, DefaultValue):
+            attributes[key] = field_value
+
+        else:
+            attributes[key] = DefaultValue(field_value)
+
+    return attributes
+
+
+class Immutable(metaclass=ImmutableMeta):
+    __IMMUTABLE__: ClassVar[EllipsisType] = ...
+    __ATTRIBUTES__: ClassVar[dict[str, DefaultValue | None]]
+
+    def __init__(
+        self,
+        **kwargs: Any,
+    ) -> None:
+        for name, default in self.__ATTRIBUTES__.items():
+            if name in kwargs:
+                object.__setattr__(
+                    self,
+                    name,
+                    kwargs[name],
+                )
+
+            elif default is not None:
+                object.__setattr__(
+                    self,
+                    name,
+                    default(),
+                )
+
+            else:
+                raise AttributeError(
+                    f"Missing required attribute: {name}@{self.__class__.__qualname__}"
+                )
+
+    def __setattr__(
+        self,
+        name: str,
+        value: Any,
+    ) -> Any:
+        raise AttributeError(
+            f"Can't modify immutable {self.__class__.__qualname__},"
+            f" attribute - '{name}' cannot be modified"
+        )
+
+    def __delattr__(
+        self,
+        name: str,
+    ) -> None:
+        raise AttributeError(
+            f"Can't modify immutable {self.__class__.__qualname__},"
+            f" attribute - '{name}' cannot be deleted"
+        )
+
+    def __str__(self) -> str:
+        attributes: str = ", ".join([f"{key}: {value}" for key, value in vars(self).items()])
+        return f"{self.__class__.__name__}({attributes})"
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __copy__(self) -> Self:
+        return self  # Immutable, no need to provide an actual copy
+
+    def __deepcopy__(
+        self,
+        memo: dict[int, Any] | None,
+    ) -> Self:
+        return self  # Immutable, no need to provide an actual copy

haiway/state/structure.py

@@ -1,4 +1,3 @@
-import typing
 from collections.abc import Mapping
 from types import EllipsisType, GenericAlias
 from typing import (
@@ -131,7 +130,7 @@ class StateAttribute[Value]:
 @dataclass_transform(
     kw_only_default=True,
     frozen_default=True,
-    field_specifiers=(DefaultValue,),
+    field_specifiers=(),
 )
 class StateMeta(type):
     """
@@ -150,7 +149,7 @@ class StateMeta(type):
     """
 
     def __new__(
-        cls,
+        mcs,
         /,
         name: str,
         bases: tuple[type, ...],
@@ -158,29 +157,8 @@ class StateMeta(type):
         type_parameters: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> Any:
-        """
-        Create a new State class with processed attributes and validation.
-
-        Parameters
-        ----------
-        name : str
-            The name of the new class
-        bases : tuple[type, ...]
-            The base classes
-        namespace : dict[str, Any]
-            The class namespace (attributes and methods)
-        type_parameters : dict[str, Any] | None
-            Type parameters for generic specialization
-        **kwargs : Any
-            Additional arguments for class creation
-
-        Returns
-        -------
-        Any
-            The new class object
-        """
-        state_type = type.__new__(
-            cls,
+        cls = type.__new__(
+            mcs,
             name,
             bases,
             namespace,
@@ -190,29 +168,27 @@ class StateMeta(type):
         attributes: dict[str, StateAttribute[Any]] = {}
 
         for key, annotation in attribute_annotations(
-            state_type,
+            cls,
             type_parameters=type_parameters or {},
         ).items():
-            default: Any = getattr(state_type, key, MISSING)
+            default: Any = getattr(cls, key, MISSING)
             attributes[key] = StateAttribute(
                 name=key,
                 annotation=annotation.update_required(default is MISSING),
                 default=_resolve_default(default),
                 validator=AttributeValidator.of(
                     annotation,
-                    recursion_guard={
-                        str(AttributeAnnotation(origin=state_type)): state_type.validator
-                    },
+                    recursion_guard={str(AttributeAnnotation(origin=cls)): cls.validator},
                 ),
             )
 
-        state_type.__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[reportCallIssue, reportUnknownMemberType, reportAttributeAccessIssue]
+        cls.__TYPE_PARAMETERS__ = type_parameters  # pyright: ignore[reportAttributeAccessIssue]
+        cls.__ATTRIBUTES__ = attributes  # pyright: ignore[reportAttributeAccessIssue]
+        cls.__slots__ = frozenset(attributes.keys())  # pyright: ignore[reportAttributeAccessIssue]
+        cls.__match_args__ = cls.__slots__  # pyright: ignore[reportAttributeAccessIssue]
+        cls._ = AttributePath(cls, attribute=cls)  # pyright: ignore[reportCallIssue, reportUnknownMemberType, reportAttributeAccessIssue]
 
-        return state_type
+        return cls
 
     def validator(
         cls,
@@ -241,24 +217,8 @@ class StateMeta(type):
         self,
         instance: Any,
     ) -> bool:
-        """
-        Check if an instance is an instance of this class.
-
-        Implements isinstance() behavior for State classes, with special handling
-        for generic type parameters and validation.
-
-        Parameters
-        ----------
-        instance : Any
-            The instance to check
-
-        Returns
-        -------
-        bool
-            True if the instance is an instance of this class, False otherwise
-        """
         # check for type match
-        if self.__subclasscheck__(type(instance)):  # pyright: ignore[reportUnknownArgumentType]
+        if self.__subclasscheck__(type(instance)):
             return True
 
         # otherwise check if we are dealing with unparametrized base
@@ -276,85 +236,69 @@ class StateMeta(type):
         else:
             return True
 
-    def __subclasscheck__(  # noqa: C901, PLR0911, PLR0912
+    def __subclasscheck__(
         self,
         subclass: type[Any],
     ) -> bool:
-        """
-        Check if a class is a subclass of this class.
-
-        Implements issubclass() behavior for State classes, with special handling
-        for generic type parameters.
+        if self is subclass:
+            return True
 
-        Parameters
-        ----------
-        subclass : type[Any]
-            The class to check
+        self_origin: type[Any] = getattr(self, "__origin__", self)
+        subclass_origin: type[Any] = getattr(subclass, "__origin__", subclass)
 
-        Returns
-        -------
-        bool
-            True if the class is a subclass of this class, False otherwise
+        # Handle case where we're checking a parameterized type against unparameterized
+        if self_origin is self:
+            return type.__subclasscheck__(self, subclass)
 
-        Raises
-        ------
-        RuntimeError
-            If there is an issue with type parametrization
-        """
-        # check if we are the same class for early exit
-        if self == subclass:
-            return True
+        # Both must be based on the same generic class
+        if not issubclass(subclass_origin, self_origin):
+            return False
 
-        # then check if we are parametrized
-        checked_parameters: Mapping[str, Any] | None = getattr(
-            self,
-            "__TYPE_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,
-                "__TYPE_PARAMETERS__",
-                None,
-            )
+        return self._check_type_parameters(subclass)
 
-            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)
+    def _check_type_parameters(
+        self,
+        subclass: type[Any],
+    ) -> bool:
+        self_params: Mapping[str, Any] | None = getattr(self, "__TYPE_PARAMETERS__", None)
+        subclass_params: Mapping[str, Any] | None = getattr(subclass, "__TYPE_PARAMETERS__", None)
 
-            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
+        if self_params is None:
+            return True
 
-                    case typing.Any:
-                        continue  # Any ignores type checks
+        # If subclass doesn't have type parameters, look in the MRO for a parametrized base
+        if subclass_params is None:
+            subclass_params = self._find_parametrized_base(subclass)
+            if subclass_params is None:
+                return False
 
-                    case checked:
-                        if param is Any:
-                            continue  # Any ignores type checks
+        # Check if the type parameters are compatible (covariant)
+        for key, self_param in self_params.items():
+            subclass_param: type[Any] = subclass_params.get(key, Any)
+            if self_param is Any:
+                continue
 
-                        elif issubclass(checked, param):
-                            continue  # if we have matching type we are fine
+            # For covariance: GenericState[Child] should be subclass of GenericState[Parent]
+            # This means subclass_param should be a subclass of self_param
+            if not issubclass(subclass_param, self_param):
+                return False
 
-                        else:
-                            return False  # types are not matching
+        return True
 
-            return True  # when all parameters were matching we have matching subclass
+    def _find_parametrized_base(
+        self,
+        subclass: type[Any],
+    ) -> Mapping[str, Any] | None:
+        self_origin: type[Any] = getattr(self, "__origin__", self)
+        for base in getattr(subclass, "__mro__", ()):
+            if getattr(base, "__origin__", None) is not self_origin:
+                continue
 
-        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())
+            subclass_params: Mapping[str, Any] | None = getattr(base, "__TYPE_PARAMETERS__", None)
+            if subclass_params is not None:
+                return subclass_params
 
-        else:
-            return False  # we have different base / comparing to not parametrized
+        return None
 
 
 def _resolve_default[Value](
@@ -514,6 +458,8 @@ class State(metaclass=StateMeta):
             namespace={"__module__": cls.__module__},
             type_parameters=type_parameters,
         )
+        # Set origin for subclass checks
+        parametrized_type.__origin__ = cls  # pyright: ignore[reportAttributeAccessIssue]
         _types_cache[(cls, type_arguments)] = parametrized_type
         return parametrized_type
 

haiway/state/validation.py

@@ -1,4 +1,4 @@
-from collections.abc import Callable, Mapping, MutableMapping, Sequence, Set
+from collections.abc import Callable, Collection, Mapping, MutableMapping, Sequence, Set
 from datetime import date, datetime, time, timedelta, timezone
 from enum import Enum
 from pathlib import Path
@@ -132,6 +132,14 @@ class AttributeValidator[Type]:
                 _prepare_validator_of_type(annotation, recursion_guard),
             )
 
+        elif isinstance(annotation.origin, type):
+            # Handle arbitrary types as valid type annotations
+            object.__setattr__(
+                validator,
+                "validation",
+                _prepare_validator_of_type(annotation, recursion_guard),
+            )
+
         else:
             raise TypeError(f"Unsupported type annotation: {annotation}")
 
@@ -397,12 +405,11 @@ def _prepare_validator_of_type(
         value: Any,
         /,
     ) -> Any:
-        match value:
-            case value if isinstance(value, validated_type):
-                return value
+        if isinstance(value, validated_type):
+            return value
 
-            case _:
-                raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+        else:
+            raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
 
     return validator
 
@@ -440,8 +447,8 @@ def _prepare_validator_of_set(
         value: Any,
         /,
     ) -> Any:
-        if isinstance(value, set):
-            return frozenset(element_validator(element) for element in value)  # pyright: ignore[reportUnknownVariableType]
+        if isinstance(value, Set):
+            return frozenset(element_validator(element) for element in value)
 
         else:
             raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
@@ -482,12 +489,53 @@ def _prepare_validator_of_sequence(
         value: Any,
         /,
     ) -> Any:
-        match value:
-            case [*elements]:
-                return tuple(element_validator(element) for element in elements)
+        if isinstance(value, Sequence) and not isinstance(value, str | bytes):
+            return tuple(element_validator(element) for element in value)
 
-            case _:
-                raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+        else:
+            raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+
+    return validator
+
+
+def _prepare_validator_of_collection(
+    annotation: AttributeAnnotation,
+    /,
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    """
+    Create a validator for collection types.
+
+    This validator checks if the value is a collection and validates each element
+    according to the collection's element type. Collections are converted to tuples.
+
+    Parameters
+    ----------
+    annotation : AttributeAnnotation
+        The collection type annotation
+    recursion_guard : MutableMapping[str, AttributeValidation[Any]]
+        Mapping to prevent infinite recursion for recursive types
+
+    Returns
+    -------
+    AttributeValidation[Any]
+        A validator that validates collections and their elements
+    """
+    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, Collection) and not isinstance(value, str | bytes):
+            return tuple(element_validator(element) for element in value)
+
+        else:
+            raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
 
     return validator
 
@@ -529,16 +577,12 @@ def _prepare_validator_of_mapping(
         value: Any,
         /,
     ) -> Any:
-        match value:
-            case {**elements}:
-                # 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}'")
+        if isinstance(value, Mapping):
+            # TODO: make sure dict is not mutable with MappingProxyType?
+            return {key_validator(key): value_validator(element) for key, element in value.items()}
+
+        else:
+            raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
 
     return validator
 
@@ -580,14 +624,11 @@ def _prepare_validator_of_tuple(
             value: Any,
             /,
         ) -> Any:
-            match value:
-                case [*elements]:
-                    return tuple(element_validator(element) for element in elements)
+            if isinstance(value, Collection) and not isinstance(value, str | bytes):
+                return tuple(element_validator(element) for element in value)
 
-                case _:
-                    raise TypeError(
-                        f"'{value}' is not matching expected type of '{formatted_type}'"
-                    )
+            else:
+                raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
 
         return validator
 
@@ -603,22 +644,17 @@ def _prepare_validator_of_tuple(
             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](element) for idx, element in enumerate(elements)
-                    )
-
-                case _:
-                    raise TypeError(
+            if isinstance(value, Sequence):
+                if len(value) != elements_count:
+                    raise ValueError(
                         f"'{value}' is not matching expected type of '{formatted_type}'"
                     )
 
+                return tuple(element_validators[idx](element) for idx, element in enumerate(value))
+
+            else:
+                raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+
         return validator
 
 
@@ -738,12 +774,11 @@ def _prepare_validator_of_typed_dict(
         value: Any,
         /,
     ) -> Any:
-        match value:
-            case value if isinstance(value, str):
-                return value
+        if isinstance(value, str):
+            return value
 
-            case _:
-                raise TypeError(f"'{value}' is not matching expected type of 'str'")
+        else:
+            raise TypeError(f"'{value}' is not matching expected type of 'str'")
 
     formatted_type: str = str(annotation)
     values_validators: dict[str, AttributeValidation[Any]] = {
@@ -756,21 +791,20 @@ def _prepare_validator_of_typed_dict(
         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 MISSING and key not in required_values:
-                        continue  # skip missing and not required
+        if isinstance(value, Mapping):
+            validated: MutableMapping[str, Any] = {}
+            for key, validator in values_validators.items():
+                element: Any = value.get(key, MISSING)
+                if element is MISSING and key not in required_values:
+                    continue  # skip missing and not required
 
-                    validated[key_validator(key)] = validator(element)
+                validated[key_validator(key)] = validator(element)
 
-                # TODO: make sure dict is not mutable with MappingProxyType?
-                return validated
+            # TODO: make sure dict is not mutable with MappingProxyType?
+            return validated
 
-            case _:
-                raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+        else:
+            raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
 
     return validator
 
@@ -799,6 +833,7 @@ VALIDATORS: Mapping[
     frozenset: _prepare_validator_of_set,
     Set: _prepare_validator_of_set,
     Sequence: _prepare_validator_of_sequence,
+    Collection: _prepare_validator_of_collection,
     Mapping: _prepare_validator_of_mapping,
     Literal: _prepare_validator_of_literal,
     range: _prepare_validator_of_type,

{haiway-0.24.3.dist-info → haiway-0.25.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: haiway
-Version: 0.24.3
+Version: 0.25.1
 Summary: Framework for dependency injection and state management within structured concurrency model.
 Project-URL: Homepage, https://miquido.com
 Project-URL: Repository, https://github.com/miquido/haiway.git