haiway 0.9.1__tar.gz → 0.10.1__tar.gz

{haiway-0.9.1/src/haiway.egg-info → haiway-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: haiway
-Version: 0.9.1
+Version: 0.10.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.9.1 → haiway-0.10.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.9.1"
+version = "0.10.1"
 readme = "README.md"
 maintainers = [
   { name = "Kacper Kaliński", email = "kacper.kalinski@miquido.com" },

{haiway-0.9.1 → haiway-0.10.1}/src/haiway/__init__.py

@@ -28,6 +28,8 @@ from haiway.helpers import (
 from haiway.state import AttributePath, AttributeRequirement, State
 from haiway.types import (
     MISSING,
+    Default,
+    DefaultValue,
     Missing,
     frozenlist,
     is_missing,
@@ -39,6 +41,7 @@ from haiway.utils import (
     always,
     as_dict,
     as_list,
+    as_set,
     as_tuple,
     async_always,
     async_noop,
@@ -59,6 +62,8 @@ __all__ = [
     "AsyncQueue",
     "AttributePath",
     "AttributeRequirement",
+    "Default",
+    "DefaultValue",
     "Disposable",
     "Disposables",
     "MetricsContext",
@@ -78,6 +83,7 @@ __all__ = [
     "always",
     "as_dict",
     "as_list",
+    "as_set",
     "as_tuple",
     "async_always",
     "async_noop",

{haiway-0.9.1 → haiway-0.10.1}/src/haiway/state/attributes.py

@@ -509,7 +509,10 @@ def _resolve_type_typeddict(
             self_annotation=resolved_attribute,
             recursion_guard=recursion_guard,
         ).update_required(key in annotation.__required_keys__)
-    resolved_attribute.extra = attributes
+    resolved_attribute.extra = {
+        "attributes": attributes,
+        "required": annotation.__required_keys__,
+    }
     return resolved_attribute
 
 

{haiway-0.9.1 → haiway-0.10.1}/src/haiway/state/structure.py

@@ -1,5 +1,5 @@
 import typing
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from types import EllipsisType, GenericAlias
 from typing import (
     Any,
@@ -10,34 +10,55 @@ from typing import (
     cast,
     dataclass_transform,
     final,
+    overload,
 )
 from weakref import WeakValueDictionary
 
 from haiway.state.attributes import AttributeAnnotation, attribute_annotations
 from haiway.state.path import AttributePath
-from haiway.state.validation import (
-    AttributeValidation,
-    AttributeValidator,
-)
-from haiway.types import MISSING, Missing, not_missing
+from haiway.state.validation import AttributeValidation, AttributeValidator
+from haiway.types import MISSING, DefaultValue, Missing, not_missing
 
 __all__ = [
     "State",
 ]
 
 
+@overload
+def Default[Value](
+    value: Value,
+    /,
+) -> Value: ...
+
+
+@overload
+def Default[Value](
+    *,
+    factory: Callable[[], Value],
+) -> Value: ...
+
+
+def Default[Value](
+    value: Value | Missing = MISSING,
+    /,
+    *,
+    factory: Callable[[], Value] | Missing = MISSING,
+) -> Value:  # it is actually a DefaultValue, but type checker has to be fooled
+    return cast(Value, DefaultValue(value, factory=factory))
+
+
 @final
 class StateAttribute[Value]:
     def __init__(
         self,
         name: str,
         annotation: AttributeAnnotation,
-        default: Value | Missing,
+        default: DefaultValue[Value],
         validator: AttributeValidation[Value],
     ) -> None:
         self.name: str = name
         self.annotation: AttributeAnnotation = annotation
-        self.default: Value | Missing = default
+        self.default: DefaultValue[Value] = default
         self.validator: AttributeValidation[Value] = validator
 
     def validated(
@@ -45,13 +66,13 @@ class StateAttribute[Value]:
         value: Any | Missing,
         /,
     ) -> Value:
-        return self.validator(self.default if value is MISSING else value)
+        return self.validator(self.default() if value is MISSING else value)
 
 
 @dataclass_transform(
     kw_only_default=True,
     frozen_default=True,
-    field_specifiers=(),
+    field_specifiers=(DefaultValue,),
 )
 class StateMeta(type):
     def __new__(
@@ -81,7 +102,7 @@ class StateMeta(type):
             attributes[key] = StateAttribute(
                 name=key,
                 annotation=annotation.update_required(default is MISSING),
-                default=default,
+                default=_resolve_default(default),
                 validator=AttributeValidator.of(
                     annotation,
                     recursion_guard={
@@ -187,6 +208,18 @@ class StateMeta(type):
             return False  # we have different base / comparing to not parametrized
 
 
+def _resolve_default[Value](
+    value: DefaultValue[Value] | Value | Missing,
+) -> DefaultValue[Value]:
+    if isinstance(value, DefaultValue):
+        return cast(DefaultValue[Value], value)
+
+    return DefaultValue[Value](
+        value,
+        factory=MISSING,
+    )
+
+
 _types_cache: WeakValueDictionary[
     tuple[
         Any,

{haiway-0.9.1 → haiway-0.10.1}/src/haiway/state/validation.py

@@ -86,6 +86,12 @@ class AttributeValidator[Type]:
         assert self.validation is not MISSING  # nosec: B101
         return self.validation(value)  # pyright: ignore[reportCallIssue, reportUnknownVariableType]
 
+    def __str__(self) -> str:
+        return f"Validator[{self.annotation}]"
+
+    def __repr__(self) -> str:
+        return f"Validator[{self.annotation}]"
+
 
 def _prepare_validator_of_any(
     annotation: AttributeAnnotation,
@@ -391,11 +397,12 @@ def _prepare_validator_of_typed_dict(
             case _:
                 raise TypeError(f"'{value}' is not matching expected type of 'str'")
 
+    formatted_type: str = str(annotation)
     values_validators: dict[str, AttributeValidation[Any]] = {
         key: AttributeValidator.of(element, recursion_guard=recursion_guard)
-        for key, element in annotation.extra.items()
+        for key, element in annotation.extra["attributes"].items()
     }
-    formatted_type: str = str(annotation)
+    required_values: Set[str] = annotation.extra["required"]
 
     def validator(
         value: Any,
@@ -406,8 +413,10 @@ def _prepare_validator_of_typed_dict(
                 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)
+                    if element is MISSING and key not in required_values:
+                        continue  # skip missing and not required
+
+                    validated[key_validator(key)] = validator(element)
 
                 # TODO: make sure dict is not mutable with MappingProxyType?
                 return validated

{haiway-0.9.1 → haiway-0.10.1}/src/haiway/types/__init__.py

@@ -1,8 +1,11 @@
+from haiway.types.default import Default, DefaultValue
 from haiway.types.frozen import frozenlist
 from haiway.types.missing import MISSING, Missing, is_missing, not_missing, when_missing
 
 __all__ = [
     "MISSING",
+    "Default",
+    "DefaultValue",
     "Missing",
     "frozenlist",
     "is_missing",

haiway-0.10.1/src/haiway/types/default.py

@@ -0,0 +1,108 @@
+from collections.abc import Callable
+from typing import Any, cast, final, overload
+
+from haiway.types.missing import MISSING, Missing, not_missing
+from haiway.utils.always import always
+
+__all__ = [
+    "Default",
+    "DefaultValue",
+]
+
+
+@final
+class DefaultValue[Value]:
+    @overload
+    def __init__(
+        self,
+        value: Value,
+        /,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        /,
+        *,
+        factory: Callable[[], Value],
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        value: Value | Missing,
+        /,
+        *,
+        factory: Callable[[], Value] | Missing,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        value: Value | Missing = MISSING,
+        /,
+        *,
+        factory: Callable[[], Value] | Missing = MISSING,
+    ) -> None:
+        assert (  # nosec: B101
+            value is MISSING or factory is MISSING
+        ), "Can't specify both default value and factory"
+
+        self._value: Callable[[], Value | Missing]
+        if not_missing(factory):
+            object.__setattr__(
+                self,
+                "_value",
+                factory,
+            )
+
+        else:
+            object.__setattr__(
+                self,
+                "_value",
+                always(value),
+            )
+
+    def __call__(self) -> Value | Missing:
+        return self._value()
+
+    def __setattr__(
+        self,
+        __name: str,
+        __value: Any,
+    ) -> None:
+        raise AttributeError("Missing can't be modified")
+
+    def __delattr__(
+        self,
+        __name: str,
+    ) -> None:
+        raise AttributeError("Missing can't be modified")
+
+
+@overload
+def Default[Value](
+    value: Value,
+    /,
+) -> Value: ...
+
+
+@overload
+def Default[Value](
+    *,
+    factory: Callable[[], Value],
+) -> Value: ...
+
+
+def Default[Value](
+    value: Value | Missing = MISSING,
+    /,
+    *,
+    factory: Callable[[], Value] | Missing = MISSING,
+) -> Value:  # it is actually a DefaultValue, but type checker has to be fooled most some cases
+    return cast(
+        Value,
+        DefaultValue(
+            value,
+            factory=factory,
+        ),
+    )

{haiway-0.9.1 → haiway-0.10.1}/src/haiway/types/missing.py

@@ -85,6 +85,7 @@ def not_missing[Value](
 def when_missing[Value](
     check: Value | Missing,
     /,
+    *,
     value: Value,
 ) -> Value:
     if check is MISSING:

{haiway-0.9.1 → haiway-0.10.1}/src/haiway/utils/__init__.py

@@ -1,18 +1,18 @@
 from haiway.utils.always import always, async_always
+from haiway.utils.collections import as_dict, as_list, as_set, as_tuple
 from haiway.utils.env import getenv_bool, getenv_float, getenv_int, getenv_str, load_env
-from haiway.utils.immutable import freeze
+from haiway.utils.freezing import freeze
 from haiway.utils.logs import setup_logging
-from haiway.utils.mappings import as_dict
 from haiway.utils.mimic import mimic_function
 from haiway.utils.noop import async_noop, noop
 from haiway.utils.queue import AsyncQueue
-from haiway.utils.sequences import as_list, as_tuple
 
 __all__ = [
     "AsyncQueue",
     "always",
     "as_dict",
     "as_list",
+    "as_set",
     "as_tuple",
     "async_always",
     "async_noop",

haiway-0.10.1/src/haiway/utils/collections.py

@@ -0,0 +1,108 @@
+from collections.abc import Mapping, Sequence, Set
+
+__all__ = [
+    "as_dict",
+    "as_list",
+    "as_set",
+    "as_tuple",
+]
+
+
+def as_list[T](
+    collection: Sequence[T],
+    /,
+) -> list[T]:
+    """
+    Converts any given Sequence into a list.
+
+    Parameters
+    ----------
+    collection : Sequence[T]
+        The input collection to be converted.
+
+    Returns
+    -------
+    list[T]
+        A new list containing all elements of the input collection,
+        or the original list if it was already one.
+    """
+    if isinstance(collection, list):
+        return collection
+
+    else:
+        return list(collection)
+
+
+def as_tuple[T](
+    collection: Sequence[T],
+    /,
+) -> tuple[T, ...]:
+    """
+    Converts any given Sequence into a tuple.
+
+    Parameters
+    ----------
+    collection : Sequence[T]
+        The input collection to be converted.
+
+    Returns
+    -------
+    tuple[T]
+        A new tuple containing all elements of the input collection,
+        or the original tuple if it was already one.
+    """
+    if isinstance(collection, tuple):
+        return collection
+
+    else:
+        return tuple(collection)
+
+
+def as_set[T](
+    collection: Set[T],
+    /,
+) -> set[T]:
+    """
+    Converts any given Set into a set.
+
+    Parameters
+    ----------
+    collection : Set[T]
+        The input collection to be converted.
+
+    Returns
+    -------
+    set[T]
+        A new set containing all elements of the input collection,
+        or the original set if it was already one.
+    """
+    if isinstance(collection, set):
+        return collection
+
+    else:
+        return set(collection)
+
+
+def as_dict[K, V](
+    collection: Mapping[K, V],
+    /,
+) -> dict[K, V]:
+    """
+    Converts any given Mapping into a dict.
+
+    Parameters
+    ----------
+    collection : Mapping[K, V]
+        The input collection to be converted.
+
+    Returns
+    -------
+    dict[K, V]
+        A new dict containing all elements of the input collection,
+        or the original dict if it was already one.
+    """
+    if isinstance(collection, dict):
+        return collection
+
+    else:
+        return dict(collection)

{haiway-0.9.1 → haiway-0.10.1/src/haiway.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: haiway
-Version: 0.9.1
+Version: 0.10.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.9.1 → haiway-0.10.1}/src/haiway.egg-info/SOURCES.txt

@@ -32,18 +32,18 @@ src/haiway/state/requirement.py
 src/haiway/state/structure.py
 src/haiway/state/validation.py
 src/haiway/types/__init__.py
+src/haiway/types/default.py
 src/haiway/types/frozen.py
 src/haiway/types/missing.py
 src/haiway/utils/__init__.py
 src/haiway/utils/always.py
+src/haiway/utils/collections.py
 src/haiway/utils/env.py
-src/haiway/utils/immutable.py
+src/haiway/utils/freezing.py
 src/haiway/utils/logs.py
-src/haiway/utils/mappings.py
 src/haiway/utils/mimic.py
 src/haiway/utils/noop.py
 src/haiway/utils/queue.py
-src/haiway/utils/sequences.py
 tests/test_async_queue.py
 tests/test_attribute_path.py
 tests/test_auto_retry.py

haiway-0.10.1/src/haiway.egg-info/top_level.txt

@@ -0,0 +1 @@
+haiway

{haiway-0.9.1 → haiway-0.10.1}/tests/test_state.py

@@ -7,7 +7,7 @@ from uuid import UUID, uuid4
 
 from pytest import raises
 
-from haiway import MISSING, Missing, State, frozenlist
+from haiway import MISSING, Default, Missing, State, frozenlist
 
 
 def test_basic_initializes_with_arguments() -> None:
@@ -92,11 +92,15 @@ def test_basic_initializes_with_defaults() -> None:
         string: str = ""
         integer: int = 0
         optional: str | None = None
+        unique: UUID = Default(factory=uuid4)
+        same: UUID = Default(uuid4())
 
     basic = Basics()
     assert basic.string == ""
     assert basic.integer == 0
     assert basic.optional is None
+    assert basic.unique is not Basics().unique
+    assert basic.same is Basics().same
 
 
 def test_basic_equals_checks_properties() -> None:

haiway-0.9.1/src/haiway/utils/mappings.py

@@ -1,30 +0,0 @@
-from collections.abc import Mapping
-
-__all__ = [
-    "as_dict",
-]
-
-
-def as_dict[K, V](
-    mapping: Mapping[K, V],
-    /,
-) -> dict[K, V]:
-    """
-    Converts any given mapping into a dict.
-
-    Parameters
-    ----------
-    mapping : Mapping[K, V]
-        The input mapping to be converted.
-
-    Returns
-    -------
-    dict[K, V]
-        A new dict containing all elements of the input mapping,
-        or the original dict if it was already one.
-    """
-    if isinstance(mapping, dict):
-        return mapping
-
-    else:
-        return dict(mapping)

haiway-0.9.1/src/haiway/utils/sequences.py

@@ -1,56 +0,0 @@
-from collections.abc import Sequence
-
-__all__ = [
-    "as_list",
-    "as_tuple",
-]
-
-
-def as_list[T](
-    sequence: Sequence[T],
-    /,
-) -> list[T]:
-    """
-    Converts any given sequence into a list.
-
-    Parameters
-    ----------
-    sequence : Sequence[T]
-        The input sequence to be converted.
-
-    Returns
-    -------
-    list[T]
-        A new list containing all elements of the input sequence,
-        or the original list if it was already one.
-    """
-    if isinstance(sequence, list):
-        return sequence
-
-    else:
-        return list(sequence)
-
-
-def as_tuple[T](
-    sequence: Sequence[T],
-    /,
-) -> tuple[T, ...]:
-    """
-    Converts any given sequence into a tuple.
-
-    Parameters
-    ----------
-    sequence : Sequence[T]
-        The input sequence to be converted.
-
-    Returns
-    -------
-    tuple[T]
-        A new tuple containing all elements of the input sequence,
-        or the original tuple if it was already one.
-    """
-    if isinstance(sequence, tuple):
-        return sequence
-
-    else:
-        return tuple(sequence)

haiway-0.9.1/src/haiway.egg-info/top_level.txt

@@ -1,2 +0,0 @@
-guidelines
-haiway