haiway 0.10.14__py3-none-any.whl → 0.10.16__py3-none-any.whl

haiway/state/validation.py

@@ -0,0 +1,468 @@
+from collections.abc import Callable, Mapping, MutableMapping, Sequence, Set
+from datetime import date, datetime, time, timedelta, timezone
+from enum import Enum
+from pathlib import Path
+from re import Pattern
+from types import EllipsisType, NoneType, UnionType
+from typing import Any, Literal, Protocol, Self, Union, is_typeddict
+from uuid import UUID
+
+from haiway.state.attributes import AttributeAnnotation
+from haiway.types import MISSING, Missing
+
+__all__ = [
+    "AttributeValidation",
+    "AttributeValidationError",
+    "AttributeValidator",
+]
+
+
+class AttributeValidation[Type](Protocol):
+    def __call__(
+        self,
+        value: Any,
+        /,
+    ) -> Type: ...
+
+
+class AttributeValidationError(Exception):
+    pass
+
+
+class AttributeValidator[Type]:
+    @classmethod
+    def of(
+        cls,
+        annotation: AttributeAnnotation,
+        /,
+        *,
+        recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+    ) -> AttributeValidation[Any]:
+        if isinstance(annotation.origin, NotImplementedError | RuntimeError):
+            raise annotation.origin  # raise an error if origin was not properly resolved
+
+        if recursive := recursion_guard.get(str(annotation)):
+            return recursive
+
+        validator: Self = cls(
+            annotation,
+            validation=MISSING,
+        )
+        recursion_guard[str(annotation)] = validator
+
+        if common := VALIDATORS.get(annotation.origin):
+            validator.validation = common(annotation, recursion_guard)
+
+        elif hasattr(annotation.origin, "__IMMUTABLE__"):
+            validator.validation = _prepare_validator_of_type(annotation, recursion_guard)
+
+        elif is_typeddict(annotation.origin):
+            validator.validation = _prepare_validator_of_typed_dict(annotation, recursion_guard)
+
+        elif issubclass(annotation.origin, Protocol):
+            validator.validation = _prepare_validator_of_type(annotation, recursion_guard)
+
+        elif issubclass(annotation.origin, Enum):
+            validator.validation = _prepare_validator_of_type(annotation, recursion_guard)
+
+        else:
+            raise TypeError(f"Unsupported type annotation: {annotation}")
+
+        return validator
+
+    def __init__(
+        self,
+        annotation: AttributeAnnotation,
+        validation: AttributeValidation[Type] | Missing,
+    ) -> None:
+        self.annotation: AttributeAnnotation = annotation
+        self.validation: AttributeValidation[Type] | Missing = validation
+
+    def __call__(
+        self,
+        value: Any,
+        /,
+    ) -> Any:
+        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,
+    /,
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    def validator(
+        value: Any,
+        /,
+    ) -> Any:
+        return value  # any is always valid
+
+    return validator
+
+
+def _prepare_validator_of_none(
+    annotation: AttributeAnnotation,
+    /,
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    def validator(
+        value: Any,
+        /,
+    ) -> Any:
+        if value is None:
+            return value
+
+        else:
+            raise TypeError(f"'{value}' is not matching expected type of 'None'")
+
+    return validator
+
+
+def _prepare_validator_of_missing(
+    annotation: AttributeAnnotation,
+    /,
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    def validator(
+        value: Any,
+        /,
+    ) -> Any:
+        if value is MISSING:
+            return value
+
+        else:
+            raise TypeError(f"'{value}' is not matching expected type of 'Missing'")
+
+    return validator
+
+
+def _prepare_validator_of_literal(
+    annotation: AttributeAnnotation,
+    /,
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    elements: Sequence[Any] = annotation.arguments
+    formatted_type: str = str(annotation)
+
+    def validator(
+        value: Any,
+        /,
+    ) -> Any:
+        if value in elements:
+            return value
+
+        else:
+            raise ValueError(f"'{value}' is not matching expected values of '{formatted_type}'")
+
+    return validator
+
+
+def _prepare_validator_of_type(
+    annotation: AttributeAnnotation,
+    /,
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    validated_type: type[Any] = annotation.origin
+    formatted_type: str = str(annotation)
+
+    def validator(
+        value: Any,
+        /,
+    ) -> Any:
+        match value:
+            case value if isinstance(value, validated_type):
+                return value
+
+            case _:
+                raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+
+    return validator
+
+
+def _prepare_validator_of_set(
+    annotation: AttributeAnnotation,
+    /,
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    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, set):
+            return frozenset(element_validator(element) for element in value)  # pyright: ignore[reportUnknownVariableType]
+
+        else:
+            raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+
+    return validator
+
+
+def _prepare_validator_of_sequence(
+    annotation: AttributeAnnotation,
+    /,
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    element_validator: AttributeValidation[Any] = AttributeValidator.of(
+        annotation.arguments[0],
+        recursion_guard=recursion_guard,
+    )
+    formatted_type: str = str(annotation)
+
+    def validator(
+        value: Any,
+        /,
+    ) -> Any:
+        match value:
+            case [*elements]:
+                return tuple(element_validator(element) for element in elements)
+
+            case _:
+                raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+
+    return validator
+
+
+def _prepare_validator_of_mapping(
+    annotation: AttributeAnnotation,
+    /,
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    key_validator: AttributeValidation[Any] = AttributeValidator.of(
+        annotation.arguments[0],
+        recursion_guard=recursion_guard,
+    )
+    value_validator: AttributeValidation[Any] = AttributeValidator.of(
+        annotation.arguments[1],
+        recursion_guard=recursion_guard,
+    )
+    formatted_type: str = str(annotation)
+
+    def validator(
+        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}'")
+
+    return validator
+
+
+def _prepare_validator_of_tuple(
+    annotation: AttributeAnnotation,
+    /,
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    if (
+        annotation.arguments[-1].origin == Ellipsis
+        or annotation.arguments[-1].origin == EllipsisType
+    ):
+        element_validator: AttributeValidation[Any] = AttributeValidator.of(
+            annotation.arguments[0],
+            recursion_guard=recursion_guard,
+        )
+        formatted_type: str = str(annotation)
+
+        def validator(
+            value: Any,
+            /,
+        ) -> Any:
+            match value:
+                case [*elements]:
+                    return tuple(element_validator(element) for element in elements)
+
+                case _:
+                    raise TypeError(
+                        f"'{value}' is not matching expected type of '{formatted_type}'"
+                    )
+
+        return validator
+
+    else:
+        element_validators: list[AttributeValidation[Any]] = [
+            AttributeValidator.of(alternative, recursion_guard=recursion_guard)
+            for alternative in annotation.arguments
+        ]
+        elements_count: int = len(element_validators)
+        formatted_type: str = str(annotation)
+
+        def validator(
+            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(
+                        f"'{value}' is not matching expected type of '{formatted_type}'"
+                    )
+
+        return validator
+
+
+def _prepare_validator_of_union(
+    annotation: AttributeAnnotation,
+    /,
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    validators: list[AttributeValidation[Any]] = [
+        AttributeValidator.of(alternative, recursion_guard=recursion_guard)
+        for alternative in annotation.arguments
+    ]
+    formatted_type: str = str(annotation)
+
+    def validator(
+        value: Any,
+        /,
+    ) -> Any:
+        errors: list[Exception] = []
+        for validator in validators:
+            try:
+                return validator(value)
+
+            except Exception as exc:
+                errors.append(exc)
+
+        raise ExceptionGroup(
+            f"'{value}' is not matching expected type of '{formatted_type}'",
+            errors,
+        )
+
+    return validator
+
+
+def _prepare_validator_of_callable(
+    annotation: AttributeAnnotation,
+    /,
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    formatted_type: str = str(annotation)
+
+    def validator(
+        value: Any,
+        /,
+    ) -> Any:
+        if callable(value):
+            # TODO: we could verify callable signature here
+            return value
+
+        else:
+            raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+
+    return validator
+
+
+def _prepare_validator_of_typed_dict(
+    annotation: AttributeAnnotation,
+    /,
+    recursion_guard: MutableMapping[str, AttributeValidation[Any]],
+) -> AttributeValidation[Any]:
+    def key_validator(
+        value: Any,
+        /,
+    ) -> Any:
+        match value:
+            case value if isinstance(value, str):
+                return value
+
+            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["attributes"].items()
+    }
+    required_values: Set[str] = annotation.extra["required"]
+
+    def validator(
+        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
+
+                    validated[key_validator(key)] = validator(element)
+
+                # TODO: make sure dict is not mutable with MappingProxyType?
+                return validated
+
+            case _:
+                raise TypeError(f"'{value}' is not matching expected type of '{formatted_type}'")
+
+    return validator
+
+
+VALIDATORS: Mapping[
+    Any,
+    Callable[
+        [
+            AttributeAnnotation,
+            MutableMapping[str, AttributeValidation[Any]],
+        ],
+        AttributeValidation[Any],
+    ],
+] = {
+    Any: _prepare_validator_of_any,
+    NoneType: _prepare_validator_of_none,
+    Missing: _prepare_validator_of_missing,
+    type: _prepare_validator_of_type,
+    bool: _prepare_validator_of_type,
+    int: _prepare_validator_of_type,
+    float: _prepare_validator_of_type,
+    complex: _prepare_validator_of_type,
+    bytes: _prepare_validator_of_type,
+    str: _prepare_validator_of_type,
+    tuple: _prepare_validator_of_tuple,
+    frozenset: _prepare_validator_of_set,
+    Set: _prepare_validator_of_set,
+    Sequence: _prepare_validator_of_sequence,
+    Mapping: _prepare_validator_of_mapping,
+    Literal: _prepare_validator_of_literal,
+    range: _prepare_validator_of_type,
+    UUID: _prepare_validator_of_type,
+    date: _prepare_validator_of_type,
+    datetime: _prepare_validator_of_type,
+    time: _prepare_validator_of_type,
+    timedelta: _prepare_validator_of_type,
+    timezone: _prepare_validator_of_type,
+    Path: _prepare_validator_of_type,
+    Pattern: _prepare_validator_of_type,
+    Union: _prepare_validator_of_union,
+    UnionType: _prepare_validator_of_union,
+    Callable: _prepare_validator_of_callable,
+}

haiway/types/__init__.py

@@ -0,0 +1,14 @@
+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",
+    "not_missing",
+    "when_missing",
+]

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/types/frozen.py

@@ -0,0 +1,5 @@
+__all__ = [
+    "frozenlist",
+]
+
+type frozenlist[Value] = tuple[Value, ...]

haiway/types/missing.py

@@ -0,0 +1,95 @@
+from typing import Any, Final, TypeGuard, cast, final
+
+__all__ = [
+    "MISSING",
+    "Missing",
+    "is_missing",
+    "not_missing",
+    "when_missing",
+]
+
+
+class MissingType(type):
+    _instance: Any = None
+
+    def __call__(cls) -> Any:
+        if cls._instance is None:
+            cls._instance = super().__call__()
+            return cls._instance
+
+        else:
+            return cls._instance
+
+
+@final
+class Missing(metaclass=MissingType):
+    """
+    Type representing absence of a value. Use MISSING constant for its value.
+    """
+
+    __slots__ = ()
+    __match_args__ = ()
+
+    def __bool__(self) -> bool:
+        return False
+
+    def __eq__(
+        self,
+        value: object,
+    ) -> bool:
+        return value is MISSING
+
+    def __str__(self) -> str:
+        return "MISSING"
+
+    def __repr__(self) -> str:
+        return "MISSING"
+
+    def __getattr__(
+        self,
+        name: str,
+    ) -> Any:
+        raise AttributeError("Missing has no attributes")
+
+    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")
+
+
+MISSING: Final[Missing] = Missing()
+
+
+def is_missing(
+    check: Any | Missing,
+    /,
+) -> TypeGuard[Missing]:
+    return check is MISSING
+
+
+def not_missing[Value](
+    check: Value | Missing,
+    /,
+) -> TypeGuard[Value]:
+    return check is not MISSING
+
+
+def when_missing[Value](
+    check: Value | Missing,
+    /,
+    *,
+    value: Value,
+) -> Value:
+    if check is MISSING:
+        return value
+
+    else:
+        return cast(Value, check)

haiway/utils/__init__.py

@@ -0,0 +1,28 @@
+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.freezing import freeze
+from haiway.utils.logs import setup_logging
+from haiway.utils.mimic import mimic_function
+from haiway.utils.noop import async_noop, noop
+from haiway.utils.queue import AsyncQueue
+
+__all__ = [
+    "AsyncQueue",
+    "always",
+    "as_dict",
+    "as_list",
+    "as_set",
+    "as_tuple",
+    "async_always",
+    "async_noop",
+    "freeze",
+    "getenv_bool",
+    "getenv_float",
+    "getenv_int",
+    "getenv_str",
+    "load_env",
+    "mimic_function",
+    "noop",
+    "setup_logging",
+]