relib 1.2.11__tar.gz → 1.3.0__tar.gz

{relib-1.2.11 → relib-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relib
-Version: 1.2.11
+Version: 1.3.0
 Project-URL: Repository, https://github.com/Reddan/relib.git
 Author: Hampus Hallman
 License: Copyright 2018-2025 Hampus Hallman

{relib-1.2.11 → relib-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "relib"
-version = "1.2.11"
+version = "1.3.0"
 requires-python = ">=3.12"
 dependencies = []
 authors = [

relib-1.3.0/relib/__init__.py

@@ -0,0 +1,6 @@
+from .dict_utils import *
+from .io_utils import *
+from .iter_utils import *
+from .processing_utils import *
+from .runtime_tools import *
+from .type_utils import *

relib-1.3.0/relib/dict_utils.py

@@ -0,0 +1,97 @@
+from typing import Any, Callable, Iterable, overload
+from .type_utils import as_any
+
+__all__ = [
+  "deepen_dict", "dict_by", "dict_firsts",
+  "flatten_dict_inner", "flatten_dict",
+  "get_at", "group",
+  "key_of",
+  "map_dict", "merge_dicts",
+  "omit",
+  "pick",
+  "tuple_by",
+]
+
+def merge_dicts[T, K](*dicts: dict[K, T]) -> dict[K, T]:
+  if len(dicts) == 1:
+    return dicts[0]
+  result = {}
+  for d in dicts:
+    result |= d
+  return result
+
+def omit[T, K](d: dict[K, T], keys: Iterable[K]) -> dict[K, T]:
+  if keys:
+    d = dict(d)
+    for key in keys:
+      del d[key]
+  return d
+
+def pick[T, K](d: dict[K, T], keys: Iterable[K]) -> dict[K, T]:
+  return {key: d[key] for key in keys}
+
+def dict_by[T, K](keys: Iterable[K], values: Iterable[T]) -> dict[K, T]:
+  return dict(zip(keys, values))
+
+def tuple_by[T, K](d: dict[K, T], keys: Iterable[K]) -> tuple[T, ...]:
+  return tuple(d[key] for key in keys)
+
+def map_dict[T, U, K](fn: Callable[[T], U], d: dict[K, T]) -> dict[K, U]:
+  return {key: fn(value) for key, value in d.items()}
+
+def key_of[T, U](dicts: Iterable[dict[T, U]], key: T) -> list[U]:
+  return [d[key] for d in dicts]
+
+def get_at[T](d: dict, keys: Iterable[Any], default: T) -> T:
+  try:
+    for key in keys:
+      d = d[key]
+  except KeyError:
+    return default
+  return as_any(d)
+
+def dict_firsts[T, K](pairs: Iterable[tuple[K, T]]) -> dict[K, T]:
+  result: dict[K, T] = {}
+  for key, item in pairs:
+    if key not in result:
+      result[key] = item
+  return result
+
+def group[T, K](pairs: Iterable[tuple[K, T]]) -> dict[K, list[T]]:
+  values_by_key = {}
+  for key, value in pairs:
+    values_by_key.setdefault(key, []).append(value)
+  return values_by_key
+
+@overload
+def deepen_dict[K1, U](d: dict[tuple[K1], U]) -> dict[K1, U]: ...
+@overload
+def deepen_dict[K1, K2, U](d: dict[tuple[K1, K2], U]) -> dict[K1, dict[K2, U]]: ...
+@overload
+def deepen_dict[K1, K2, K3, U](d: dict[tuple[K1, K2, K3], U]) -> dict[K1, dict[K2, dict[K3, U]]]: ...
+@overload
+def deepen_dict[K1, K2, K3, K4, U](d: dict[tuple[K1, K2, K3, K4], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, U]]]]: ...
+@overload
+def deepen_dict[K1, K2, K3, K4, K5, U](d: dict[tuple[K1, K2, K3, K4, K5], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, dict[K5, U]]]]]: ...
+@overload
+def deepen_dict[K1, K2, K3, K4, K5, K6, U](d: dict[tuple[K1, K2, K3, K4, K5, K6], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, dict[K5, dict[K6, U]]]]]]: ...
+def deepen_dict(d: dict[tuple[Any, ...], Any]) -> dict:
+  output = {}
+  if () in d:
+    return d[()]
+  for (*tail, head), value in d.items():
+    curr = output
+    for key in tail:
+      curr = curr.setdefault(key, {})
+    curr[head] = value
+  return output
+
+def flatten_dict_inner(d, prefix=()):
+  for key, value in d.items():
+    if not isinstance(value, dict) or value == {}:
+      yield prefix + (key,), value
+    else:
+      yield from flatten_dict_inner(value, prefix + (key,))
+
+def flatten_dict(deep_dict: dict, prefix=()) -> dict:
+  return dict(flatten_dict_inner(deep_dict, prefix))

relib-1.3.0/relib/io_utils.py

@@ -0,0 +1,21 @@
+import json
+from pathlib import Path
+from typing import Any
+
+__all__ = [
+  "read_json",
+  "write_json",
+]
+
+default_sentinel = object()
+
+def read_json(path: Path, default=default_sentinel) -> Any:
+  if default is not default_sentinel and not path.exists():
+    return default
+  with path.open("r") as f:
+    return json.load(f)
+
+def write_json(path: Path, obj: object, indent: None | int = None) -> None:
+  with path.open("w") as f:
+    separators = (",", ":") if indent is None else None
+    return json.dump(obj, f, indent=indent, separators=separators)

relib-1.3.0/relib/iter_utils.py

@@ -0,0 +1,94 @@
+from itertools import chain
+from typing import Any, Iterable, Literal, overload
+from .dict_utils import dict_firsts
+
+__all__ = [
+  "distinct_by", "distinct", "drop_none",
+  "first", "flatten",
+  "intersect",
+  "list_split",
+  "move_value",
+  "num_partitions",
+  "reversed_enumerate",
+  "sized_partitions", "sort_by",
+  "transpose",
+]
+
+def first[T](iterable: Iterable[T]) -> T | None:
+  return next(iter(iterable), None)
+
+def drop_none[T](iterable: Iterable[T | None]) -> list[T]:
+  return [x for x in iterable if x is not None]
+
+def distinct[T](iterable: Iterable[T]) -> list[T]:
+  return list(dict.fromkeys(iterable))
+
+def distinct_by[T](pairs: Iterable[tuple[object, T]]) -> list[T]:
+  return list(dict_firsts(pairs).values())
+
+def sort_by[T](pairs: Iterable[tuple[Any, T]]) -> list[T]:
+  pairs = sorted(pairs, key=lambda p: p[0])
+  return [v for _, v in pairs]
+
+def move_value[T](iterable: Iterable[T], from_i: int, to_i: int) -> list[T]:
+  values = list(iterable)
+  values.insert(to_i, values.pop(from_i))
+  return values
+
+def reversed_enumerate[T](values: list[T] | tuple[T, ...]) -> Iterable[tuple[int, T]]:
+  return zip(reversed(range(len(values))), reversed(values))
+
+def intersect[T](*iterables: Iterable[T]) -> list[T]:
+  return list(set.intersection(*map(set, iterables)))
+
+@overload
+def flatten[T](iterable: Iterable[T], depth: Literal[0]) -> list[T]: ...
+@overload
+def flatten[T](iterable: Iterable[Iterable[T]], depth: Literal[1] = 1) -> list[T]: ...
+@overload
+def flatten[T](iterable: Iterable[Iterable[Iterable[T]]], depth: Literal[2]) -> list[T]: ...
+@overload
+def flatten[T](iterable: Iterable[Iterable[Iterable[Iterable[T]]]], depth: Literal[3]) -> list[T]: ...
+@overload
+def flatten[T](iterable: Iterable[Iterable[Iterable[Iterable[Iterable[T]]]]], depth: Literal[4]) -> list[T]: ...
+@overload
+def flatten(iterable: Iterable, depth: int) -> list: ...
+def flatten(iterable: Iterable, depth: int = 1) -> list:
+  for _ in range(depth):
+    iterable = chain.from_iterable(iterable)
+  return list(iterable)
+
+def list_split[T](iterable: Iterable[T], sep: T) -> list[list[T]]:
+  values = [sep, *iterable, sep]
+  split_at = [i for i, x in enumerate(values) if x is sep]
+  ranges = list(zip(split_at[0:-1], split_at[1:]))
+  return [values[start + 1:end] for start, end in ranges]
+
+def sized_partitions[T](values: Iterable[T], part_size: int) -> list[list[T]]:
+  # "chunk"
+  if not isinstance(values, list):
+    values = list(values)
+  num_parts = (len(values) / part_size).__ceil__()
+  return [values[i * part_size:(i + 1) * part_size] for i in range(num_parts)]
+
+def num_partitions[T](values: Iterable[T], num_parts: int) -> list[list[T]]:
+  if not isinstance(values, list):
+    values = list(values)
+  part_size = (len(values) / num_parts).__ceil__()
+  return [values[i * part_size:(i + 1) * part_size] for i in range(num_parts)]
+
+@overload
+def transpose[T1, T2](tuples: Iterable[tuple[T1, T2]], default_num_returns=0) -> tuple[list[T1], list[T2]]: ...
+@overload
+def transpose[T1, T2, T3](tuples: Iterable[tuple[T1, T2, T3]], default_num_returns=0) -> tuple[list[T1], list[T2], list[T3]]: ...
+@overload
+def transpose[T1, T2, T3, T4](tuples: Iterable[tuple[T1, T2, T3, T4]], default_num_returns=0) -> tuple[list[T1], list[T2], list[T3], list[T4]]: ...
+@overload
+def transpose[T1, T2, T3, T4, T5](tuples: Iterable[tuple[T1, T2, T3, T4, T5]], default_num_returns=0) -> tuple[list[T1], list[T2], list[T3], list[T4], list[T5]]: ...
+@overload
+def transpose[T](tuples: Iterable[tuple[T, ...]], default_num_returns=0) -> tuple[list[T], ...]: ...
+def transpose(tuples: Iterable[tuple], default_num_returns=0) -> tuple[list, ...]:
+  output = tuple(zip(*tuples))
+  if not output:
+    return ([],) * default_num_returns
+  return tuple(map(list, output))

relib-1.3.0/relib/processing_utils.py

@@ -0,0 +1,66 @@
+import re
+from typing import Any, Callable, Iterable, overload
+
+__all__ = [
+  "clamp",
+  "df_from_array",
+  "for_each",
+  "noop",
+  "str_filterer", "StrFilter",
+]
+
+def noop() -> None:
+  pass
+
+def for_each[T](func: Callable[[T], Any], iterable: Iterable[T]) -> None:
+  for item in iterable:
+    func(item)
+
+@overload
+def clamp(value: int, low: int, high: int) -> int: ...
+@overload
+def clamp(value: float, low: float, high: float) -> float: ...
+def clamp(value: float, low: float, high: float) -> float:
+    return max(low, min(value, high))
+
+def _cat_tile(cats, n_tile):
+  import numpy as np
+  return cats[np.tile(np.arange(len(cats)), n_tile)]
+
+def df_from_array(
+  value_cols: dict[str, Any],
+  dim_labels: list[tuple[str, list[str | int | float]]],
+  indexed=False,
+):
+  import numpy as np
+  import pandas as pd
+  dim_sizes = np.array([len(labels) for _, labels in dim_labels])
+  assert all(array.shape == tuple(dim_sizes) for array in value_cols.values())
+  array_offsets = [
+    (dim_sizes[i + 1:].prod(), dim_sizes[:i].prod())
+    for i in range(len(dim_sizes))
+  ]
+  category_cols = {
+    dim: _cat_tile(pd.Categorical(labels).repeat(repeats), tiles)
+    for (dim, labels), (repeats, tiles) in zip(dim_labels, array_offsets)
+  }
+  value_cols = {name: array.reshape(-1) for name, array in value_cols.items()}
+  df = pd.DataFrame({**category_cols, **value_cols}, copy=False)
+  if indexed:
+    df = df.set_index([name for name, _ in dim_labels])
+  return df
+
+StrFilter = Callable[[str], bool]
+
+def str_filterer(
+  include_patterns: list[re.Pattern[str]] = [],
+  exclude_patterns: list[re.Pattern[str]] = [],
+) -> StrFilter:
+  def str_filter(string: str) -> bool:
+    if any(pattern.search(string) for pattern in exclude_patterns):
+      return False
+    if not include_patterns:
+      return True
+    return any(pattern.search(string) for pattern in include_patterns)
+
+  return str_filter

relib-1.2.11/relib/system.py → relib-1.3.0/relib/runtime_tools.py

@@ -1,38 +1,23 @@
 import asyncio
 import contextvars
-import functools
-import json
 import os
 from concurrent.futures import ThreadPoolExecutor
-from pathlib import Path
-from typing import Any, Awaitable, Callable, Iterable, ParamSpec, TypeVar
-from .utils import noop
+from functools import partial, wraps
+from time import time
+from typing import Awaitable, Callable, Iterable, ParamSpec, TypeVar
+from .processing_utils import noop
 
 __all__ = [
-  "read_json",
-  "write_json",
-  "clear_console",
-  "console_link",
+  "as_async", "async_limit",
+  "clear_console", "console_link",
   "roll_tasks",
-  "as_async",
-  "async_limit",
+  "measure_duration",
 ]
 
 P = ParamSpec("P")
 R = TypeVar("R")
-default_workers = min(32, (os.cpu_count() or 1) + 4)
-default_sentinel = object()
-
-def read_json(path: Path, default=default_sentinel) -> Any:
-  if default is not default_sentinel and not path.exists():
-    return default
-  with path.open("r") as f:
-    return json.load(f)
 
-def write_json(path: Path, obj: object, indent: None | int = None) -> None:
-  with path.open("w") as f:
-    separators = (",", ":") if indent is None else None
-    return json.dump(obj, f, indent=indent, separators=separators)
+default_workers = min(32, (os.cpu_count() or 1) + 4)
 
 def clear_console() -> None:
   os.system("cls" if os.name == "nt" else "clear")
@@ -54,18 +39,18 @@ async def roll_tasks[T](tasks: Iterable[Awaitable[T]], workers=default_workers,
   from tqdm import tqdm
   tasks = tasks if isinstance(tasks, list) else list(tasks)
   with tqdm(total=len(tasks)) as pbar:
-    update = functools.partial(pbar.update, 1)
+    update = partial(pbar.update, 1)
     return await asyncio.gather(*[worker(task, semaphore, update) for task in tasks])
 
 def as_async(workers=default_workers) -> Callable[[Callable[P, R]], Callable[P, Awaitable[R]]]:
   executor = ThreadPoolExecutor(max_workers=workers)
 
   def on_fn(func: Callable[P, R]) -> Callable[P, Awaitable[R]]:
-    @functools.wraps(func)
+    @wraps(func)
     async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
       loop = asyncio.get_running_loop()
       ctx = contextvars.copy_context()
-      fn_call = functools.partial(ctx.run, func, *args, **kwargs)
+      fn_call = partial(ctx.run, func, *args, **kwargs)
       return await loop.run_in_executor(executor, fn_call)
     return wrapper
   return on_fn
@@ -74,9 +59,27 @@ def async_limit(workers=default_workers) -> Callable[[Callable[P, Awaitable[R]]]
   semaphore = asyncio.Semaphore(workers)
 
   def on_fn(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]:
-    @functools.wraps(func)
+    @wraps(func)
     async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
       async with semaphore:
         return await func(*args, **kwargs)
     return wrapper
   return on_fn
+
+active_mds = []
+
+class measure_duration:
+  def __init__(self, name):
+    self.name = name
+    active_mds.append(self)
+
+  def __enter__(self):
+    self.start = time()
+
+  def __exit__(self, *_):
+    duration = round(time() - self.start, 4)
+    depth = len(active_mds) - 1
+    indent = ('──' * depth) + (' ' * (depth > 0))
+    text = '{}: {} seconds'.format(self.name, duration)
+    print(indent + text)
+    active_mds.remove(self)

relib-1.3.0/relib/type_utils.py

@@ -0,0 +1,17 @@
+from typing import Any
+
+__all__ = [
+  "as_any",
+  "ensure_tuple",
+  "non_none",
+]
+
+def as_any(obj: Any) -> Any:
+  return obj
+
+def non_none[T](obj: T | None) -> T:
+  assert obj is not None
+  return obj
+
+def ensure_tuple[T](value: T | tuple[T, ...]) -> tuple[T, ...]:
+  return value if isinstance(value, tuple) else (value,)

{relib-1.2.11 → relib-1.3.0}/uv.lock

@@ -106,7 +106,7 @@ wheels = [
 
 [[package]]
 name = "relib"
-version = "1.2.11"
+version = "1.3.0"
 source = { editable = "." }
 
 [package.dev-dependencies]

relib-1.2.11/relib/__init__.py

@@ -1,4 +0,0 @@
-from .utils import *
-from .system import *
-from .hashing import hash, hash_obj
-from .measure_duration import measure_duration

relib-1.2.11/relib/hashing.py

@@ -1,179 +0,0 @@
-# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
-# Copyright (c) 2009 Gael Varoquaux
-# License: BSD Style, 3 clauses.
-
-import pickle
-import hashlib
-import sys
-import types
-import io
-import decimal
-
-try:
-  import numpy
-except:
-  has_numpy = False
-else:
-  has_numpy = True
-
-Pickler = pickle._Pickler
-
-
-class _ConsistentSet(object):
-  def __init__(self, set_sequence):
-    try:
-      self._sequence = sorted(set_sequence)
-    except (TypeError, decimal.InvalidOperation):
-      self._sequence = sorted(map(hash_obj, set_sequence))
-
-
-class _MyHash(object):
-  """ Class used to hash objects that won't normally pickle """
-
-  def __init__(self, *args):
-    self.args = args
-
-
-class Hasher(Pickler):
-  """ A subclass of pickler, to do cryptographic hashing, rather than pickling. """
-
-  def __init__(self, hash_name="md5"):
-    self.stream = io.BytesIO()
-    # We want a pickle protocol that only changes with major Python versions
-    protocol = pickle.HIGHEST_PROTOCOL
-    Pickler.__init__(self, self.stream, protocol=protocol)
-    self._hash = hashlib.new(hash_name)
-
-  def hash(self, obj) -> str:
-    try:
-      self.dump(obj)
-    except pickle.PicklingError as e:
-      e.args += ("PicklingError while hashing %r: %r" % (obj, e),)
-      raise
-    dumps = self.stream.getvalue()
-    self._hash.update(dumps)
-    return self._hash.hexdigest()
-
-  def save(self, obj):
-    if isinstance(obj, (types.MethodType, type({}.pop))):
-      # the Pickler cannot pickle instance methods; here we decompose
-      # them into components that make them uniquely identifiable
-      if hasattr(obj, "__func__"):
-        func_name = obj.__func__.__name__
-      else:
-        func_name = obj.__name__
-      inst = obj.__self__
-      if type(inst) == type(pickle):
-        obj = _MyHash(func_name, inst.__name__)
-      elif inst is None:
-        # type(None) or type(module) do not pickle
-        obj = _MyHash(func_name, inst)
-      else:
-        cls = obj.__self__.__class__
-        obj = _MyHash(func_name, inst, cls)
-    Pickler.save(self, obj)
-
-  def memoize(self, obj):
-    # We want hashing to be sensitive to value instead of reference.
-    # For example we want ["aa", "aa"] and ["aa", "aaZ"[:2]]
-    # to hash to the same value and that's why we disable memoization
-    # for strings
-    if isinstance(obj, (bytes, str)):
-      return
-    Pickler.memoize(self, obj)
-
-  # The dispatch table of the pickler is not accessible in Python
-  # 3, as these lines are only bugware for IPython, we skip them.
-  def save_global(self, obj, name=None):
-    # We have to override this method in order to deal with objects
-    # defined interactively in IPython that are not injected in
-    # __main__
-    try:
-      Pickler.save_global(self, obj, name=name)
-    except pickle.PicklingError:
-      Pickler.save_global(self, obj, name=name)
-      module = getattr(obj, "__module__", None)
-      if module == "__main__":
-        my_name = name
-        if my_name is None:
-          my_name = obj.__name__
-        mod = sys.modules[module]
-        if not hasattr(mod, my_name):
-          # IPython doesn't inject the variables define
-          # interactively in __main__
-          setattr(mod, my_name, obj)
-
-  def _batch_setitems(self, items):
-    try:
-      Pickler._batch_setitems(self, iter(sorted(items)))
-    except TypeError:
-      Pickler._batch_setitems(self, iter(sorted((hash_obj(k), v) for k, v in items)))
-
-  def save_set(self, set_items):
-    Pickler.save(self, _ConsistentSet(set_items))
-
-  dispatch = Pickler.dispatch.copy()
-  dispatch[type(len)] = save_global # builtin
-  dispatch[type(object)] = save_global # type
-  dispatch[type(Pickler)] = save_global # classobj
-  dispatch[type(pickle.dump)] = save_global # function
-  dispatch[type(set())] = save_set
-
-
-class NumpyHasher(Hasher):
-  def __init__(self, hash_name="md5"):
-    Hasher.__init__(self, hash_name=hash_name)
-
-  def save(self, obj):
-    """ Subclass the save method, to hash ndarray subclass, rather
-      than pickling them. Off course, this is a total abuse of
-      the Pickler class.
-    """
-    import numpy as np
-
-    if isinstance(obj, np.ndarray) and not obj.dtype.hasobject:
-      # Compute a hash of the object
-      # The update function of the hash requires a c_contiguous buffer.
-      if obj.shape == ():
-        # 0d arrays need to be flattened because viewing them as bytes
-        # raises a ValueError exception.
-        obj_c_contiguous = obj.flatten()
-      elif obj.flags.c_contiguous:
-        obj_c_contiguous = obj
-      elif obj.flags.f_contiguous:
-        obj_c_contiguous = obj.T
-      else:
-        # Cater for non-single-segment arrays: this creates a
-        # copy, and thus aleviates this issue.
-        # XXX: There might be a more efficient way of doing this
-        obj_c_contiguous = obj.flatten()
-
-      # View the array as bytes to support dtypes like datetime64
-      self._hash.update(memoryview(obj_c_contiguous.view(np.uint8)))
-
-      # The object will be pickled by the pickler hashed at the end.
-      obj = (obj.__class__, ("HASHED", obj.dtype, obj.shape, obj.strides))
-    elif isinstance(obj, np.dtype):
-      # Atomic dtype objects are interned by their default constructor:
-      # np.dtype("f8") is np.dtype("f8")
-      # This interning is not maintained by a
-      # pickle.loads + pickle.dumps cycle, because __reduce__
-      # uses copy=True in the dtype constructor. This
-      # non-deterministic behavior causes the internal memoizer
-      # of the hasher to generate different hash values
-      # depending on the history of the dtype object.
-      # To prevent the hash from being sensitive to this, we use
-      # .descr which is a full (and never interned) description of
-      # the array dtype according to the numpy doc.
-      obj = (obj.__class__, ("HASHED", obj.descr))
-
-    Hasher.save(self, obj)
-
-
-def hash_obj(obj, hash_name="md5") -> str:
-  if has_numpy:
-    return NumpyHasher(hash_name=hash_name).hash(obj)
-  else:
-    return Hasher(hash_name=hash_name).hash(obj)
-
-hash = hash_obj

relib-1.2.11/relib/measure_duration.py

@@ -1,19 +0,0 @@
-from time import time
-
-active_mds = []
-
-class measure_duration:
-  def __init__(self, name):
-    self.name = name
-    active_mds.append(self)
-
-  def __enter__(self):
-    self.start = time()
-
-  def __exit__(self, *_):
-    duration = round(time() - self.start, 4)
-    depth = len(active_mds) - 1
-    indent = ('──' * depth) + (' ' * (depth > 0))
-    text = '{}: {} seconds'.format(self.name, duration)
-    print(indent + text)
-    active_mds.remove(self)

relib-1.2.11/relib/utils.py

@@ -1,306 +0,0 @@
-import re
-from itertools import chain
-from typing import Any, Callable, Iterable, Literal, overload
-
-__all__ = [
-  "noop",
-  "clamp",
-  "non_none",
-  "as_any",
-  "list_split",
-  "drop_none",
-  "distinct",
-  "dict_firsts",
-  "distinct_by",
-  "sort_by",
-  "first",
-  "move_value",
-  "transpose_dict",
-  "make_combinations_by_dict",
-  "merge_dicts",
-  "intersect",
-  "ensure_tuple",
-  "key_of",
-  "omit",
-  "pick",
-  "dict_by",
-  "tuple_by",
-  "flatten",
-  "transpose",
-  "map_dict",
-  "deepen_dict",
-  "flatten_dict_inner",
-  "flatten_dict",
-  "group",
-  "reversed_enumerate",
-  "get_at",
-  "for_each",
-  "sized_partitions",
-  "num_partitions",
-  "df_from_array",
-  "StrFilter",
-  "str_filterer",
-]
-
-def noop() -> None:
-  pass
-
-@overload
-def clamp(value: int, low: int, high: int) -> int: ...
-@overload
-def clamp(value: float, low: float, high: float) -> float: ...
-def clamp(value: float, low: float, high: float) -> float:
-    return max(low, min(value, high))
-
-def non_none[T](obj: T | None) -> T:
-  assert obj is not None
-  return obj
-
-def as_any(obj: Any) -> Any:
-  return obj
-
-def list_split[T](iterable: Iterable[T], sep: T) -> list[list[T]]:
-  values = [sep, *iterable, sep]
-  split_at = [i for i, x in enumerate(values) if x is sep]
-  ranges = list(zip(split_at[0:-1], split_at[1:]))
-  return [
-    values[start + 1:end]
-    for start, end in ranges
-  ]
-
-def drop_none[T](iterable: Iterable[T | None]) -> list[T]:
-  return [x for x in iterable if x is not None]
-
-def distinct[T](iterable: Iterable[T]) -> list[T]:
-  return list(dict.fromkeys(iterable))
-
-def dict_firsts[T, K](pairs: Iterable[tuple[K, T]]) -> dict[K, T]:
-  result: dict[K, T] = {}
-  for key, item in pairs:
-    if key not in result:
-      result[key] = item
-  return result
-
-def distinct_by[T](pairs: Iterable[tuple[object, T]]) -> list[T]:
-  return list(dict_firsts(pairs).values())
-
-def sort_by[T](pairs: Iterable[tuple[Any, T]]) -> list[T]:
-  pairs = sorted(pairs, key=lambda p: p[0])
-  return [v for _, v in pairs]
-
-def first[T](iterable: Iterable[T]) -> T | None:
-  return next(iter(iterable), None)
-
-def move_value[T](iterable: Iterable[T], from_i: int, to_i: int) -> list[T]:
-  values = list(iterable)
-  values.insert(to_i, values.pop(from_i))
-  return values
-
-def transpose_dict(des):
-  if isinstance(des, list):
-    keys = list(des[0].keys()) if des else []
-    length = len(des)
-    return {
-      key: [des[i][key] for i in range(length)]
-      for key in keys
-    }
-  elif isinstance(des, dict):
-    keys = list(des.keys())
-    length = len(des[keys[0]]) if keys else 0
-    return [
-      {key: des[key][i] for key in keys}
-      for i in range(length)
-    ]
-  raise ValueError("transpose_dict only accepts dict or list")
-
-def make_combinations_by_dict(des, keys=None, pairs=[]):
-  keys = sorted(des.keys()) if keys is None else keys
-  if len(keys) == 0:
-    return [dict(pairs)]
-  key = keys[0]
-  remaining_keys = keys[1:]
-  new_pairs = [(key, val) for val in des[key]]
-  return flatten([
-    make_combinations_by_dict(des, remaining_keys, [pair] + pairs)
-    for pair in new_pairs
-  ])
-
-def merge_dicts[T, K](*dicts: dict[K, T]) -> dict[K, T]:
-  if len(dicts) == 1:
-    return dicts[0]
-  result = {}
-  for d in dicts:
-    result.update(d)
-  return result
-
-def intersect[T](*iterables: Iterable[T]) -> list[T]:
-  return list(set.intersection(*map(set, iterables)))
-
-def ensure_tuple[T](value: T | tuple[T, ...]) -> tuple[T, ...]:
-  return value if isinstance(value, tuple) else (value,)
-
-def key_of[T, U](dicts: Iterable[dict[T, U]], key: T) -> list[U]:
-  return [d[key] for d in dicts]
-
-def omit[T, K](d: dict[K, T], keys: Iterable[K]) -> dict[K, T]:
-  if keys:
-    d = dict(d)
-    for key in keys:
-      del d[key]
-  return d
-
-def pick[T, K](d: dict[K, T], keys: Iterable[K]) -> dict[K, T]:
-  return {key: d[key] for key in keys}
-
-def dict_by[T, K](keys: Iterable[K], values: Iterable[T]) -> dict[K, T]:
-  return dict(zip(keys, values))
-
-def tuple_by[T, K](d: dict[K, T], keys: Iterable[K]) -> tuple[T, ...]:
-  return tuple(d[key] for key in keys)
-
-@overload
-def flatten[T](iterable: Iterable[T], depth: Literal[0]) -> list[T]: ...
-@overload
-def flatten[T](iterable: Iterable[Iterable[T]], depth: Literal[1] = 1) -> list[T]: ...
-@overload
-def flatten[T](iterable: Iterable[Iterable[Iterable[T]]], depth: Literal[2]) -> list[T]: ...
-@overload
-def flatten[T](iterable: Iterable[Iterable[Iterable[Iterable[T]]]], depth: Literal[3]) -> list[T]: ...
-@overload
-def flatten[T](iterable: Iterable[Iterable[Iterable[Iterable[Iterable[T]]]]], depth: Literal[4]) -> list[T]: ...
-@overload
-def flatten(iterable: Iterable, depth: int) -> list: ...
-
-def flatten(iterable: Iterable, depth: int = 1) -> list:
-  for _ in range(depth):
-    iterable = chain.from_iterable(iterable)
-  return list(iterable)
-
-@overload
-def transpose[T1, T2](tuples: Iterable[tuple[T1, T2]], default_num_returns: int = 0) -> tuple[list[T1], list[T2]]: ...
-@overload
-def transpose[T1, T2, T3](tuples: Iterable[tuple[T1, T2, T3]], default_num_returns: int = 0) -> tuple[list[T1], list[T2], list[T3]]: ...
-@overload
-def transpose[T1, T2, T3, T4](tuples: Iterable[tuple[T1, T2, T3, T4]], default_num_returns: int = 0) -> tuple[list[T1], list[T2], list[T3], list[T4]]: ...
-@overload
-def transpose[T1, T2, T3, T4, T5](tuples: Iterable[tuple[T1, T2, T3, T4, T5]], default_num_returns: int = 0) -> tuple[list[T1], list[T2], list[T3], list[T4], list[T5]]: ...
-@overload
-def transpose(tuples: Iterable[tuple], default_num_returns: int = 0) -> tuple[list, ...]: ...
-
-def transpose(tuples: Iterable[tuple], default_num_returns=0) -> tuple[list, ...]:
-  output = tuple(zip(*tuples))
-  if not output:
-    return ([],) * default_num_returns
-  return tuple(map(list, output))
-
-def map_dict[T, U, K](fn: Callable[[T], U], d: dict[K, T]) -> dict[K, U]:
-  return {key: fn(value) for key, value in d.items()}
-
-@overload
-def deepen_dict[K1, U](d: dict[tuple[K1], U]) -> dict[K1, U]: ...
-@overload
-def deepen_dict[K1, K2, U](d: dict[tuple[K1, K2], U]) -> dict[K1, dict[K2, U]]: ...
-@overload
-def deepen_dict[K1, K2, K3, U](d: dict[tuple[K1, K2, K3], U]) -> dict[K1, dict[K2, dict[K3, U]]]: ...
-@overload
-def deepen_dict[K1, K2, K3, K4, U](d: dict[tuple[K1, K2, K3, K4], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, U]]]]: ...
-@overload
-def deepen_dict[K1, K2, K3, K4, K5, U](d: dict[tuple[K1, K2, K3, K4, K5], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, dict[K5, U]]]]]: ...
-@overload
-def deepen_dict[K1, K2, K3, K4, K5, K6, U](d: dict[tuple[K1, K2, K3, K4, K5, K6], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, dict[K5, dict[K6, U]]]]]]: ...
-def deepen_dict(d: dict[tuple[Any, ...], Any]) -> dict:
-  output = {}
-  if () in d:
-    return d[()]
-  for (*tail, head), value in d.items():
-    curr = output
-    for key in tail:
-      curr = curr.setdefault(key, {})
-    curr[head] = value
-  return output
-
-def flatten_dict_inner(d, prefix=()):
-  for key, value in d.items():
-    if not isinstance(value, dict) or value == {}:
-      yield prefix + (key,), value
-    else:
-      yield from flatten_dict_inner(value, prefix + (key,))
-
-def flatten_dict(deep_dict: dict, prefix=()) -> dict:
-  return dict(flatten_dict_inner(deep_dict, prefix))
-
-def group[T, K](pairs: Iterable[tuple[K, T]]) -> dict[K, list[T]]:
-  values_by_key = {}
-  for key, value in pairs:
-    values_by_key.setdefault(key, []).append(value)
-  return values_by_key
-
-def reversed_enumerate[T](values: list[T] | tuple[T, ...]) -> Iterable[tuple[int, T]]:
-  return zip(reversed(range(len(values))), reversed(values))
-
-def get_at[T](d: dict, keys: Iterable[Any], default: T) -> T:
-  try:
-    for key in keys:
-      d = d[key]
-  except KeyError:
-    return default
-  return as_any(d)
-
-def for_each[T](func: Callable[[T], Any], iterable: Iterable[T]) -> None:
-  for item in iterable:
-    func(item)
-
-def sized_partitions[T](values: Iterable[T], part_size: int) -> list[list[T]]:
-  # "chunk"
-  if not isinstance(values, list):
-    values = list(values)
-  num_parts = (len(values) / part_size).__ceil__()
-  return [values[i * part_size:(i + 1) * part_size] for i in range(num_parts)]
-
-def num_partitions[T](values: Iterable[T], num_parts: int) -> list[list[T]]:
-  if not isinstance(values, list):
-    values = list(values)
-  part_size = (len(values) / num_parts).__ceil__()
-  return [values[i * part_size:(i + 1) * part_size] for i in range(num_parts)]
-
-def _cat_tile(cats, n_tile):
-  import numpy as np
-  return cats[np.tile(np.arange(len(cats)), n_tile)]
-
-def df_from_array(
-  value_cols: dict[str, Any],
-  dim_labels: list[tuple[str, list[str | int | float]]],
-  indexed=False,
-):
-  import numpy as np
-  import pandas as pd
-  dim_sizes = np.array([len(labels) for _, labels in dim_labels])
-  assert all(array.shape == tuple(dim_sizes) for array in value_cols.values())
-  array_offsets = [
-    (dim_sizes[i + 1:].prod(), dim_sizes[:i].prod())
-    for i in range(len(dim_sizes))
-  ]
-  category_cols = {
-    dim: _cat_tile(pd.Categorical(labels).repeat(repeats), tiles)
-    for (dim, labels), (repeats, tiles) in zip(dim_labels, array_offsets)
-  }
-  value_cols = {name: array.reshape(-1) for name, array in value_cols.items()}
-  df = pd.DataFrame({**category_cols, **value_cols}, copy=False)
-  if indexed:
-    df = df.set_index([name for name, _ in dim_labels])
-  return df
-
-StrFilter = Callable[[str], bool]
-
-def str_filterer(
-  include_patterns: list[re.Pattern[str]] = [],
-  exclude_patterns: list[re.Pattern[str]] = [],
-) -> StrFilter:
-  def str_filter(string: str) -> bool:
-    if any(pattern.search(string) for pattern in exclude_patterns):
-      return False
-    if not include_patterns:
-      return True
-    return any(pattern.search(string) for pattern in include_patterns)
-
-  return str_filter