adiumentum 0.1.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

adiumentum/pydantic_extensions.py

@@ -0,0 +1,410 @@
+"""
+Idea: make BaseSequence[C, T] type,
+    where C is list|set|tuple and T is the element type
+"""
+
+import json
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Hashable, Mapping
+from pathlib import Path
+from types import GenericAlias
+from typing import (
+    Any,
+    Literal,
+    Self,
+    TypeVar,
+    cast,
+    get_args,
+)
+
+from pydantic import ConfigDict, GetCoreSchemaHandler, GetJsonSchemaHandler, TypeAdapter
+from pydantic.config import ExtraValues
+from pydantic.fields import FieldInfo
+from pydantic.json_schema import (
+    DEFAULT_REF_TEMPLATE,
+    GenerateJsonSchema,
+    JsonSchemaMode,
+    JsonSchemaValue,
+)
+from pydantic.main import IncEx
+from pydantic_core import CoreSchema, core_schema
+
+from .io_utils import JSONDict, write_json
+
+T = TypeVar("T")
+K_ = TypeVar("K_", bound=Hashable)
+V_ = TypeVar("V_")
+Mode = Literal["json", "python"] | str
+
+
+VALID_MODES: set[Literal["json", "python"]] = {"json", "python"}
+
+
+# TODO: next step: create BaseList (BaseModelList?)
+# FoodPlanRaw, Entries, WeightSessionPlan, WorkoutPlanRaw, Partition
+
+
+class AbstractCustom(ABC):
+    model_config: ConfigDict = ConfigDict()
+    __pydantic_core_schema__: CoreSchema
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: GetCoreSchemaHandler
+    ) -> CoreSchema:
+        return core_schema.no_info_after_validator_function(
+            cls.model_validate,
+            core_schema.dict_schema(),
+        )
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+        cls,
+        core_schema: CoreSchema,
+        handler: GetJsonSchemaHandler,
+    ) -> JsonSchemaValue:
+        json_schema = handler(core_schema)
+        json_schema = handler.resolve_ref_schema(json_schema)
+        return json_schema
+
+    @abstractmethod
+    def __init__(self, *args, **kwargs) -> None:
+        TypeError(f"Use `model_validate` to instantiate {self.__class__.__name__}")
+
+    # @abstractmethod
+    # def __init__(**data: Any) -> None: ...
+
+    @classmethod
+    @abstractmethod
+    def get_adapter(cls) -> TypeAdapter: ...
+
+    @abstractmethod
+    def __repr__(self) -> str: ...
+
+    @abstractmethod
+    def __str__(self) -> str: ...
+
+    @classmethod
+    def model_fields(cls) -> dict[str, FieldInfo]:
+        return {}
+
+    @property
+    def model_extra(self) -> dict[str, Any] | None:
+        return None
+
+    @property
+    def model_fields_set(self) -> set[str]:
+        return set()
+
+    @classmethod
+    @abstractmethod
+    def model_construct(cls, _fields_set: set[str] | None = None, **values: Any) -> Self: ...
+
+    @abstractmethod
+    def model_copy(
+        self, *, update: Mapping[str, Any] | None = None, deep: bool = False
+    ) -> Self: ...
+
+    def model_dump(
+        self,
+        *,
+        mode: Literal["json", "python"] | str = "python",
+        include: IncEx | None = None,
+        exclude: IncEx | None = None,
+        context: Any | None = None,
+        by_alias: bool | None = None,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        exclude_computed_fields: bool = False,
+        round_trip: bool = False,
+        warnings: (bool | Literal["none", "warn", "error"]) = True,
+        fallback: Callable[[Any], Any] | None = None,
+        serialize_as_any: bool = False,
+    ) -> dict[str, Any]:
+        if mode not in VALID_MODES:
+            raise ValueError
+        if exclude_computed_fields:
+            raise ValueError
+
+        return self.get_adapter().dump_python(
+            self.pre_dump_hook(mode=mode),
+            mode=mode,
+            include=include,
+            exclude=exclude,
+            context=context,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            round_trip=round_trip,
+            warnings=warnings,
+            fallback=fallback,
+            serialize_as_any=serialize_as_any,
+        )
+
+    def model_dump_json(
+        self,
+        *,
+        indent: int | None = None,
+        ensure_ascii: bool = False,
+        include: IncEx | None = None,
+        exclude: IncEx | None = None,
+        context: Any | None = None,
+        by_alias: bool | None = None,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        exclude_computed_fields: bool = False,
+        round_trip: bool = False,
+        warnings: (bool | Literal["none", "warn", "error"]) = True,
+        fallback: Callable[[Any], Any] | None = None,
+        serialize_as_any: bool = False,
+    ) -> str:
+        if ensure_ascii or exclude_computed_fields:
+            raise ValueError
+        from_hook = self.pre_dump_hook(mode="json")
+        return (
+            self.get_adapter()
+            .dump_json(
+                from_hook,
+                indent=indent,
+                include=include,
+                exclude=exclude,
+                context=context,
+                by_alias=by_alias,
+                exclude_unset=exclude_unset,
+                exclude_defaults=exclude_defaults,
+                exclude_none=exclude_none,
+                round_trip=round_trip,
+                warnings=warnings,
+                fallback=fallback,
+                serialize_as_any=serialize_as_any,
+            )
+            .decode("utf-8")
+        )
+
+    @classmethod
+    def model_json_schema(
+        cls,
+        by_alias: bool = True,
+        ref_template: str = DEFAULT_REF_TEMPLATE,
+        schema_generator: type[GenerateJsonSchema] = GenerateJsonSchema,
+        mode: JsonSchemaMode = "validation",
+        *,
+        union_format: Literal["any_of", "primitive_type_array"] = "any_of",
+    ) -> dict[str, Any]:
+        return cls.get_adapter().json_schema(
+            by_alias=by_alias,
+            ref_template=ref_template,
+            schema_generator=schema_generator,
+            mode=mode,
+        )
+
+    @classmethod
+    def model_parametrized_name(cls, params: tuple[type[Any], ...]) -> str:
+        raise NotImplementedError
+
+    @classmethod
+    def model_validate(
+        cls,
+        obj: Any,
+        *,
+        strict: bool | None = None,
+        extra: ExtraValues | None = None,
+        from_attributes: bool | None = None,
+        context: Any | None = None,
+        by_alias: bool | None = None,
+        by_name: bool | None = None,
+    ) -> Self:
+        if extra:
+            raise ValueError
+        adapter = cls.get_adapter()
+        obj = cls.pre_validation_hook_python(obj)
+        obj = adapter.validate_python(
+            obj,
+            strict=strict,
+            from_attributes=from_attributes,
+            context=context,
+            by_alias=by_alias,
+            by_name=by_name,
+        )
+        validated = cls(obj)
+        return cls.post_validation_hook(validated)
+
+    @classmethod
+    def model_validate_json(
+        cls,
+        json_data: str | bytes | bytearray,
+        *,
+        strict: bool | None = None,
+        extra: ExtraValues | None = None,
+        context: Any | None = None,
+        by_alias: bool | None = None,
+        by_name: bool | None = None,
+    ) -> Self:
+        if extra:
+            raise ValueError
+        adapter = cls.get_adapter()
+        json_string = cls.pre_validation_hook_json(json_data)
+        raw_validated = adapter.validate_json(
+            json_string,
+            strict=strict,
+            context=context,
+            by_alias=by_alias,
+            by_name=by_name,
+        )
+        validated = cls(raw_validated)
+        return cls.post_validation_hook(validated)
+
+    @classmethod
+    @abstractmethod
+    def model_validate_strings(
+        cls,
+        obj: Any,
+        *,
+        strict: bool | None = None,
+        extra: ExtraValues | None = None,
+        context: Any | None = None,
+        by_alias: bool | None = None,
+        by_name: bool | None = None,
+    ) -> Self: ...
+
+    @property
+    def __annotations__(self) -> dict[str, Any]:  # type: ignore
+        return self.get_adapter().__annotations__
+
+    @classmethod
+    def read(cls, read_path: Path) -> Self:
+        return cls.model_validate_json(read_path.read_text())
+
+    def write(self, write_path: Path) -> None:
+        write_json(cast(JSONDict, self.model_dump(mode="json")), write_path)
+
+    @staticmethod
+    def pre_validation_hook_python(python_dict: dict) -> dict:
+        return python_dict
+
+    @staticmethod
+    def pre_validation_hook_json(json_string: str | bytes | bytearray) -> str | bytes | bytearray:
+        return json_string
+
+    @staticmethod
+    def post_validation_hook(validated: T) -> T:
+        return validated
+
+    def pre_dump_hook(self, *, mode: Mode) -> Self:
+        if mode not in VALID_MODES:
+            raise ValueError
+        return self
+
+    def post_dump_hook(self, dumped: T, *, mode: Mode) -> T:
+        return dumped
+
+    def schema(self) -> CoreSchema:
+        return self.get_adapter().core_schema
+
+    def schema_json(self) -> str:
+        return json.dumps(self.model_json_schema())
+
+
+class BaseDict[K, V](dict[K, V], AbstractCustom):
+    """
+    Dictionary type leveraging pydantic for validation and JSON serialization.
+    """
+
+    @classmethod
+    def get_adapter(cls) -> TypeAdapter[dict[K, V]]:
+        """Return a TypeAdapter for this subclass, preserving its key/value types."""
+        for base in getattr(cls, "__orig_bases__", []):
+            if isinstance(base, GenericAlias):
+                key_type, val_type = get_args(base)
+                return TypeAdapter(dict[key_type, val_type])  # type: ignore[valid-type]
+        raise TypeError("Key and value types not found.")
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}{dict.__repr__(self)}"
+
+    def __str__(self) -> str:
+        raise NotImplementedError
+
+
+class BaseList[T](list[T], AbstractCustom):
+    """
+    Dictionary type leveraging pydantic for validation and JSON serialization.
+    """
+
+    @classmethod
+    def get_adapter(cls) -> TypeAdapter[list[T]]:
+        """Return a TypeAdapter for this subclass, preserving its key/value types."""
+        for base in getattr(cls, "__orig_bases__", []):
+            if isinstance(base, GenericAlias):
+                element_type = get_args(base)[0]
+                return TypeAdapter(list[element_type])  # type: ignore[valid-type]
+        raise TypeError("Key and value types not found.")
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}{list.__repr__(self)}"
+
+    def __str__(self) -> str:
+        raise NotImplementedError
+
+
+class BaseSet[T](set[T], AbstractCustom):
+    """
+    Dictionary type leveraging pydantic for validation and JSON serialization.
+
+    TODO: make dump as list if not all members hashable.
+    """
+
+    @classmethod
+    def get_adapter(cls) -> TypeAdapter[set[T]]:
+        """Return a TypeAdapter for this subclass, preserving its key/value types."""
+        for base in getattr(cls, "__orig_bases__", []):
+            if isinstance(base, GenericAlias):
+                element_type = get_args(base)[0]
+                return TypeAdapter(set[element_type])  # type: ignore[valid-type]
+        raise TypeError("Key and value types not found.")
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}{set.__repr__(self)}"
+
+    def __str__(self) -> str:
+        raise NotImplementedError
+
+    def model_dump(
+        self,
+        *,
+        mode: Literal["json", "python"] | str = "python",
+        include: IncEx | None = None,
+        exclude: IncEx | None = None,
+        context: Any | None = None,
+        by_alias: bool | None = None,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        exclude_computed_fields: bool = False,
+        round_trip: bool = False,
+        warnings: (bool | Literal["none", "warn", "error"]) = True,
+        fallback: Callable[[Any], Any] | None = None,
+        serialize_as_any: bool = False,
+    ) -> dict[str, Any]:
+        if mode not in VALID_MODES:
+            raise ValueError
+        if exclude_computed_fields:
+            raise ValueError
+
+        return BaseList.model_validate(self).model_dump(
+            mode=mode,
+            include=include,
+            exclude=exclude,
+            context=context,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            round_trip=round_trip,
+            warnings=warnings,
+            fallback=fallback,
+            serialize_as_any=serialize_as_any,
+        )

adiumentum/{string.py → string_utils.py}

@@ -1,19 +1,40 @@
 import json
 import re
 from collections.abc import Callable, Iterable
-from typing import Literal, TypeAlias, cast
-
-from datethyme import Date, Time
+from typing import Literal, Protocol, Self, TypeAlias, cast
 
 from .functional import lmap
+from .typing_utils import JSONDict, areinstances
+
+class DateProtocol(Protocol):
+    year: int
+    month: int
+    day: int
+
+    @classmethod
+    def parse(cls, date_string: str) -> Self: ...
+
+    def __str__(self) -> str: ...
+
+
+class TimeProtocol(Protocol):
+    hour: int
+    minute: int
+    second: float
+
+    @classmethod
+    def parse(cls, time_string: str) -> Self: ...
+
+    def __str__(self) -> str: ...
+
 
 MixedValidated: TypeAlias = (
     str
     | bool
     | int
     | float
-    | Time
-    | Date
+    | TimeProtocol
+    | DateProtocol
     | tuple[str, ...]
     | tuple[str, str]
     | tuple[float, float]
@@ -75,7 +96,7 @@ def parse_sequence(s: str) -> list[str]:
             start, end = start[1:], end[1:]
             return [f"{letter}{i}" for i in range(int(start), int(end) + 1, step)]
 
-    segments = []
+    segments: list[str] = []
     for subseq in s.strip().split(","):
         segments.extend(interpolate(subseq))
     return segments
@@ -134,10 +155,10 @@ def cast_to_negative_score(s: str | bool) -> float:
     return score
 
 
-def cast_to_Date(s: str | bool) -> Date:
+def cast_to_date(s: str | bool, date_class: type[DateProtocol]) -> DateProtocol:
     if isinstance(s, bool):
         raise TypeError
-    return Date.model_validate(s)
+    return date_class.parse(s)
 
 
 def cast_to_stringtuple(s: str | bool) -> tuple[str, ...]:
@@ -159,10 +180,10 @@ def cast_as(
         "integer": cast_to_int,
         "float": cast_to_float,
         "minutes": cast_to_minutes,
-        "time": Time.model_validate,
+        # "time": Time.model_validate, TODO: add later via injection
         "positiveScore": cast_to_positive_score,
         "negativeScore": cast_to_negative_score,
-        "date": cast_to_Date,
+        # "date": cast_to_date, TODO: add later via injection
         "stringtuple": cast_to_stringtuple,
     }
     caster = dispatch[input_type]
@@ -175,5 +196,12 @@ def cast_as(
     return type_specific_caster
 
 
-def as_json(d: dict) -> str:
+def as_json(d: JSONDict) -> str:
     return json.dumps(d, ensure_ascii=False, indent=4)
+
+
+def re_split(expr: str | re.Pattern[str], s: str) -> list[str]:
+    segments = re.split(expr, s)
+    if not areinstances(segments, str):
+        raise TypeError("Function 're_split' may only return a list of strings.")
+    return segments

adiumentum/typing_utils.py

@@ -1,13 +1,22 @@
+import re
+from abc import ABC, abstractmethod
 from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+from pathlib import Path
 from types import UnionType
-from typing import TypeVar
+from typing import Annotated, Any, Protocol, Self, TypeVar, Union
 
 T = TypeVar("T")
 
+
+type Atomic = int | float | str | bool | None
 ClassInfo = type | UnionType | tuple["ClassInfo"]
+JSONPrimitive = int | float | str | None
+JSONDict = dict[str, Union[JSONPrimitive, "JSONDict", list[Union["JSONDict | JSONPrimitive"]]]]
+JSONList = list[JSONPrimitive | JSONDict]
 
 
-def areinstances(iterable_instance: Iterable, class_or_tuple: ClassInfo) -> bool:
+def areinstances(iterable_instance: Iterable[Any], class_or_tuple: ClassInfo) -> bool:
     return all(map(lambda inst: isinstance(inst, class_or_tuple), iterable_instance))
 
 
@@ -17,3 +26,107 @@ def fallback_if_none(orig: T | None, alt: T) -> T:
 
 def call_fallback_if_none(orig: T | None, alt: Callable[[], T]) -> T:
     return alt() if (orig is None) else orig
+
+
+class SupportsGe(Protocol):
+    def __ge__(self: T, __other: T) -> bool: ...
+
+
+class SupportsGt(Protocol):
+    def __gt__(self: T, __other: T) -> bool: ...
+
+
+class SupportsLe(Protocol):
+    def __le__(self: T, __other: T) -> bool: ...
+
+
+class SupportsLt(Protocol):
+    def __lt__(self: T, __other: T) -> bool: ...
+
+
+@dataclass(frozen=True)
+class _BaseMetadata:
+    """Base class for all metadata.
+
+    This exists mainly so that implementers
+    can do `isinstance(..., BaseMetadata)` while traversing field annotations.
+    """
+
+    __slots__ = ()
+
+
+@dataclass(frozen=True)
+class Ge(_BaseMetadata):
+    """Ge(ge=x) implies that the value must be greater than or equal to x.
+
+    It can be used with any type that supports the ``>=`` operator,
+    including numbers, dates and times, strings, sets, and so on.
+    """
+
+    ge: SupportsGe
+
+
+@dataclass(frozen=True)
+class Gt(_BaseMetadata):
+    """Gt(gt=x) implies that the value must be greater than x.
+
+    It can be used with any type that supports the ``>`` operator,
+    including numbers, dates and times, strings, sets, and so on.
+    """
+
+    gt: SupportsGt
+
+
+@dataclass(frozen=True)
+class Lt(_BaseMetadata):
+    """Lt(lt=x) implies that the value must be less than x.
+
+    It can be used with any type that supports the ``<`` operator,
+    including numbers, dates and times, strings, sets, and so on.
+    """
+
+    lt: SupportsLt
+
+
+@dataclass(frozen=True)
+class Le(_BaseMetadata):
+    """Le(le=x) implies that the value must be less than x.
+
+    It can be used with any type that supports the ``<=`` operator,
+    including numbers, dates and times, strings, sets, and so on.
+    """
+
+    le: SupportsLe
+
+
+class SupportsIO(ABC):
+    @classmethod
+    @abstractmethod
+    def read(cls, read_path: Path) -> Self: ...
+
+    @abstractmethod
+    def write(self, write_path: Path) -> None: ...
+
+
+class Pattern:
+    DATE: re.Pattern[str] = re.compile(r"^[12]\d\d\d-(0?\d|1[012]|)-(0?\d|[12]\d|3[01])$")
+    DATE_STRICT: re.Pattern[str] = re.compile(r"^[12]\d\d\d-(0\d|1[012]|)-(0\d|[12]\d|3[01])$")
+    DATE_LOOSE: re.Pattern[str] = re.compile(r"(\d{2,4})[^\d](\d\d?)[^\d](\d\d?)")
+    ID: re.Pattern[str] = re.compile(r"^[A-Za-z][A-Za-z0-9_]+$")
+    ID_OR_2IDS: re.Pattern[str] = re.compile(r"^[A-Za-z][A-Za-z0-9_]+,[A-Za-z][A-Za-z0-9_]+$")
+    NATURAL: re.Pattern[str] = re.compile(r"^[1-9][0-9]*$")
+    PROPORTION: re.Pattern[str] = re.compile(r"^0?\.[0-9]+$")
+    PROPORTION_OR_2: re.Pattern[str] = re.compile(r"^0?\.[0-9]+$|^0?\.[0-9]+,0?\.[0-9]+$")
+
+
+TimeAmountRaw = str | int
+
+Natural = Annotated[int, Ge(ge=0)]
+Nonnegative = Annotated[float, Ge(ge=0)]
+Positive = Annotated[float, Gt(gt=0)]
+PositiveScore = Annotated[float, Gt(gt=0.0), Lt(lt=5.0)]
+NegativeScore = Annotated[float, Gt(gt=-5.0), Lt(lt=0.0)]
+Proportion = Annotated[float, Ge(ge=0.0), Le(le=1.0)]
+NonnegativeInt = Annotated[int, Ge(ge=0)]
+NonnegativeFloat = Annotated[float, Ge(ge=0.0)]
+PolarityScore = Annotated[float, Ge(ge=-1.0), Le(le=1.0)]

adiumentum-0.3.1.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.3
+Name: adiumentum
+Version: 0.3.1
+Summary: 
+Author: Isaac Riley
+Author-email: Isaac Riley <yelircaasi@proton.me>
+Requires-Dist: pydantic>=2.11
+Requires-Dist: multipledispatch>=1
+Requires-Dist: loguru>=0.7.3
+Requires-Python: >=3.11, <3.15
+Description-Content-Type: text/markdown
+
+# adiumentum
+
+
+With Nix installed, you can enter a development environment with all dependencies installed:
+
+```sh
+nix develop
+```
+
+Once in this dev shell, you have a number of development utils you can try out (via just):
+
+```sh
+✔just
+✔just format
+✔just check
+✔just fix
+✔just typecheck
+✔just lint
+✔just deal
+✔just vulture
+✔just pydeps-full
+✔just pydeps
+✔just pydeps-simple
+✔just view-deps
+✔just snakefood
+✔just deply
+✔just bandit
+✔just bandit-html
+✔just bandit-view
+✔just pyflame
+✔just flamegraph
+✔just perf-flamegraph
+✔just check-structure
+✔just check-imports
+✔just smoke
+✔just unit
+✔just test
+✔just test-cov
+✔just docs
+✔just scalene
+✔just view-cov
+✔just view-docs
+✔just view-flamegraphs
+✔just sbom
+
+lefthook validate
+lefthook run all
+```