adiumentum 0.1.0__py3-none-any.whl → 0.3.0__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}

@@ -6,6 +6,7 @@ from typing import Literal, TypeAlias, cast
 from datethyme import Date, Time
 
 from .functional import lmap
+from .typing_utils import JSONDict, areinstances
 
 MixedValidated: TypeAlias = (
     str
@@ -75,7 +76,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
@@ -175,5 +176,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/timestamping.py

@@ -2,11 +2,19 @@ from datetime import datetime
 from pathlib import Path
 
 
+def make_timestamp(places: int = 3) -> str:
+    dt = datetime.now()
+    if places > 0:
+        idx: int | None = min(0, int(places) - 6) or None
+        return dt.strftime("%Y-%m-%d_%H:%M:%S.%f")[:idx]
+    return dt.strftime("%Y-%m-%d_%H:%M:%S")
+
+
 def insert_timestamp(p: Path | str) -> Path:
     new_path = str(p)
 
     if "." in new_path:
         base, suffix = new_path.rsplit(".", 1)
-        return Path(f"{base}__{datetime.now():%Y-%m-%d_%H:%M:%S}.{suffix}")
+        return Path(f"{base}__{make_timestamp()}.{suffix}")
 
-    return Path(f"{new_path}__{datetime.now():%Y-%m-%d_%H:%M:%S}")
+    return Path(f"{new_path}__{make_timestamp()}")

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.0.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.3
+Name: adiumentum
+Version: 0.3.0
+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-Dist: datethyme>=0.4.0
+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
+```

adiumentum-0.3.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+adiumentum/__init__.py,sha256=318b2af46bfbddaf6cd4b90b1a9d65e1023052a43a44323abbf704826e70426d,2611
+adiumentum/color.py,sha256=dfdebfecf0cdcf32794103fff75bb2e20dd0ae3514d1d051b1af95e6560f6790,1673
+adiumentum/comparison.py,sha256=5d3045dbe9364c52c88ae52be29a6739d280f2f1789fa7813ccda0c05f1e1bad,204
+adiumentum/converters.py,sha256=ae64583d622aa3f9e242fcba479ffb2fa5ec0bcbdf237e6bfc7f980f69914221,48
+adiumentum/dependency_sorting.py,sha256=0310f297b9b559ab02334d9d5becd1909433246d70f04c03b26b7b7afe7fa903,3291
+adiumentum/display.py,sha256=87528f2eacde427138c6ccfe41e5f1141ba34236553352e7159f7e9389d15ec6,1461
+adiumentum/elementary_types.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
+adiumentum/exceptions.py,sha256=b6851f704e236f8970998060317b68ead953f20e496b990ccd11eb740e5a01e3,49
+adiumentum/file_modification_time.py,sha256=898b8e8c794954ac9133b2c6959f4d6b142a11e98f01a3aab89efdf097e4d2e3,1236
+adiumentum/frozendict.py,sha256=b575059bd5fdaecb7b5f33f86e87342b31656b5526e0948a060adf1cf93dcb0c,942
+adiumentum/functional.py,sha256=82ac44991c02f946a0eb1b34506121c1f8978461085ad3e1958a23d0cc1643dc,2972
+adiumentum/io_utils.py,sha256=033110e6b9335ad4270cf62c86a0df53c5c43954521a814729f2f2b7edc5e7c2,2005
+adiumentum/markers.py,sha256=988f0b7ef80d61871165f30b601f05c9981cfd353c235eb314de5271e8040900,2959
+adiumentum/merge.py,sha256=b1894b08e906ead6f423dfb6d637df553eeed4f894c197f771f3569854044c32,3877
+adiumentum/numerical.py,sha256=adad3335e7220c8bf9666ce8c79f01ca4f1a0933316bb8e6fbfc0440293fbbed,704
+adiumentum/paths_manager.py,sha256=7098bf8bd71cbe93eb60eb8c145a3f02d3e3470c2f236e8bb579c08cf0db5579,403
+adiumentum/performance_logging.py,sha256=bd0c42337fb5c77921700e5487d366ea103e8cd25825138962bfb44c1b54773b,1471
+adiumentum/pydantic_extensions.md,sha256=6f5fe7fc9f10e0f6a87e2861dd16d066892099542dbaca3764944c6a27635706,24936
+adiumentum/pydantic_extensions.py,sha256=8e49c80f4be42b71986ec93195172af2d83986598de3f1bffe4c64505dc03729,12599
+adiumentum/string_utils.py,sha256=88b6389b2cb8ed9a3d65c5ea506ffe852cff480ac287ecdc399dec1e45095a58,4862
+adiumentum/timestamping.py,sha256=87729ac9dd7dac614fbb7bb1995e321bd860202a4c2f435e044f4af23dd545a0,556
+adiumentum/typing_utils.py,sha256=81e01e90a60fe397c5211493fb4446af5f59fbd4b364c98f377962f4bd67ff8b,3894
+adiumentum-0.3.0.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
+adiumentum-0.3.0.dist-info/entry_points.txt,sha256=8d158243687a1102f915d2091f19bdc1443ec58709954317c4edff9edb9e5be8,57
+adiumentum-0.3.0.dist-info/METADATA,sha256=9e6fb8f1c191d51f594457019bfc06043d6754b93ef6c7c1f82925d22eaeae2e,1136
+adiumentum-0.3.0.dist-info/RECORD,,

adiumentum-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+adiumentum = adiumentum.__main__:main
+