adiumentum 0.1.1__tar.gz → 0.3.1__tar.gz

adiumentum-0.3.1/PKG-INFO

@@ -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
+```

adiumentum-0.3.1/README.md

@@ -0,0 +1,48 @@
+# 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.1.1 → adiumentum-0.3.1}/pyproject.toml

@@ -1,16 +1,26 @@
 [project]
 name = "adiumentum"
-version = "0.1.1"
+version = "0.3.1"
 description = ""
 authors = [{name = "Isaac Riley", email = "yelircaasi@proton.me"}]
 readme = "README.md"
-requires-python = ">=3.12,<3.14"
+requires-python = ">=3.11,<3.15"
 dependencies = [
+    "pydantic         >= 2.11 ",
     "multipledispatch >= 1    ",
     "loguru           >= 0.7.3",
-    "datethyme        >= 0.4.0",
 ]
 
+[project.scripts]
+adiumentum = "adiumentum.__main__:main"
+
+[build-system]
+requires = ["uv_build>=0.7.5,<0.8.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "adiumentum"
+
 [dependency-groups]
 test = [
     "pytest           >= 8.3  ",
@@ -57,10 +67,6 @@ cli-utils = [
     "ty              >= 0.0.1a5",
 ]
 
-[build-system]
-requires = ["uv_build>=0.7.5,<0.8.0"]
-build-backend = "uv_build"
-
 [tool.bandit]
 targets = ["src/adiumentum", "codeqa/scripts/"]
 exclude_dirs = []
@@ -248,97 +254,61 @@ suppress-none-returning = true
 [tool.ruff.lint.pydocstyle]
 convention = "google"
 
-[tool.scripts.check_imports]
-primitive_modules = ["utils"]  # the utils module may not import from any other module in the project (external imports ok)
-external_allowed_everywhere = []
-internal_allowed_everywhere = []
-
-[tool.scripts.check_imports.disallowed.internal]  # for a given module, allow all internal imports except those explicitly named
-utils = ["utils"]  # don’t let the project’s root module import directly from the utils module
-
-[tool.scripts.check_imports.disallowed.external]  # for a given module, allow all internal imports except those explicitly named
-utils = ["pydantic"]  # don’t let the utils module import from pydantic
+[tool.structlint]
+root_dir = "."
+module_name = "consilium.notes"
+module_root_dir = "src/consilium/notes"
 
-[tool.scripts.check_imports.allowed.internal]  # for a given module, disallow all imports except those explicitly named and those allowed everywhere
-
-[tool.scripts.check_imports.allowed.external]  # for a given module, disallow all imports except those explicitly named and those allowed everywhere
-utils = ["deal"]
+[tool.structlint.docs]
+md_dir = "docs/md"
+allow_additional = "(?!)"
+ignore = "(?!)"
+order_ignore = "(?!)"
+file_per_directory = "(?!)"
+file_per_class = "(?!)"
+replace_double_underscore = false
 
-[tool.scripts.check_method_order]
-init = 0
-abstract_property = 0.0401
-property = 0.041
-abstract_private_property = 0.042
-private_property = 0.003
-abstract_dunder = 0.8
-abstract_classmethod = 0.81
-abstract_static = 0.82
-abstract = 0.9
-abstract_private = 0.91
-dunder = 1
-classmethod = 2
-static = 3.5
-final = 3.9
-normal = 4
-private = 5
-mangled = 6
+[tool.structlint.imports]
+internal_allowed_everywhere = []
+external_allowed_everywhere = []
+grimp_cache = ".grimp_cache"
 
-[tool.scripts.check_method_order.regex]
-"@model_validator|model_validate" = 0
-"_pydantic_" = 0.01
-" adapter(" = 0.011
-"@field_validator" = 0.1
-"model_serializ|model_dump" = 0.00001
-"@field_serializer" = 0.3
-"__call__" = 0.99
-"check_.+" = 9
-" read[^ ]+(" = 3.98
-" write[^ ]+(" = 3.99
-"[^_][a-z_]+_hook$" = 9
+[tool.structlint.imports.internal.allowed]
+datamodels = []
+utils = []
+types = ["datamodels"]
 
-[tool.scripts.check_structure]
-checks = [
-    "tests",
-    "mkdocs",
-]
-module_root_dir = "src/adiumentum"
+[tool.structlint.imports.internal.disallowed]
+conversion = ["datamodels"]
 
-[tool.scripts.check_structure.docs]
-allow_additional = "index"
-file_per_class = ""
-file_per_directory = "|utils"
-ignore = "exceptions.py|:_[A-Z]"
-keep_double_underscore = true
-md_dir = "docs/md"
+[tool.structlint.methods.builtins_order]
+init = 0.0
+abstract_property = 1.0
+property = 2.0
+abstract_private_property = 3.0
+private_property = 4.0
+abstract_dunder = 5.0
+dunder = 6.0
+abstract_classmethod = 7.0
+classmethod = 8.0
+abstract = 9.0
+final = 11.0
+abstract_static = 12.0
+static = 13.0
+abstract_private = 14.0
+private = 15.0
+mangled = 16.0
 
-[tool.scripts.check_structure.tests]
-allow_additional = ".*"
-file_per_class = ""
-file_per_directory = "|utils"
-function_for_class = ""
-ignore = ":test__[A-Z]|__init__$|_abcs|exceptions|__get_pydantic_core_schema__"
-keep_double_underscore = true
+[tool.structlint.tests]
 unit_dir = "tests/unit"
 use_filename_suffix = true
-
-[tool.tomlsort]
-all = false
-in_place = true
-no_comments = false
-no_header_comments = false
-no_footer_comments = false
-no_inline_comments = false
-no_block_comments = false
-no_sort_tables = true
-sort_first = ["key1", "key2"]
-sort_table_keys = false
-sort_inline_tables = false
-sort_inline_arrays = false
-spaces_before_inline_comment = 2
-spaces_indent_inline_array = 4
-trailing_comma_inline_array = true
-check = false
-ignore_case = false
+allow_additional = "_tmp"
+ignore = "(?!)"
+order_ignore = "(?!)"
+file_per_directory = "(?!)"
+file_per_class = "(?!)"
+function_per_class = "(?!)"
+replace_double_underscore = false
 
 [tool.vulture]
 exclude = []

{adiumentum-0.1.1 → adiumentum-0.3.1}/src/adiumentum/__init__.py

@@ -11,15 +11,22 @@ from .file_modification_time import (
 from .frozendict import FrozenDefaultDict
 from .functional import (
     dmap,
+    endofilter,
+    endomap,
     fold_dictionaries,
     identity,
+    kfilter,
     kmap,
+    lfilter,
     lmap,
+    sfilter,
     smap,
+    tfilter,
     tmap,
+    vfilter,
     vmap,
 )
-from .io import (
+from .io_utils import (
     list_full,
     read_json,
     read_raw,
@@ -28,20 +35,24 @@ from .io import (
     write_raw_bytes,
 )
 from .markers import (
-    helper,
+    endo,
     impure,
     mutates,
     mutates_and_returns_instance,
     mutates_instance,
     pure,
     refactor,
-    step_data,
-    step_transition,
-    validator,
+)
+from .merge import (
+    join_as_sequence,
+    make_hashable,
+    merge_dicts,
 )
 from .numerical import evenly_spaced, ihash, round5
-from .performance_logging import log_perf
-from .string import (
+from .paths_manager import PathsManager
+from .performance_logging import log_perf  # type: ignore
+from .pydantic_extensions import BaseDict, BaseList, BaseSet
+from .string_utils import (
     MixedValidated,
     PromptTypeName,
     as_json,
@@ -49,6 +60,7 @@ from .string import (
     flexsplit,
     indent_lines,
     parse_sequence,
+    re_split,
 )
 from .timestamping import insert_timestamp, make_timestamp
 from .typing_utils import (
@@ -61,55 +73,64 @@ DELIMITER = "᜶"
 
 __all__ = [
     "DELIMITER",
+    "BaseDict",
+    "BaseList",
+    "BaseSet",
     "Colorizer",
     "CustomValidationError",
     "FrozenDefaultDict",
     "MixedValidated",
-    "NoneDate",
-    "NoneTime",
+    "PathsManager",
     "PromptTypeName",
     "areinstances",
-    "args_to_dict",
     "as_json",
     "call_fallback_if_none",
     "cast_as",
     "dmap",
+    "endo",
+    "endofilter",
+    "endomap",
     "equal_within",
     "evenly_spaced",
     "fallback_if_none",
     "first_newer",
     "flexsplit",
     "fold_dictionaries",
-    "helper",
     "identity",
     "ihash",
     "impure",
     "indent_lines",
     "insert_timestamp",
+    "join_as_sequence",
+    "kfilter",
     "kmap",
+    "lfilter",
     "list_full",
     "lmap",
     "log_perf",
+    "make_hashable",
     "make_timestamp",
+    "merge_dicts",
     "mutates",
     "mutates_and_returns_instance",
     "mutates_instance",
     "nearly_equal",
     "parse_sequence",
     "pure",
+    "re_split",
     "read_json",
     "read_raw",
     "refactor",
     "round5",
+    "sfilter",
     "smap",
-    "step_data",
-    "step_transition",
+    "tfilter",
     "time_created",
     "time_created_readable",
     "time_modified",
     "time_modified_readable",
     "tmap",
-    "validator",
+    "vfilter",
     "vmap",
     "write_json",
     "write_raw",

adiumentum-0.3.1/src/adiumentum/dependency_sorting.py

@@ -0,0 +1,84 @@
+# for tests
+sample = [
+    {"id": "a", "priority": 0.4, "prerequisites": []},
+    {"id": "b", "priority": 0.7, "prerequisites": []},
+    {"id": "c", "priority": 0.4, "prerequisites": []},
+    {"id": "d", "priority": 0.3, "prerequisites": []},
+    {"id": "e", "priority": 0.8, "prerequisites": ["a", "b"]},
+    {"id": "f", "priority": 0.9, "prerequisites": []},
+    {"id": "g", "priority": 0.1, "prerequisites": ["i", "m"]},
+    {"id": "h", "priority": 0.5, "prerequisites": []},
+    {"id": "i", "priority": 0.45, "prerequisites": ["j"]},
+    {"id": "j", "priority": 0.3, "prerequisites": []},
+    {"id": "k", "priority": 0.8, "prerequisites": ["l", "m", "d"]},
+    {"id": "l", "priority": 0.6, "prerequisites": ["o"]},
+    {"id": "m", "priority": 0.9, "prerequisites": []},
+    {"id": "n", "priority": 0.4, "prerequisites": ["o"]},
+    {"id": "o", "priority": 0.2, "prerequisites": []},
+    {"id": "p", "priority": 0.5, "prerequisites": []},
+]
+
+
+def dep_sort(task_list: list[dict]) -> list[dict]:
+    """
+    Sort list of dictionaries such that
+      1) dependency constraints are satisfied and
+      2) priority ordering is satisfied subject to (1)
+    """
+    # sort on priority to preserve priority order in the output
+    task_list.sort(key=lambda t: t["priority"], reverse=True)
+    task_ids = [t["id"] for t in task_list]
+
+    # important to make changes in reverse priority order so that insertion preserves priority order
+    dep_dict = {t["id"]: t["prerequisites"] for t in reversed(task_list) if t["prerequisites"]}
+    print(dep_dict)
+
+    def place_after(to_move: str, deps: list[str], id_list: list) -> bool:
+        if not deps:
+            return False
+        idx1 = id_list.index(to_move)
+        idx2 = max(map(id_list.index, deps))
+        if idx1 > idx2:
+            return False
+        id_list.pop(idx1)
+        id_list.insert(idx2, to_move)
+        return True
+
+    print(task_ids)
+    count = 0
+    maxcount = sum(range(len(task_ids) + 1))
+    while count < maxcount:
+        change_tracker = []
+        for task_id, task_deps in dep_dict.items():
+            changed = place_after(task_id, task_deps, task_ids)
+            change_tracker.append(changed)
+        unchanged = not any(change_tracker)
+        print(task_ids)
+        if unchanged:
+            return sorted(task_list, key=lambda t: task_ids.index(t["id"]))
+        count += 1
+
+    print("ERROR ---------------------------------------------------")
+    str(task_ids)
+    for task_id, task_deps in dep_dict.items():
+        changed = place_after(task_id, task_deps, task_ids)
+        if changed:
+            after = str(task_ids)
+            print(after)
+
+    raise ValueError("Graph contains a cycle.")
+
+    # levels = {t: 0 for t in task_ids}
+    # roots = list(filter(lambda t: t["depencies"] == [], task_list))
+    # depended_on = {t: set() for t in task_ids}
+    # for t in task_list:
+    #     for d in t["prerequisites"]:
+    #         depended_on[d].add(t)
+    # dict_rep = json.dumps(levels)
+    # new_rep = ""
+    # while new_rep != dict_rep:
+    #     dict_rep = json.dumps(levels)
+    #     for t in task_list:
+    #         levels[t["id"]] = max([levels[d] for d in t["prerequisites"]]) + 1
+    #     new_rep = json.dumps(levels)
+    # return sorted(task_list, key=lambda t: levels[t["id"]])

adiumentum-0.3.1/src/adiumentum/display.py

@@ -0,0 +1,49 @@
+import re
+from collections import defaultdict
+from collections.abc import Callable
+
+
+def display_counts(key: str, depth: int, dl: list[str]) -> None:
+    print(f"\n=== {key} ===")
+    for d in dl:
+        if key not in d:
+            print(d["name"])
+    cats = [d[key] for d in dl]
+    cats = [".".join(re.split(r"\.|, ", c)[:depth]) for c in cats]
+    counts = sorted([(cats.count(c), c) for c in sorted(set(cats))], reverse=True)
+    for count, item in counts:
+        print(f"{count:>4} {item}")
+
+
+def print_tree(strings):
+    # Nested dictionary to hold tree structure
+    def tree() -> defaultdict:
+        return defaultdict(tree)
+
+    root = tree()
+
+    # Build the tree
+    for _string in strings:
+        parts = _string.split(".")
+        current_level = root
+        for part in parts:
+            current_level = current_level[part]
+
+    # Function to print the tree recursively
+    def print_subtree(node, prefix=""):
+        children = list(node.keys())
+        for i, child in enumerate(children):
+            is_last = i == len(children) - 1
+            if is_last:
+                print(prefix + "└─ " + child)
+                new_prefix = prefix + "   "
+            else:
+                print(prefix + "├─ " + child)
+                new_prefix = prefix + "│  "
+            print_subtree(node[child], new_prefix)
+
+    # Print the root
+    print_subtree(root)
+
+
+def wrap_line(line: str, length: int, formatter: Callable) -> str: ...

adiumentum-0.3.1/src/adiumentum/functional.py

@@ -0,0 +1,95 @@
+from collections.abc import Callable, Hashable, Iterable
+from functools import reduce
+from typing import TypeVar, overload
+
+T = TypeVar("T")
+TPost = TypeVar("TPost")
+TPre = TypeVar("TPre")
+K = TypeVar("K", bound=Hashable)
+V = TypeVar("V")
+type Filterer[T] = Callable[[T], bool]
+
+
+@overload
+def endomap(callable_: Callable[[TPre], TPost], sequence: list[TPre]) -> list[TPost]: ...
+@overload
+def endomap(callable_: Callable[[TPre], TPost], sequence: set[TPre]) -> set[TPost]: ...
+@overload
+def endomap(
+    callable_: Callable[[TPre], TPost], sequence: tuple[TPre, ...]
+) -> tuple[TPost, ...]: ...
+
+
+def endomap(callable_, sequence):
+    return type(sequence)(map(callable_, sequence))
+
+
+@overload
+def endofilter(callable_: Callable[[T], bool], sequence: list[T]) -> list[T]: ...
+@overload
+def endofilter(callable_: Callable[[T], bool], sequence: set[T]) -> set[T]: ...
+@overload
+def endofilter(callable_: Callable[[T], bool], sequence: tuple[T, ...]) -> tuple[T, ...]: ...
+
+
+def endofilter(callable_, sequence):
+    return type(sequence)(filter(callable_, sequence))
+
+
+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 lfilter(filterer: Filterer[T], iterable: Iterable[T]) -> list[T]:
+    return list(filter(filterer, iterable))
+
+
+def sfilter(filterer: Filterer[T], iterable: Iterable[T]) -> set[T]:
+    return set(filter(filterer, iterable))
+
+
+def tfilter(filterer: Filterer[T], iterable: Iterable[T]) -> tuple[T, ...]:
+    return tuple(filter(filterer, iterable))
+
+
+def vfilter(filterer: Filterer[V], dictionary: dict[K, V]) -> dict[K, V]:
+    return {k: v for k, v in dictionary.items() if filterer(v)}
+
+
+def kfilter(filterer: Filterer[K], dictionary: dict[K, V]) -> dict[K, V]:
+    return {k: v for k, v in dictionary.items() if filterer(k)}
+
+
+def dfilter(filterer: Filterer[T], dictionary: dict[T, T]) -> dict[T, T]:
+    return {k: v for k, v in dictionary.items() if filterer(k) and filterer(v)}
+
+
+def identity[T](x: T) -> T:
+    return x
+
+
+def fold_dictionaries[K, V](dicts: Iterable[dict[K, V]]) -> dict[K, V]:
+    def _or(dict1: dict[K, V], dict2: dict[K, V]) -> dict[K, V]:
+        return dict1 | dict2
+
+    return reduce(_or, dicts)