haiway 0.11.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

haiway/context/tasks.py

@@ -1,8 +1,8 @@
 from asyncio import Task, TaskGroup, get_event_loop
 from collections.abc import Callable, Coroutine
-from contextvars import ContextVar, copy_context
+from contextvars import ContextVar, Token, copy_context
 from types import TracebackType
-from typing import final
+from typing import Any, final
 
 __all__ = [
     "TaskGroupContext",
@@ -33,15 +33,54 @@ class TaskGroupContext:
                 context=copy_context(),
             )
 
+    __slots__ = (
+        "_group",
+        "_token",
+    )
+
     def __init__(
         self,
     ) -> None:
-        self._group: TaskGroup = TaskGroup()
+        self._group: TaskGroup
+        object.__setattr__(
+            self,
+            "_group",
+            TaskGroup(),
+        )
+        self._token: Token[TaskGroup] | None
+        object.__setattr__(
+            self,
+            "_token",
+            None,
+        )
+
+    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"
+        )
 
     async def __aenter__(self) -> None:
-        assert not hasattr(self, "_token"), "Context reentrance is not allowed"  # nosec: B101
+        assert self._token is None, "Context reentrance is not allowed"  # nosec: B101
         await self._group.__aenter__()
-        self._token = TaskGroupContext._context.set(self._group)
+        object.__setattr__(
+            self,
+            "_token",
+            TaskGroupContext._context.set(self._group),
+        )
 
     async def __aexit__(
         self,
@@ -49,9 +88,13 @@ class TaskGroupContext:
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> None:
-        assert hasattr(self, "_token"), "Unbalanced context enter/exit"  # nosec: B101
+        assert self._token is not None, "Unbalanced context enter/exit"  # nosec: B101
         TaskGroupContext._context.reset(self._token)
-        del self._token
+        object.__setattr__(
+            self,
+            "_token",
+            None,
+        )
 
         try:
             await self._group.__aexit__(

haiway/helpers/asynchrony.py

@@ -107,6 +107,20 @@ def asynchronous[**Args, Result](
 
 
 class _ExecutorWrapper[**Args, Result]:
+    __slots__ = (
+        "__annotations__",
+        "__defaults__",
+        "__doc__",
+        "__globals__",
+        "__kwdefaults__",
+        "__name__",
+        "__qualname__",
+        "__wrapped__",
+        "_executor",
+        "_function",
+        "_loop",
+    )
+
     def __init__(
         self,
         function: Callable[Args, Result],

haiway/helpers/caching.py

@@ -89,6 +89,21 @@ class _CacheEntry[Entry](NamedTuple):
 
 
 class _SyncCache[**Args, Result]:
+    __slots__ = (
+        "__annotations__",
+        "__defaults__",
+        "__doc__",
+        "__globals__",
+        "__kwdefaults__",
+        "__name__",
+        "__qualname__",
+        "__wrapped__",
+        "_cached",
+        "_function",
+        "_limit",
+        "_next_expire_time",
+    )
+
     def __init__(
         self,
         function: Callable[Args, Result],
@@ -206,6 +221,21 @@ class _SyncCache[**Args, Result]:
 
 
 class _AsyncCache[**Args, Result]:
+    __slots__ = (
+        "__annotations__",
+        "__defaults__",
+        "__doc__",
+        "__globals__",
+        "__kwdefaults__",
+        "__name__",
+        "__qualname__",
+        "__wrapped__",
+        "_cached",
+        "_function",
+        "_limit",
+        "_next_expire_time",
+    )
+
     def __init__(
         self,
         function: Callable[Args, Coroutine[None, None, Result]],

haiway/helpers/metrics.py

@@ -14,6 +14,14 @@ __all_ = [
 
 
 class MetricsScopeStore:
+    __slots__ = (
+        "entered",
+        "exited",
+        "identifier",
+        "metrics",
+        "nested",
+    )
+
     def __init__(
         self,
         identifier: ScopeIdentifier,
@@ -100,6 +108,11 @@ class MetricsHolder:
             exit_scope=store_handler.exit_scope,
         )
 
+    __slots__ = (
+        "root_scope",
+        "scopes",
+    )
+
     def __init__(self) -> None:
         self.root_scope: ScopeIdentifier | None = None
         self.scopes: dict[ScopeIdentifier, MetricsScopeStore] = {}
@@ -187,6 +200,13 @@ class MetricsLogger:
             exit_scope=logger_handler.exit_scope,
         )
 
+    __slots__ = (
+        "items_limit",
+        "redact_content",
+        "root_scope",
+        "scopes",
+    )
+
     def __init__(
         self,
         items_limit: int | None,

haiway/helpers/throttling.py

@@ -89,6 +89,22 @@ def throttle[**Args, Result](
 
 
 class _AsyncThrottle[**Args, Result]:
+    __slots__ = (
+        "__annotations__",
+        "__defaults__",
+        "__doc__",
+        "__globals__",
+        "__kwdefaults__",
+        "__name__",
+        "__qualname__",
+        "__wrapped__",
+        "_entries",
+        "_function",
+        "_limit",
+        "_lock",
+        "_period",
+    )
+
     def __init__(
         self,
         function: Callable[Args, Coroutine[None, None, Result]],

haiway/helpers/timeouted.py

@@ -45,6 +45,19 @@ def timeout[**Args, Result](
 
 
 class _AsyncTimeout[**Args, Result]:
+    __slots__ = (
+        "__annotations__",
+        "__defaults__",
+        "__doc__",
+        "__globals__",
+        "__kwdefaults__",
+        "__name__",
+        "__qualname__",
+        "__wrapped__",
+        "_function",
+        "_timeout",
+    )
+
     def __init__(
         self,
         function: Callable[Args, Coroutine[None, None, Result]],

haiway/state/attributes.py

@@ -14,6 +14,7 @@ from typing import (
     TypeVar,
     TypeVarTuple,
     _GenericAlias,  # pyright: ignore
+    final,
     get_args,
     get_origin,
     get_type_hints,
@@ -31,7 +32,15 @@ __all__ = [
 ]
 
 
+@final
 class AttributeAnnotation:
+    __slots__ = (
+        "arguments",
+        "extra",
+        "origin",
+        "required",
+    )
+
     def __init__(
         self,
         *,
@@ -49,6 +58,7 @@ class AttributeAnnotation:
             self.arguments = arguments
 
         self.required: bool = required
+
         self.extra: Mapping[str, Any]
         if extra is None:
             self.extra = {}
@@ -61,7 +71,11 @@ class AttributeAnnotation:
         required: bool,
         /,
     ) -> Self:
-        self.required = self.required and required
+        object.__setattr__(
+            self,
+            "required",
+            self.required and required,
+        )
 
         return self
 

haiway/state/path.py

@@ -41,6 +41,12 @@ class AttributePathComponent(ABC):
 
 @final
 class PropertyAttributePathComponent(AttributePathComponent):
+    __slots__ = (
+        "_access",
+        "_assigning",
+        "_name",
+    )
+
     def __init__[Root, Attribute](
         self,
         root: type[Root],
@@ -104,9 +110,43 @@ class PropertyAttributePathComponent(AttributePathComponent):
 
             return updated  # pyright: ignore[reportUnknownVariableType]
 
-        self._access: Callable[[Any], Any] = access
-        self._assigning: Callable[[Any, Any], Any] = assigning
-        self._name: str = name
+        self._access: Callable[[Any], Any]
+        object.__setattr__(
+            self,
+            "_access",
+            access,
+        )
+        self._assigning: Callable[[Any, Any], Any]
+        object.__setattr__(
+            self,
+            "_assigning",
+            assigning,
+        )
+        self._name: str
+        object.__setattr__(
+            self,
+            "_name",
+            name,
+        )
+
+    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 path_str(
         self,
@@ -137,6 +177,12 @@ class PropertyAttributePathComponent(AttributePathComponent):
 
 @final
 class SequenceItemAttributePathComponent(AttributePathComponent):
+    __slots__ = (
+        "_access",
+        "_assigning",
+        "_index",
+    )
+
     def __init__[Root: Sequence[Any], Attribute](
         self,
         root: type[Root],
@@ -182,9 +228,43 @@ class SequenceItemAttributePathComponent(AttributePathComponent):
             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
+        self._access: Callable[[Any], Any]
+        object.__setattr__(
+            self,
+            "_access",
+            access,
+        )
+        self._assigning: Callable[[Any, Any], Any]
+        object.__setattr__(
+            self,
+            "_assigning",
+            assigning,
+        )
+        self._index: Any
+        object.__setattr__(
+            self,
+            "_index",
+            index,
+        )
+
+    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 path_str(
         self,
@@ -211,6 +291,12 @@ class SequenceItemAttributePathComponent(AttributePathComponent):
 
 @final
 class MappingItemAttributePathComponent(AttributePathComponent):
+    __slots__ = (
+        "_access",
+        "_assigning",
+        "_key",
+    )
+
     def __init__[Root: Mapping[Any, Any], Attribute](
         self,
         root: type[Root],
@@ -256,9 +342,43 @@ class MappingItemAttributePathComponent(AttributePathComponent):
             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
+        self._access: Callable[[Any], Any]
+        object.__setattr__(
+            self,
+            "_access",
+            access,
+        )
+        self._assigning: Callable[[Any, Any], Any]
+        object.__setattr__(
+            self,
+            "_assigning",
+            assigning,
+        )
+        self._key: Any
+        object.__setattr__(
+            self,
+            "_key",
+            key,
+        )
+
+    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 path_str(
         self,
@@ -285,6 +405,12 @@ class MappingItemAttributePathComponent(AttributePathComponent):
 
 @final
 class AttributePath[Root, Attribute]:
+    __slots__ = (
+        "__attribute__",
+        "__components__",
+        "__root__",
+    )
+
     @overload
     def __init__(
         self,
@@ -311,9 +437,43 @@ class AttributePath[Root, Attribute]:
         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
+        self.__root__: type[Root]
+        object.__setattr__(
+            self,
+            "__root__",
+            root,
+        )
+        self.__attribute__: type[Attribute]
+        object.__setattr__(
+            self,
+            "__attribute__",
+            attribute,
+        )
+        self.__components__: tuple[AttributePathComponent, ...]
+        object.__setattr__(
+            self,
+            "__components__",
+            components,
+        )
+
+    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"
+        )
 
     @property
     def components(self) -> Sequence[str]:

haiway/state/requirement.py

@@ -2,7 +2,6 @@ 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",
@@ -142,6 +141,13 @@ class AttributeRequirement[Root]:
             check=check_contained_in,
         )
 
+    __slots__ = (
+        "_check",
+        "lhs",
+        "operator",
+        "rhs",
+    )
+
     def __init__(
         self,
         lhs: Any,
@@ -157,7 +163,12 @@ class AttributeRequirement[Root]:
         rhs: Any,
         check: Callable[[Root], None],
     ) -> None:
-        self.lhs: Any = lhs
+        self.lhs: Any
+        object.__setattr__(
+            self,
+            "lhs",
+            lhs,
+        )
         self.operator: Literal[
             "equal",
             "not_equal",
@@ -166,11 +177,24 @@ class AttributeRequirement[Root]:
             "contained_in",
             "and",
             "or",
-        ] = operator
-        self.rhs: Any = rhs
-        self._check: Callable[[Root], None] = check
-
-        freeze(self)
+        ]
+        object.__setattr__(
+            self,
+            "operator",
+            operator,
+        )
+        self.rhs: Any
+        object.__setattr__(
+            self,
+            "rhs",
+            rhs,
+        )
+        self._check: Callable[[Root], None]
+        object.__setattr__(
+            self,
+            "_check",
+            check,
+        )
 
     def __and__(
         self,
@@ -227,3 +251,22 @@ class AttributeRequirement[Root]:
         values: Iterable[Root],
     ) -> list[Root]:
         return [value for value in values if self.check(value, raise_exception=False)]
+
+    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"
+        )

haiway/state/structure.py

@@ -49,6 +49,13 @@ def Default[Value](
 
 @final
 class StateAttribute[Value]:
+    __slots__ = (
+        "annotation",
+        "default",
+        "name",
+        "validator",
+    )
+
     def __init__(
         self,
         name: str,
@@ -56,10 +63,30 @@ class StateAttribute[Value]:
         default: DefaultValue[Value],
         validator: AttributeValidation[Value],
     ) -> None:
-        self.name: str = name
-        self.annotation: AttributeAnnotation = annotation
-        self.default: DefaultValue[Value] = default
-        self.validator: AttributeValidation[Value] = validator
+        self.name: str
+        object.__setattr__(
+            self,
+            "name",
+            name,
+        )
+        self.annotation: AttributeAnnotation
+        object.__setattr__(
+            self,
+            "annotation",
+            annotation,
+        )
+        self.default: DefaultValue[Value]
+        object.__setattr__(
+            self,
+            "default",
+            default,
+        )
+        self.validator: AttributeValidation[Value]
+        object.__setattr__(
+            self,
+            "validator",
+            validator,
+        )
 
     def validated(
         self,
@@ -68,6 +95,25 @@ class StateAttribute[Value]:
     ) -> Value:
         return self.validator(self.default() if value is MISSING else value)
 
+    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"
+        )
+
 
 @dataclass_transform(
     kw_only_default=True,