adiumentum 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

adiumentum/__init__.py

@@ -3,23 +3,30 @@ 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,
     time_created_readable,
+    time_modified,
     time_modified_readable,
 )
 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,8 +60,9 @@ from .string import (
     flexsplit,
     indent_lines,
     parse_sequence,
+    re_split,
 )
-from .timestamping import insert_timestamp
+from .timestamping import insert_timestamp, make_timestamp
 from .typing_utils import (
     areinstances,
     call_fallback_if_none,
@@ -61,54 +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",
-    "get_time_created",
-    "get_time_modified",
-    "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/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/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/file_modification_time.py

@@ -1,24 +1,32 @@
 import os
-import time
+from datetime import datetime
 from pathlib import Path
 
 
-def get_time_created(path: Path | str) -> float:
-    return os.path.getctime(path)
+def time_created(path: Path | str) -> float:
+    return Path(path).stat().st_ctime
 
 
-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 format_time(raw_time: float, places: int = 3) -> str:
+    dt = datetime.fromtimestamp(raw_time)
+    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 get_time_modified(path: Path | str) -> float:
-    return os.path.getmtime(path)
+def time_created_readable(path: Path | str, places: int = 3) -> str:
+    # time_created: time.struct_time = time.strptime(time.ctime(time_created(path)))
+    return format_time(time_created(path), places=places)
 
 
-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 time_modified(path: Path | str) -> float:
+    return Path(path).stat().st_mtime
+
+
+def time_modified_readable(path: Path | str, places: int = 3) -> str:
+    # time_modified: time.struct_time = time.strptime(time.ctime(time_modified(path)))
+    return format_time(time_modified(path), places=places)
 
 
 def first_newer(file1: str | Path, file2: str | Path | tuple[Path, ...] | tuple[str, ...]) -> bool:

adiumentum/frozendict.py

@@ -1,12 +1,12 @@
 from collections import defaultdict
 from collections.abc import Callable
-from typing import Generic, TypeVar, cast
+from typing import TypeVar, cast
 
 T = TypeVar("T")
 K = TypeVar("K")
 
 
-class FrozenDefaultDict(defaultdict[K, T], Generic[K, T]):
+class FrozenDefaultDict[K, T](defaultdict[K, T]):
     def __init__(self, default_factory: Callable[[], T], dictionary: dict[K, T]):
         super().__init__(default_factory, dictionary)
 

adiumentum/functional.py

@@ -1,12 +1,39 @@
-from collections.abc import Callable, Iterable
+from collections.abc import Callable, Hashable, Iterable
 from functools import reduce
-from typing import TypeVar
+from typing import TypeVar, overload
 
 T = TypeVar("T")
 TPost = TypeVar("TPost")
 TPre = TypeVar("TPre")
-K = TypeVar("K")
+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]:
@@ -33,12 +60,36 @@ def dmap(callable_: Callable[[TPre], TPost], dictionary: dict[TPre, TPre]) -> di
     return {callable_(k): callable_(v) for k, v in dictionary.items()}
 
 
-def identity(x: T) -> T:
+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(dicts: Iterable[dict[K, T]]) -> dict[K, T]:
-    def _or(dict1: dict[K, T], dict2: dict[K, T]) -> dict[K, T]:
+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)

adiumentum/io_utils.py

@@ -0,0 +1,63 @@
+import json
+import os
+import shutil
+from pathlib import Path
+from typing import Literal
+
+from .timestamping import make_timestamp
+from .typing_utils import JSONDict, JSONList
+
+
+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 back_up_json(original_path: Path, backup_dir: Path | None) -> None:
+    if not backup_dir:
+        return
+    backup_path = backup_dir / original_path.name.replace(".json", f"__{make_timestamp()}.json")
+    if original_path.exists():
+        shutil.copy(original_path, backup_path)
+
+
+def read_json(json_path: Path, backup_dir: Path | None = None) -> JSONDict | JSONList:
+    back_up_json(json_path, backup_dir)
+    with open(json_path, encoding="utf-8") as f:
+        return json.load(f)
+
+
+def write_json(
+    python_obj: JSONDict | JSONList | bytes,
+    json_path: Path,
+    backup_dir: Path | None = None,
+    mode: Literal["w", "a"] = "w",
+) -> None:
+    if mode not in {"w", "a"}:
+        raise ValueError(f"Invalid mode: '{mode}'")
+    back_up_json(json_path, backup_dir)
+    if mode == "a":
+        existing = read_json(json_path)
+        if isinstance(existing, list) and isinstance(existing, list):
+            python_obj = existing + python_obj
+        elif isinstance(existing, list) and isinstance(existing, list):
+            python_obj = existing | python_obj
+        else:
+            raise ValueError("Data types do not match.")
+    with open(json_path, "w", encoding="utf-8") as f:
+        json.dump(python_obj, f, ensure_ascii=False, indent=4)
+
+
+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

@@ -1,117 +1,100 @@
 from collections.abc import Callable
 from functools import wraps
+from typing import TypeVar, cast
 
-from .functional import identity
+# from .functional import identity
 
 
-def impure(callable_or_none: Callable | None = None, **kwargs) -> Callable:
+T = TypeVar("T")
+In = TypeVar("In")
+Out = TypeVar("Out")
+
+
+def trivial_decorator[In, Out](func: Callable[[In], Out]) -> Callable[[In], Out]:
+    return func
+
+
+def impure[In, Out](
+    callable_or_none: Callable[[In], Out] | None = None,
+    message: str = "",
+) -> Callable[[In], Out] | Callable[[Callable[[In], Out]], Callable[[In], Out]]:
     if callable_or_none is None:
-        return identity
+        return trivial_decorator
     else:
         return callable_or_none
 
 
-def pure(callable_or_none: Callable | None = None, **kwargs) -> Callable:
+def pure[In, Out](
+    callable_or_none: Callable[[In], Out] | None = None,
+    message: str = "",
+) -> Callable[[In], Out] | Callable[[Callable[[In], Out]], Callable[[In], Out]]:
     if callable_or_none is None:
-        return identity
+        return trivial_decorator
     else:
         return callable_or_none
 
 
-def helper(callable_or_none: Callable | None = None, **kwargs) -> Callable:
+def endo(
+    callable_or_none: Callable[[T], T] | None = None,
+    message: str = "",
+) -> Callable[[T], T] | Callable[[Callable[[In], Out]], Callable[[In], Out]]:
     if callable_or_none is None:
-        return identity
+        return trivial_decorator
     else:
         return callable_or_none
 
 
-def step_data(func: Callable) -> Callable:
+def decorate_with_message[In, Out](func: Callable[[In], Out], message: str) -> Callable[[In], Out]:
     @wraps(func)
-    def wrapper(*fargs, **fkwargs):
-        return func(*fargs, **fkwargs)
+    def wrapper(*fargs, **fkwargs) -> Out:  # type: ignore
+        print(message)
 
-    return wrapper
+        return func(*fargs, **fkwargs)  # type: ignore
 
+    return cast(Callable[[In], Out], wrapper)
 
-def step_transition(func: Callable) -> Callable:
-    @wraps(func)
-    def wrapper(*fargs, **fkwargs):
-        return func(*fargs, **fkwargs)
 
-    return wrapper
+def mutates_instance[In, Out](func: Callable[[In], Out], *mutated: str) -> Callable[[In], Out]:
+    message = (
+        f"\u001b[31mMutating in place\u001b[0m:         "
+        f" via \u001b[33m{func.__name__:<25}\u001b[0m"
+        f" in \u001b[34m{func.__module__}\u001b[0m"
+    )
 
+    return decorate_with_message(func, message)
 
-def validator(func: Callable) -> Callable:
-    @wraps(func)
-    def wrapper(*fargs, **fkwargs):
-        return func(*fargs, **fkwargs)
 
-    return wrapper
+def mutates_and_returns_instance[In, Out](
+    func: Callable[[In], Out],
+    *mutated: str,
+) -> Callable[[In], Out]:
+    message = (
+        f"\u001b[31mMutating\u001b[0m"
+        f"{(' ' * bool(mutated)) + ', '.join(mutated)}"
+        f" \u001b[31mand returning instance of\u001b[0m: {func.__class__.__name__}"
+        f" via \u001b[33m{func.__name__:<25}\u001b[0m"
+        f" in \u001b[34m{func.__module__}\u001b[0m"
+    )
 
+    return decorate_with_message(func, message)
 
-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[In, Out](func: Callable[[In], Out], *mutated: str) -> Callable[[In], Out]:
+    message = (
+        f"Mutating \u001b[36m{', '.join(mutated):<50}\u001b[0m"
+        f" via \u001b[33m{func.__name__:<25}\u001b[0m"
+        f" in \u001b[34m{func.__module__:<40}\u001b[0m"
+    )
 
+    return decorate_with_message(func, message)
 
-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
+
+def refactor[In, Out](func: Callable[[In], Out], message: str = "") -> Callable[[In], Out]:
+    message = (
+        f"\u001b[36mREFACTOR\u001b[0m"
+        f" \u001b[33m{func.__name__}\u001b[0m"
+        f" in \u001b[34m{func.__module__.replace('consilium.', '.')}\u001b[0m."
+        f"\n    {message}"
+    )
+
+    return decorate_with_message(func, message)