haiway 0.7.0__tar.gz → 0.7.1__tar.gz

{haiway-0.7.0/src/haiway.egg-info → haiway-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: haiway
-Version: 0.7.0
+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.7.0 → haiway-0.7.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "haiway"
 description = "Framework for dependency injection and state management within structured concurrency model."
-version = "0.7.0"
+version = "0.7.1"
 readme = "README.md"
 maintainers = [
   { name = "Kacper Kaliński", email = "kacper.kalinski@miquido.com" },

{haiway-0.7.0 → haiway-0.7.1}/src/haiway/state/structure.py

@@ -1,3 +1,5 @@
+import typing
+from collections.abc import Mapping
 from copy import deepcopy
 from types import EllipsisType, GenericAlias
 from typing import (
@@ -89,10 +91,11 @@ class StateMeta(type):
                 ),
             )
 
+        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
 
@@ -102,6 +105,88 @@ class StateMeta(type):
         /,
     ) -> 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[
@@ -119,6 +204,7 @@ class State(metaclass=StateMeta):
 
     _: ClassVar[Self]
     __IMMUTABLE__: ClassVar[EllipsisType] = ...
+    __PARAMETERS__: ClassVar[Mapping[str, Any] | None] = None
     __ATTRIBUTES__: ClassVar[dict[str, StateAttribute[Any]]]
 
     @classmethod
@@ -127,6 +213,7 @@ class State(metaclass=StateMeta):
         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:

{haiway-0.7.0 → haiway-0.7.1/src/haiway.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: haiway
-Version: 0.7.0
+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.7.0 → haiway-0.7.1}/tests/test_state.py

@@ -1,9 +1,11 @@
 from collections.abc import Callable, Sequence, Set
 from datetime import date, datetime
 from enum import StrEnum
-from typing import Literal, NotRequired, Protocol, Required, Self, TypedDict, runtime_checkable
+from typing import Any, Literal, NotRequired, Protocol, Required, Self, TypedDict, runtime_checkable
 from uuid import UUID, uuid4
 
+from pytest import raises
+
 from haiway import MISSING, Missing, State, frozenlist
 
 
@@ -183,3 +185,40 @@ def test_initialization_allows_missing_properties() -> None:
     assert Basics(**{"string": "a", "integer": 1}) == Basics(string="a", integer=1)
     assert Basics(**{"string": "a", "integer": None}) == Basics(string="a", integer=None)
     assert Basics(**{"string": "a"}) == Basics(string="a", integer=MISSING)
+
+
+def test_generic_subtypes_validation() -> None:
+    class NestedGeneric[T](State):
+        value: T
+
+    class Generic[T](State):
+        nested: NestedGeneric[T]
+
+    class Container(State):
+        generic: Generic[str]
+
+    assert isinstance(Generic[str](nested=NestedGeneric[str](value="ok")), Generic)
+    assert isinstance(Generic(nested=NestedGeneric[str](value="ok")), Generic)
+    assert isinstance(Generic(nested=NestedGeneric(value="ok")), Generic)
+
+    assert isinstance(Generic[str](nested=NestedGeneric[str](value="ok")), Generic[Any])
+    assert isinstance(Generic(nested=NestedGeneric[str](value="ok")), Generic[Any])
+    assert isinstance(Generic[str](nested=NestedGeneric(value="ok")), Generic[Any])
+    assert isinstance(Generic(nested=NestedGeneric(value="ok")), Generic[Any])
+
+    assert isinstance(Generic[str](nested=NestedGeneric[str](value="ok")), Generic[str])
+    assert isinstance(Generic(nested=NestedGeneric[str](value="ok")), Generic[str])
+    assert isinstance(Generic[str](nested=NestedGeneric(value="ok")), Generic[str])
+    assert isinstance(Generic(nested=NestedGeneric(value="ok")), Generic[str])
+
+    with raises(TypeError):
+        _ = Generic[int](nested=NestedGeneric[str](value="ok"))
+
+    with raises(TypeError):
+        _ = Container(generic=Generic(nested=NestedGeneric(value=42)))
+
+    with raises(TypeError):
+        _ = Container(generic=Generic[int](nested=NestedGeneric[str](value="ok")))
+
+    # not raises
+    _ = Container(generic=Generic(nested=NestedGeneric(value="ok")))