adiumentum 0.1.0__py3-none-any.whl

adiumentum/__init__.py

@@ -0,0 +1,116 @@
+from .color import Colorizer
+from .comparison import equal_within, nearly_equal
+from .exceptions import CustomValidationError
+from .file_modification_time import (
+    first_newer,
+    get_time_created,
+    get_time_modified,
+    time_created_readable,
+    time_modified_readable,
+)
+from .frozendict import FrozenDefaultDict
+from .functional import (
+    dmap,
+    fold_dictionaries,
+    identity,
+    kmap,
+    lmap,
+    smap,
+    tmap,
+    vmap,
+)
+from .io import (
+    list_full,
+    read_json,
+    read_raw,
+    write_json,
+    write_raw,
+    write_raw_bytes,
+)
+from .markers import (
+    helper,
+    impure,
+    mutates,
+    mutates_and_returns_instance,
+    mutates_instance,
+    pure,
+    refactor,
+    step_data,
+    step_transition,
+    validator,
+)
+from .numerical import evenly_spaced, ihash, round5
+from .performance_logging import log_perf
+from .string import (
+    MixedValidated,
+    PromptTypeName,
+    as_json,
+    cast_as,
+    flexsplit,
+    indent_lines,
+    parse_sequence,
+)
+from .timestamping import insert_timestamp
+from .typing_utils import (
+    areinstances,
+    call_fallback_if_none,
+    fallback_if_none,
+)
+
+DELIMITER = "᜶"
+
+__all__ = [
+    "DELIMITER",
+    "Colorizer",
+    "CustomValidationError",
+    "FrozenDefaultDict",
+    "MixedValidated",
+    "NoneDate",
+    "NoneTime",
+    "PromptTypeName",
+    "areinstances",
+    "args_to_dict",
+    "as_json",
+    "call_fallback_if_none",
+    "cast_as",
+    "dmap",
+    "equal_within",
+    "evenly_spaced",
+    "fallback_if_none",
+    "first_newer",
+    "flexsplit",
+    "fold_dictionaries",
+    "get_time_created",
+    "get_time_modified",
+    "helper",
+    "identity",
+    "ihash",
+    "impure",
+    "indent_lines",
+    "insert_timestamp",
+    "kmap",
+    "list_full",
+    "lmap",
+    "log_perf",
+    "mutates",
+    "mutates_and_returns_instance",
+    "mutates_instance",
+    "nearly_equal",
+    "parse_sequence",
+    "pure",
+    "read_json",
+    "read_raw",
+    "refactor",
+    "round5",
+    "smap",
+    "step_data",
+    "step_transition",
+    "time_created_readable",
+    "time_modified_readable",
+    "tmap",
+    "validator",
+    "vmap",
+    "write_json",
+    "write_raw",
+    "write_raw_bytes",
+]

adiumentum/color.py

@@ -0,0 +1,56 @@
+class Colorizer:
+    def __init__(self, use_colors: bool = True) -> None:
+        if use_colors:
+            self.BLACK = "\u001b[30m"
+            self.RED = "\u001b[31m"
+            self.GREEN = "\u001b[32m"
+            self.YELLOW = "\u001b[33m"
+            self.BLUE = "\u001b[34m"
+            self.MAGENTA = "\u001b[35m"
+            self.CYAN = "\u001b[36m"
+            self.WHITE = "\u001b[37m"
+            self.RESET = "\u001b[0m"
+        else:
+            self.BLACK = ""
+            self.RED = ""
+            self.GREEN = ""
+            self.YELLOW = ""
+            self.BLUE = ""
+            self.MAGENTA = ""
+            self.CYAN = ""
+            self.WHITE = ""
+            self.RESET = ""
+
+    @staticmethod
+    def strip(s: str) -> str:
+        return s[5:-4] if s.startswith("\u001b") else s
+
+    def length(self, s: str) -> int:
+        return len(self.strip(s))
+
+    def black(self, text: str) -> str:
+        return self._format(text, self.BLACK)
+
+    def red(self, text: str) -> str:
+        return self._format(text, self.RED)
+
+    def green(self, text: str) -> str:
+        return self._format(text, self.GREEN)
+
+    def yellow(self, text: str) -> str:
+        return self._format(text, self.YELLOW)
+
+    def blue(self, text: str) -> str:
+        return self._format(text, self.BLUE)
+
+    def magenta(self, text: str) -> str:
+        return self._format(text, self.MAGENTA)
+
+    def cyan(self, text: str) -> str:
+        return self._format(text, self.CYAN)
+
+    def white(self, text: str) -> str:
+        return self._format(text, self.WHITE)
+
+    def _format(self, text: str, color_code: str) -> str:
+        return f"{color_code}{text}{self.RESET}"

adiumentum/comparison.py

@@ -0,0 +1,6 @@
+def nearly_equal(a: int | float, b: int | float) -> bool:
+    return abs(a - b) < 0.00001
+
+
+def equal_within(a: int | float, b: int | float, epsilon: float | int) -> bool:
+    return abs(a - b) < epsilon

adiumentum/converters.py

@@ -0,0 +1,4 @@
+def ics_to_json(): ...
+
+
+def json_to_ics(): ...

adiumentum/exceptions.py

@@ -0,0 +1,2 @@
+class CustomValidationError(TypeError):
+    pass

adiumentum/file_modification_time.py

@@ -0,0 +1,31 @@
+import os
+import time
+from pathlib import Path
+
+
+def get_time_created(path: Path | str) -> float:
+    return os.path.getctime(path)
+
+
+def time_created_readable(path: Path | str) -> str:
+    time_created: time.struct_time = time.strptime(time.ctime(get_time_created(path)))
+    return time.strftime("%Y-%m-%d %H:%M:%S", time_created)
+
+
+def get_time_modified(path: Path | str) -> float:
+    return os.path.getmtime(path)
+
+
+def time_modified_readable(path: Path | str) -> str:
+    time_modified: time.struct_time = time.strptime(time.ctime(get_time_modified(path)))
+    return time.strftime("%Y-%m-%d %H:%M:%S", time_modified)
+
+
+def first_newer(file1: str | Path, file2: str | Path | tuple[Path, ...] | tuple[str, ...]) -> bool:
+    m1 = os.path.getmtime(file1)
+
+    if isinstance(file2, tuple):
+        m2 = max(os.path.getmtime(f) for f in file2)
+    else:
+        m2 = os.path.getmtime(file2)
+    return m1 > m2

adiumentum/frozendict.py

@@ -0,0 +1,27 @@
+from collections import defaultdict
+from collections.abc import Callable
+from typing import Generic, TypeVar, cast
+
+T = TypeVar("T")
+K = TypeVar("K")
+
+
+class FrozenDefaultDict(defaultdict[K, T], Generic[K, T]):
+    def __init__(self, default_factory: Callable[[], T], dictionary: dict[K, T]):
+        super().__init__(default_factory, dictionary)
+
+    def __repr__(self) -> str:
+        default = self.default_factory
+        result = default.__name__ if callable(default) else repr(default)
+        return f"{self.__class__.__name__}({dict(self)}, default={result})"
+
+    def __getitem__(self, key: K) -> T:
+        if key in self:
+            return super().__getitem__(key)
+        return cast(Callable, self.default_factory)()
+
+    def __setitem__(self, key: K, value: T) -> None:
+        raise TypeError(f"{self.__class__.__name__} is immutable")
+
+    def __delitem__(self, key) -> None:
+        raise TypeError(f"{self.__class__.__name__} is immutable")

adiumentum/functional.py

@@ -0,0 +1,44 @@
+from collections.abc import Callable, Iterable
+from functools import reduce
+from typing import TypeVar
+
+T = TypeVar("T")
+TPost = TypeVar("TPost")
+TPre = TypeVar("TPre")
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+def lmap(callable_: Callable[[TPre], TPost], iterable: Iterable[TPre]) -> list[TPost]:
+    return list(map(callable_, iterable))
+
+
+def smap(callable_: Callable[[TPre], TPost], iterable: Iterable[TPre]) -> set[TPost]:
+    return set(map(callable_, iterable))
+
+
+def tmap(callable_: Callable[[TPre], TPost], iterable: Iterable[TPre]) -> tuple[TPost, ...]:
+    return tuple(map(callable_, iterable))
+
+
+def vmap(callable_: Callable[[TPre], TPost], dictionary: dict[K, TPre]) -> dict[K, TPost]:
+    return {k: callable_(v) for k, v in dictionary.items()}
+
+
+def kmap(callable_: Callable[[TPre], TPost], dictionary: dict[TPre, V]) -> dict[TPost, V]:
+    return {callable_(k): v for k, v in dictionary.items()}
+
+
+def dmap(callable_: Callable[[TPre], TPost], dictionary: dict[TPre, TPre]) -> dict[TPost, TPost]:
+    return {callable_(k): callable_(v) for k, v in dictionary.items()}
+
+
+def identity(x: T) -> T:
+    return x
+
+
+def fold_dictionaries(dicts: Iterable[dict[K, T]]) -> dict[K, T]:
+    def _or(dict1: dict[K, T], dict2: dict[K, T]) -> dict[K, T]:
+        return dict1 | dict2
+
+    return reduce(_or, dicts)

adiumentum/io.py

@@ -0,0 +1,33 @@
+import json
+import os
+from pathlib import Path
+
+
+def list_full(directory: str | Path, ending: str = "") -> list[Path]:
+    directory = Path(directory)
+    return sorted([directory / file for file in os.listdir(directory) if file.endswith(ending)])
+
+
+def read_raw(json_path: Path) -> str:
+    with open(json_path, encoding="utf-8") as f:
+        return f.read()
+
+
+def read_json(json_path: Path) -> dict | list:
+    with open(json_path, encoding="utf-8") as f:
+        return json.load(f)
+
+
+def write_json(python_obj: dict | list | bytes, json_path: Path) -> None:
+    with open(json_path, "w", encoding="utf-8") as f:
+        json.dump(python_obj, f, indent=4, ensure_ascii=False)
+
+
+def write_raw(text: str, file_path: Path) -> None:
+    with open(file_path, "w", encoding="utf-8") as f:
+        f.write(text)
+
+
+def write_raw_bytes(text: bytes, json_path: Path) -> None:
+    with open(json_path, "wb") as f:
+        f.write(text)

adiumentum/markers.py

@@ -0,0 +1,117 @@
+from collections.abc import Callable
+from functools import wraps
+
+from .functional import identity
+
+
+def impure(callable_or_none: Callable | None = None, **kwargs) -> Callable:
+    if callable_or_none is None:
+        return identity
+    else:
+        return callable_or_none
+
+
+def pure(callable_or_none: Callable | None = None, **kwargs) -> Callable:
+    if callable_or_none is None:
+        return identity
+    else:
+        return callable_or_none
+
+
+def helper(callable_or_none: Callable | None = None, **kwargs) -> Callable:
+    if callable_or_none is None:
+        return identity
+    else:
+        return callable_or_none
+
+
+def step_data(func: Callable) -> Callable:
+    @wraps(func)
+    def wrapper(*fargs, **fkwargs):
+        return func(*fargs, **fkwargs)
+
+    return wrapper
+
+
+def step_transition(func: Callable) -> Callable:
+    @wraps(func)
+    def wrapper(*fargs, **fkwargs):
+        return func(*fargs, **fkwargs)
+
+    return wrapper
+
+
+def validator(func: Callable) -> Callable:
+    @wraps(func)
+    def wrapper(*fargs, **fkwargs):
+        return func(*fargs, **fkwargs)
+
+    return wrapper
+
+
+def mutates_instance(func: Callable) -> Callable:
+    @wraps(func)
+    def wrapper(*fargs, **fkwargs):
+        # print(
+        #     (
+        #         f"\u001b[31mMutating in place\u001b[0m:         "
+        #         f"\u001b[32m{type(fargs[0]).__name__:<25}\u001b[0m"
+        #         f" via \u001b[33m{func.__name__:<25}\u001b[0m"
+        #         f" in \u001b[34m{func.__module__}\u001b[0m"
+        #     )
+        # )
+        return func(*fargs, **fkwargs)
+
+    return wrapper
+
+
+def mutates_and_returns_instance(func: Callable) -> Callable:
+    @wraps(func)
+    def wrapper(*fargs, **fkwargs):
+        # print(
+        #     (
+        #         f"\u001b[31mMutating and returning\u001b[0m:    "
+        #         f"\u001b[32m{type(fargs[0]).__name__:<25}\u001b[0m"
+        #         f" via \u001b[33m{func.__name__:<25}\u001b[0m"
+        #         f" in \u001b[34m{func.__module__}\u001b[0m"
+        #     )
+        # )
+        return func(*fargs, **fkwargs)
+
+    return wrapper
+
+
+def mutates(*args, **kwargs) -> Callable:
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*fargs, **fkwargs):
+            print(
+                f"Mutating attributes \u001b[36m{', '.join(args):<50}\u001b[0m"
+                f" of \u001b[32m{type(fargs[0]).__name__:<25}\u001b[0m"
+                f" via \u001b[33m{func.__name__:<25}\u001b[0m"
+                f" in \u001b[34m{func.__module__.replace('consilium.', '.'):<40}\u001b[0m"
+            )
+
+            return func(*fargs, **fkwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def refactor(*args) -> Callable:
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*fargs, **fkwargs):
+            print(
+                f"\u001b[36mREFACTOR\u001b[0m"
+                f" \u001b[33m{func.__name__}\u001b[0m"
+                f" in \u001b[34m{func.__module__.replace('consilium.', '.')}\u001b[0m."
+                f" Notes: \u001b[32m{', '.join(args)}\u001b[0m"
+            )
+
+            return func(*fargs, **fkwargs)
+
+        return wrapper
+
+    return decorator

adiumentum/numerical.py

@@ -0,0 +1,28 @@
+def round5(num: int | float, min_val: int | float = 15) -> int:
+    """For numbers greater than min_val, round to the nearest multiple of 5."""
+    if num < min_val:
+        return round(num)
+    q, r = divmod(num, 5)
+    return int(5 * (q + int(r > 2)))
+
+
+def evenly_spaced(
+    start: float,
+    end: float,
+    steps: int,
+    reversed: bool = False,
+) -> list[float]:
+    if start > end:
+        start, end = end, start
+        reversed = True
+    start += 1e-7
+    end -= 1e-7
+    step_size = (end - start) / steps
+    numbers = [start + step_size * i for i in range(steps)]
+    if reversed:
+        numbers.reverse()
+    return numbers
+
+
+def ihash(i: int) -> str:
+    return str(hash(str(i)))[-4:]

adiumentum/performance_logging.py

@@ -0,0 +1,50 @@
+import json
+import os
+import time
+from collections.abc import Callable
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+DEFAULT_PATH = Path("codeqa/performance/perf_log/perf_log.jsonl")
+
+
+def get_callback_name(cb: Callable) -> str:
+    return getattr(cb, "__name__", None) or cb.__class__.__name__
+
+
+def log_perf(
+    callable_or_none: Callable | None = None,
+    *,
+    log_path: Path | Callable = DEFAULT_PATH,
+    extra_info: dict[str, Any] | None = None,
+) -> Callable:
+    def wrapper(_callback: Callable) -> Callable:
+        if not os.environ.get("LOG_PERFORMANCE"):
+            return _callback
+
+        def inner(*args, **kwargs):
+            start_time = time.time()
+            result = _callback(*args, **kwargs)
+            end_time = time.time()
+
+            log_info = (
+                {
+                    "name": get_callback_name(_callback),
+                    "timeElapsed": round(end_time - start_time, 4),
+                    "timestamp": datetime.now().isoformat(sep="_")[:-3],
+                    "file": _callback.__module__,
+                }
+                | (extra_info or {})
+                | {"args": str(args), "kwargs": str(kwargs)}
+            )
+            with log_path.open("a", encoding="utf-8") as f:
+                f.write(json.dumps(log_info) + "\n")
+
+            return result
+
+        return inner
+
+    if callable(callable_or_none):
+        return wrapper(callable_or_none)
+    return wrapper

adiumentum/string.py

@@ -0,0 +1,179 @@
+import json
+import re
+from collections.abc import Callable, Iterable
+from typing import Literal, TypeAlias, cast
+
+from datethyme import Date, Time
+
+from .functional import lmap
+
+MixedValidated: TypeAlias = (
+    str
+    | bool
+    | int
+    | float
+    | Time
+    | Date
+    | tuple[str, ...]
+    | tuple[str, str]
+    | tuple[float, float]
+    | None
+)
+PromptTypeName = Literal[
+    "string",
+    "boolean",
+    "integer",
+    "float",
+    "minutes",
+    "time",
+    "positiveScore",
+    "negativeScore",
+    "date",
+    "stringtuple",
+]
+
+
+def indent_lines(lines: Iterable[object], indent_size: int = 4) -> str:
+    joiner = "\n" + indent_size * " "
+    return joiner + joiner.join(map(str, lines))
+
+
+def flexsplit(s: str) -> list[str]:
+    return re.split(r", ?| ", s)
+
+
+def split_sequence_string(seq: str) -> tuple[str, str, int]:
+    _start: str | None
+    _end: str | None
+    _step: str | None
+    match seq.count(":"):
+        case 2:
+            _start, _end, _step = seq.split(":")
+        case 1:
+            _start, _end = seq.split(":")
+            _step = None
+        case 0:
+            _start, _end, _step = None, seq, None
+        case _:
+            raise ValueError
+    return (_start or "").upper(), (_end or "").upper(), int(_step or 1)
+
+
+def parse_sequence(s: str) -> list[str]:
+    def interpolate(_s: str) -> list[str]:
+        start, end, step = split_sequence_string(_s)
+        if end.isnumeric():
+            return lmap(str, range(int(start or 1), int(end) + 1, step))
+        elif end.isalpha():
+            start = start or "A"
+            assert len(start) == len(end) == 1
+            return lmap(chr, range(ord(start), ord(end) + 1, step))
+        else:
+            pattern = re.compile(r"[A-Z]\d+$")
+            letter = start[0]
+            assert re.match(pattern, start) and re.match(pattern, end) and (letter == end[0])
+            start, end = start[1:], end[1:]
+            return [f"{letter}{i}" for i in range(int(start), int(end) + 1, step)]
+
+    segments = []
+    for subseq in s.strip().split(","):
+        segments.extend(interpolate(subseq))
+    return segments
+
+
+def cast_to_bool(s: str | bool) -> bool:
+    if isinstance(s, bool):
+        return s
+    s = s.lower()
+    if s.startswith(("y", "t")):
+        return True
+    if s.startswith(("f", "n")):
+        return False
+    raise ValueError(f"Ambiguous input for 'cast_to_bool': '{s}'")
+
+
+def cast_to_int(s: str | bool) -> int:
+    if isinstance(s, bool):
+        return int(s)
+    return int(s.strip())
+
+
+def cast_to_float(s: str | bool) -> float:
+    if isinstance(s, bool):
+        return float(s)
+    return float(s.strip())
+
+
+def cast_to_minutes(s: str | bool) -> int:
+    if isinstance(s, bool):
+        raise TypeError
+    s = s.strip()
+    if ":" in s:
+        if s.count(":") > 1:
+            raise ValueError
+        hours, minutes = s.split(":")
+        return 60 * int(hours) + int(minutes)
+    return int(s)
+
+
+def cast_to_positive_score(s: str | bool) -> float:
+    if isinstance(s, bool):
+        raise TypeError
+    score = float(s.strip())
+    if not 0.0 <= score <= 5.0:
+        raise ValueError
+    return score
+
+
+def cast_to_negative_score(s: str | bool) -> float:
+    if isinstance(s, bool):
+        raise TypeError
+    score = float(s.strip())
+    if not -5.0 <= score <= 0.0:
+        raise ValueError
+    return score
+
+
+def cast_to_Date(s: str | bool) -> Date:
+    if isinstance(s, bool):
+        raise TypeError
+    return Date.model_validate(s)
+
+
+def cast_to_stringtuple(s: str | bool) -> tuple[str, ...]:
+    if isinstance(s, bool):
+        raise TypeError
+    if not s:
+        return tuple()
+    return cast(tuple[str, ...], tuple(re.split(r"[ ,;]+", s)))
+
+
+def cast_as(
+    input_type: PromptTypeName,
+) -> Callable[[str | bool], MixedValidated]:
+    dispatch: dict[
+        PromptTypeName,
+        Callable[[str | bool], MixedValidated],
+    ] = {
+        "boolean": cast_to_bool,
+        "integer": cast_to_int,
+        "float": cast_to_float,
+        "minutes": cast_to_minutes,
+        "time": Time.model_validate,
+        "positiveScore": cast_to_positive_score,
+        "negativeScore": cast_to_negative_score,
+        "date": cast_to_Date,
+        "stringtuple": cast_to_stringtuple,
+    }
+    caster = dispatch[input_type]
+
+    def type_specific_caster(s: str | bool) -> MixedValidated:
+        if str(s).lower() in {"none", "null", "skip", "pass"}:
+            return None
+        return caster(s)
+
+    return type_specific_caster
+
+
+def as_json(d: dict) -> str:
+    return json.dumps(d, ensure_ascii=False, indent=4)

adiumentum/timestamping.py

@@ -0,0 +1,12 @@
+from datetime import datetime
+from pathlib import Path
+
+
+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"{new_path}__{datetime.now():%Y-%m-%d_%H:%M:%S}")

adiumentum/typing_utils.py

@@ -0,0 +1,19 @@
+from collections.abc import Callable, Iterable
+from types import UnionType
+from typing import TypeVar
+
+T = TypeVar("T")
+
+ClassInfo = type | UnionType | tuple["ClassInfo"]
+
+
+def areinstances(iterable_instance: Iterable, class_or_tuple: ClassInfo) -> bool:
+    return all(map(lambda inst: isinstance(inst, class_or_tuple), iterable_instance))
+
+
+def fallback_if_none(orig: T | None, alt: T) -> T:
+    return alt if (orig is None) else orig
+
+
+def call_fallback_if_none(orig: T | None, alt: Callable[[], T]) -> T:
+    return alt() if (orig is None) else orig

adiumentum-0.1.0.dist-info/METADATA

@@ -0,0 +1,236 @@
+Metadata-Version: 2.3
+Name: adiumentum
+Version: 0.1.0
+Summary: 
+Author: Isaac Riley
+Author-email: Isaac Riley <yelircaasi@proton.me>
+Requires-Dist: multipledispatch>=1
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: datethyme>=0.4.0
+Requires-Python: >=3.12, <3.14
+Description-Content-Type: text/markdown
+
+# adiumentum
+
+Running this project requires `copier`, `git`, `uv`, and `flake`. Install `nix` and
+install the others by running `nix-shell -p uv python3 git`. You can now copy the project and run the toy CLI provided out-of-the-box:
+
+```sh
+copier copy --trust \
+    /home/isaac/repos/dev-envs/python-uv-nix /tmp/hello-world \
+    --data-file /home/isaac/repos/dev-envs/python-uv-nix/example-data-uv.yml
+
+nix run /tmp/hello-world
+```
+
+You can also 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
+```
+
+## Roadmap
+
+00. ✔ Sync package lists in uv.nix.jinja and README.md
+
+01. ✔ Parametrize each package for copier and update copier.yml
+
+02. ✔ Clean up copier.yml and example-data.yml
+
+03. ✔ Get impure environment working -> draw from buildFHSUserEnv approach in consilium and other projects
+
+04. ✔ Write working version of scripts and test them on datethyme
+
+05. ✔ create reference project (revised from datethyme)
+
+06. ✔ use copier to re-create it (make a datethyme answers file)
+
+08. ✔ find good CLI tools for diffing an entire folder
+
+09. ✔ iteratively modify template until copier perfectly re-creates the reference project
+
+10. ✔ package mdformat with mdformat-mkdocs (via nix)
+
+11. ✔ remove super-linter, but look over it and steal any good ideas
+
+12. ✔ add [commitizen](https://github.com/commitizen-tools/commitizen) and [commitmsgfmt](https://gitlab.com/mkjeldsen/commitmsgfmt) ✔
+
+13. ✔ Modify nix to support any python version via [nixpkgs-python](https://github.com/cachix/nixpkgs-python) and [tox](https://tox.wiki/en/4.27.0/index.html)
+
+14. ✔ Read through [jinja2-ansible-filters](https://gitlab.com/dreamer-labs/libraries/)
+
+15. Go through https://www.youtube.com/results?search_query=nix+and+python and any relevant NixCon talks
+
+16. ✔ restructure nix code
+
+17. ✔ add poetry support (selectable via copier)
+
+18. re-make datethyme package using template, iteratively polishing the template
+
+19. add copier switch to include a CLI or not
+
+### Later
+
+Note: first get working the way it is for datathyme.
+
+0. [conventional-changelog](https://github.com/conventional-changelog/conventional-changelog)
+
+1. Package all docs packages via nix, since they run independently of the other Python packages.
+
+2. Do the same for testing dependencies, if possible.
+
+3. Add different types of git hooks
+
+- Client-Side Hooks
+
+  - **Pre-commit hooks** run before a commit is created and are ideal for code quality checks. They're perfect for running linters, formatters, static analysis tools, or tests to catch issues before they enter the repository. If the hook exits with a non-zero status, the commit is aborted
+
+  - **Prepare-commit-msg hooks** execute after the default commit message is created but before the editor opens. These work well for automatically adding ticket numbers, branch names, or standardized formatting to commit messages based on branch patterns or other context
+
+  - **Commit-msg hooks** run after you've written your commit message and are excellent for enforcing commit message conventions. They can validate that messages follow specific formats, contain required information like issue references, or meet length requirements
+
+  - **Post-commit hooks** trigger after a commit completes successfully. Since they can't affect the commit outcome, they're useful for notifications, triggering builds, updating external systems, or logging commit information
+
+  - **Pre-rebase hooks** run before rebasing and help prevent rebasing published commits or branches that shouldn't be rebased. They're particularly valuable for protecting main branches or enforcing workflow policies
+
+  - **Post-checkout and post-merge hooks** execute after checking out branches or completing merges. These are ideal for environment setup tasks like updating dependencies, clearing caches, generating files, or syncing external resources that depend on the current branch state
+
+- Server-Side Hooks
+
+  - **Pre-receive hooks** run before any references are updated when receiving a push. They're powerful for enforcing repository-wide policies like preventing force pushes to protected branches, validating that all commits meet standards, or checking permissions before allowing updates
+
+  - **Update hooks** execute once per branch being updated and are perfect for branch-specific policies. They can enforce different rules for different branches, validate individual commits, or check that updates follow branching strategies
+
+  - **Post-receive hooks** run after all references are successfully updated and are ideal for deployment triggers, sending notifications, updating issue trackers, or kicking off CI/CD pipelines. Since they run after the push succeeds, they're commonly used for automation that depends on the repository being in its new state
+
+## Dependency Classes
+
+## Dependency Classes
+
+TODO: look at jj-fzf, lazyjj, gg-jj look at luxuries
+
+- dependency resolution (should already be installed)
+
+  - [uv](https://github.com/astral-sh/uv) ✔
+
+- miscellaneous (semver via Python)
+
+  - [semver](https://github.com/python-semver/python-semver) ✔
+
+- task running / hooks (installable via Python or Nix; Nix preferred)
+
+  - [just](https://just.systems/man/en/) ✔
+  - [lefthook](https://lefthook.dev/) ✔
+
+- interactive programming (installable via Python or Nix; Nix preferred)
+
+  - [ipython](https://ipython.org/) ✔
+
+- static type checking (installable via Python or Nix; Nix preferred)
+
+  - [mypy](https://mypy.readthedocs.io/en/stable/) ✔
+  - [ty](https://github.com/astral-sh/ty) ✔
+
+- source code visualization (graphviz and pydeps via Nix, the rest via Python)
+
+  - [pydeps](https://github.com/thebjorn/pydeps) ✔
+  - [graphviz](https://graphviz.org/) ✔
+  - [deply](https://vashkatsi.github.io/deply/) ✔
+  - [snakefood3](https://furius.ca/snakefood/) ✔
+  - [grimp](https://grimp.readthedocs.io/en/stable/usage.html) ✔
+
+- performance profiling (flamegraph and scalene via Nix, pyflame via Python)
+
+  - [pyflame](https://pyflame.readthedocs.io/en/latest/) ✔
+  - [scalene](https://github.com/plasma-umass/scalene) ✔
+  - [flamegraph-rs](https://github.com/flamegraph-rs/flamegraph)
+    (cargo-flamegraph in nix) ✔
+
+- software supply chain, security (installable via Python, but Nix preferred)
+
+  - [cyclonedx-python](https://github.com/CycloneDX/cyclonedx-python) ✔
+  - [bandit](https://bandit.readthedocs.io/en/latest/) ✔
+
+- testing (installed via Python for now)
+
+  - [pytest](https://docs.pytest.org/en/stable/) ✔
+  - pytest plugins: --> look at [these](https://github.com/man-group/pytest-plugins)
+    - [mock](https://pytest-mock.readthedocs.io/en/latest/) ✔
+    - [testmon](https://testmon.org/) ✔
+    - [cov](https://pytest-cov.readthedocs.io/en/latest/) ✔
+    - [loguru](https://github.com/mcarans/pytest-loguru) ✔
+    - [profiling](https://github.com/man-group/pytest-plugins/tree/master/pytest-profiling) [video](https://www.youtube.com/watch?v=OexWnUTsQGU) ✔
+  - [coverage](https://coverage.readthedocs.io/en/7.8.2/) ✔
+  - [hypothesis](https://hypothesis.readthedocs.io/en/latest/) ✔
+  - [tox](https://tox.wiki/en/4.26.0/) ✔
+
+- docs (installed via Python for now)
+
+  - [mkdocs](https://www.mkdocs.org/) ✔
+  - [mkdocstrings](https://mkdocstrings.github.io/) ✔
+  - [mkdocstrings-python](https://mkdocstrings.github.io/python/) ✔
+  - [mkdocs-material](https://squidfunk.github.io/mkdocs-material/) ✔
+  - [pygments](https://pygments.org/) ✔
+
+- formatters / linters
+
+  - installable via Python or Nix:
+    - [ruff](https://astral.sh/ruff) ✔
+    - [mdformat](https://github.com/hukkin/mdformat) + [mdformat-mkdocs](https://github.com/KyleKing/mdformat-mkdocs) TODO
+    - [yamlfmt](https://github.com/google/yamlfmt)
+      OR [yamllint](https://github.com/adrienverge/yamllint) ✔
+    - [pyprojectsort](https://github.com/kieran-ryan/pyprojectsort)
+    - [toml-sort](https://github.com/pappasam/toml-sort) ✔
+  - installable only via Nix or other package manager:
+    - [treefmt](https://treefmt.com/latest/) + [treefmt-nix](https://github.com/numtide/treefmt-nix) ✔
+    - [alejandra](https://github.com/kamadorueda/alejandra) ✔
+    - [super-linter](https://github.com/super-linter/super-linter) TODO
+    - [markdown-code-runner](https://github.com/drupol/markdown-code-runner)
+      OR [mdsf](https://github.com/hougesen/mdsf) ✔
+    - [markdownlint-cli2](https://github.com/DavidAnson/markdownlint-cli2)
+      OR [markdownlint-cli](https://github.com/DavidAnson/markdownlint-cli) TODO
+    - [just-formatter](https://github.com/eli-yip/just-formatter) ✔
+
+## To Look at for Later
+
+- [pystackflame](https://pypi.org/project/pystackflame/)

adiumentum-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+adiumentum/__init__.py,sha256=5bd4edf50fe42ca697d5de8a1188f6b78c346663b91ad2b23cb350f81e1e5f20,2180
+adiumentum/color.py,sha256=dfdebfecf0cdcf32794103fff75bb2e20dd0ae3514d1d051b1af95e6560f6790,1673
+adiumentum/comparison.py,sha256=5d3045dbe9364c52c88ae52be29a6739d280f2f1789fa7813ccda0c05f1e1bad,204
+adiumentum/converters.py,sha256=ae64583d622aa3f9e242fcba479ffb2fa5ec0bcbdf237e6bfc7f980f69914221,48
+adiumentum/elementary_types.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
+adiumentum/exceptions.py,sha256=b6851f704e236f8970998060317b68ead953f20e496b990ccd11eb740e5a01e3,49
+adiumentum/file_modification_time.py,sha256=0c36086590f6c2e9790d7ed144fc7f5eac93794f3a7dd9a61647b81ccf37fae9,912
+adiumentum/frozendict.py,sha256=1a7c8a1d8b8c1791040a30f2dfcbda820c6076f6b5a9e23719ec6ec13d7b9bee,960
+adiumentum/functional.py,sha256=58d3bbbd2085bcd20b97c0aba59af7ac8d4331836b328a843b2f97256d7e9182,1311
+adiumentum/io.py,sha256=8e00e9cb11d0d3bdd3d56b0ffbaecf0064d00866670a899426a59601a765eee8,929
+adiumentum/markers.py,sha256=be50f8f45ff885d92429370efc3409962cb03b6c9cbf5d462bf58ab226e26a1f,3198
+adiumentum/numerical.py,sha256=adad3335e7220c8bf9666ce8c79f01ca4f1a0933316bb8e6fbfc0440293fbbed,704
+adiumentum/performance_logging.py,sha256=bd0c42337fb5c77921700e5487d366ea103e8cd25825138962bfb44c1b54773b,1471
+adiumentum/string.py,sha256=bf43e7b023bdcf02b61004d093c93e69a69cf5e274f940c6086ff3c36df2d8f6,4557
+adiumentum/timestamping.py,sha256=6e7c6bd0e88c9e2cb68489687eb853476ba5a351db4ee2d6698f34113e3b5017,340
+adiumentum/typing_utils.py,sha256=36c90fb08da12c88aacce9c6b14d79e9da3db8aec5d52655179f6aaf676250b7,554
+adiumentum-0.1.0.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
+adiumentum-0.1.0.dist-info/METADATA,sha256=2a7b36433ead718b35bf50a2493f071d3643518e5bec67a964d6f65e16e6efd8,9669
+adiumentum-0.1.0.dist-info/RECORD,,

adiumentum-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.7.22
+Root-Is-Purelib: true
+Tag: py3-none-any