relib 1.0.9__tar.gz

relib-1.0.9/.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+/dist
+.DS_Store

relib-1.0.9/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2023 Hampus Hallman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

relib-1.0.9/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.3
+Name: relib
+Version: 1.0.9
+Project-URL: Repository, https://github.com/Reddan/relib.git
+Author: Hampus Hallman
+License: Copyright 2023 Hampus Hallman
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: numpy>=2.1.0
+Requires-Dist: termcolor>=2.4.0

relib-1.0.9/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "relib"
+version = "1.0.9"
+requires-python = ">=3.12"
+dependencies = [
+  "numpy>=2.1.0",
+  "termcolor>=2.4.0",
+]
+authors = [
+  {name = "Hampus Hallman"}
+]
+# description = ""
+readme = "README.md"
+license = {file = "LICENSE"}
+
+[project.urls]
+Repository = "https://github.com/Reddan/relib.git"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["relib"]

relib-1.0.9/relib/__init__.py

@@ -0,0 +1,31 @@
+from .utils import (
+  non_none,
+  list_split,
+  drop_none,
+  distinct,
+  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,
+  group,
+  sized_partitions,
+  num_partitions,
+  df_from_array,
+  StrFilter,
+  str_filterer,
+)
+from .raypipe import raypipe
+from .hashing import hash
+from .measure_duration import measure_duration

relib-1.0.9/relib/hashing.py

@@ -0,0 +1,255 @@
+"""
+Fast cryptographic hash of Python objects, with a special case for fast
+hashing of numpy arrays.
+"""
+
+# 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 struct
+import io
+import decimal
+
+Pickler = pickle._Pickler
+_bytes_or_unicode = (bytes, str)
+
+
+class _ConsistentSet(object):
+  """ Class used to ensure the hash of Sets is preserved
+    whatever the order of its items.
+  """
+  def __init__(self, set_sequence):
+    # Forces order of elements in set to ensure consistent hash.
+    try:
+      # Trying first to order the set assuming the type of elements is
+      # consistent and orderable.
+      # This fails on python 3 when elements are unorderable
+      # but we keep it in a try as it's faster.
+      self._sequence = sorted(set_sequence)
+    except (TypeError, decimal.InvalidOperation):
+      # If elements are unorderable, sorting them using their hash.
+      # This is slower but works in any case.
+      self._sequence = sorted((hash(e) for e in 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()
+    # By default we want a pickle protocol that only changes with
+    # the major python version and not the minor one
+    protocol = pickle.HIGHEST_PROTOCOL
+    Pickler.__init__(self, self.stream, protocol=protocol)
+    # Initialise the hash obj
+    self._hash = hashlib.new(hash_name)
+
+  def hash(self, obj, return_digest=True):
+    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)
+    if return_digest:
+      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_or_unicode):
+      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, pack=struct.pack):
+    # We have to override this method in order to deal with objects
+    # defined interactively in IPython that are not injected in
+    # __main__
+    kwargs = dict(name=name, pack=pack)
+    if sys.version_info >= (3, 4):
+      del kwargs['pack']
+    try:
+      Pickler.save_global(self, obj, **kwargs)
+    except pickle.PicklingError:
+      Pickler.save_global(self, obj, **kwargs)
+      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)
+
+  dispatch = Pickler.dispatch.copy()
+  # builtin
+  dispatch[type(len)] = save_global
+  # type
+  dispatch[type(object)] = save_global
+  # classobj
+  dispatch[type(Pickler)] = save_global
+  # function
+  dispatch[type(pickle.dump)] = save_global
+
+  def _batch_setitems(self, items):
+    # forces order of keys in dict to ensure consistent hash.
+    try:
+      # Trying first to compare dict assuming the type of keys is
+      # consistent and orderable.
+      # This fails on python 3 when keys are unorderable
+      # but we keep it in a try as it's faster.
+      Pickler._batch_setitems(self, iter(sorted(items)))
+    except TypeError:
+      # If keys are unorderable, sorting them using their hash. This is
+      # slower but works in any case.
+      Pickler._batch_setitems(self, iter(sorted((hash(k), v)
+                           for k, v in items)))
+
+  def save_set(self, set_items):
+    # forces order of items in Set to ensure consistent hash
+    Pickler.save(self, _ConsistentSet(set_items))
+
+  dispatch[type(set())] = save_set
+
+
+class NumpyHasher(Hasher):
+  """ Special case the hasher for when numpy is loaded.
+  """
+
+  def __init__(self, hash_name='md5', coerce_mmap=False):
+    """
+      Parameters
+      ----------
+      hash_name: string
+        The hash algorithm to be used
+      coerce_mmap: boolean
+        Make no difference between np.memmap and np.ndarray
+        objects.
+    """
+    self.coerce_mmap = coerce_mmap
+    Hasher.__init__(self, hash_name=hash_name)
+    # delayed import of numpy, to avoid tight coupling
+    import numpy as np
+    self.np = np
+    if hasattr(np, 'getbuffer'):
+      self._getbuffer = np.getbuffer
+    else:
+      self._getbuffer = memoryview
+
+  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.
+    """
+    if isinstance(obj, self.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()
+
+      # memoryview is not supported for some dtypes, e.g. datetime64, see
+      # https://github.com/numpy/numpy/issues/4983. The
+      # workaround is to view the array as bytes before
+      # taking the memoryview.
+      self._hash.update(
+        self._getbuffer(obj_c_contiguous.view(self.np.uint8)))
+
+      # We store the class, to be able to distinguish between
+      # Objects with the same binary content, but different
+      # classes.
+      if self.coerce_mmap and isinstance(obj, self.np.memmap):
+        # We don't make the difference between memmap and
+        # normal ndarrays, to be able to reload previously
+        # computed results with memmap.
+        klass = self.np.ndarray
+      else:
+        klass = obj.__class__
+      # We also return the dtype and the shape, to distinguish
+      # different views on the same data with different dtypes.
+
+      # The object will be pickled by the pickler hashed at the end.
+      obj = (klass, ('HASHED', obj.dtype, obj.shape, obj.strides))
+    elif isinstance(obj, self.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.
+      klass = obj.__class__
+      obj = (klass, ('HASHED', obj.descr))
+    Hasher.save(self, obj)
+
+
+def hash(obj, hash_name='md5', coerce_mmap=False):
+  """ Quick calculation of a hash to identify uniquely Python objects
+    containing numpy arrays.
+    Parameters
+    -----------
+    hash_name: 'md5' or 'sha1'
+      Hashing algorithm used. sha1 is supposedly safer, but md5 is
+      faster.
+    coerce_mmap: boolean
+      Make no difference between np.memmap and np.ndarray
+  """
+  if 'numpy' in sys.modules:
+    hasher = NumpyHasher(hash_name=hash_name, coerce_mmap=coerce_mmap)
+  else:
+    hasher = Hasher(hash_name=hash_name)
+  return hasher.hash(obj)

relib-1.0.9/relib/measure_duration.py

@@ -0,0 +1,20 @@
+from time import time
+from termcolor import colored
+
+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(colored(indent + text, attrs=['dark']))
+    active_mds.remove(self)

relib-1.0.9/relib/raypipe.py

@@ -0,0 +1,60 @@
+import numpy as np
+
+class Raypipe():
+  def __init__(self, handlers=[]):
+    self.handlers = handlers
+
+  def __add_to_pipeline(self, handler_type, fn, kwargs={}):
+    handler = (handler_type, fn, kwargs)
+    return Raypipe(self.handlers + [handler])
+
+  def map(self, fn):
+    return self.__add_to_pipeline('map', fn)
+
+  def flatten(self):
+    return self.__add_to_pipeline('flatten', None)
+
+  def flat_map(self, fn):
+    return self.map(fn).flatten()
+
+  def filter(self, fn):
+    return self.__add_to_pipeline('filter', fn)
+
+  def sort(self, fn=None, reverse=False):
+    return self.__add_to_pipeline('sort', fn, dict(reverse=reverse))
+
+  def distinct(self):
+    return self.__add_to_pipeline('distinct', None)
+
+  def sort_distinct(self, fn=None, reverse=False):
+    return self.distinct().sort(fn, reverse=reverse)
+
+  def do(self, fn):
+    return self.__add_to_pipeline('do', fn)
+
+  def shuffle(self, random_state=42):
+    return self.__add_to_pipeline('shuffle', None, dict(random_state=random_state))
+
+  def to_numpy(self):
+    return self.__add_to_pipeline('do', np.array)
+
+  def compute(self, values):
+    for handler_type, handler_fn, handler_kwargs in self.handlers:
+      if handler_type == 'map':
+        values = [handler_fn(val) for val in values]
+      elif handler_type == 'flatten':
+        values = [item for sublist in values for item in sublist]
+      elif handler_type == 'filter':
+        values = [val for val in values if handler_fn(val)]
+      elif handler_type == 'sort':
+        values.sort(key=handler_fn, reverse=handler_kwargs['reverse'])
+      elif handler_type == 'distinct':
+        values = list(set(values))
+      elif handler_type == 'do':
+        values = handler_fn(values)
+      elif handler_type == 'shuffle':
+        from sklearn.utils import shuffle
+        values = shuffle(values, random_state=handler_kwargs['random_state'])
+    return values
+
+raypipe = Raypipe()

relib-1.0.9/relib/utils.py

@@ -0,0 +1,208 @@
+from typing import TypeVar, Iterable, Callable, Any, cast, overload
+from itertools import chain
+import numpy as np
+import re
+
+T = TypeVar('T')
+U = TypeVar('U')
+K = TypeVar('K')
+K1, K2, K3, K4, K5, K6 = TypeVar('K1'), TypeVar('K2'), TypeVar('K3'), TypeVar('K4'), TypeVar('K5'), TypeVar('K6')
+
+def non_none(obj: T | None) -> T:
+  assert obj is not None
+  return obj
+
+def list_split(l: list[T], sep: T) -> list[list[T]]:
+  l = [sep, *l, sep]
+  split_at = [i for i, x in enumerate(l) if x is sep]
+  ranges = list(zip(split_at[0:-1], split_at[1:]))
+  return [
+    l[start + 1:end]
+    for start, end in ranges
+  ]
+
+def drop_none(l: Iterable[T | None]) -> list[T]:
+  return [x for x in l if x is not None]
+
+def distinct(items: Iterable[T]) -> list[T]:
+  return list(set(items))
+
+def first(iterable: Iterable[T]) -> T | None:
+  return next(iter(iterable), None)
+
+def move_value(l: Iterable[T], from_i: int, to_i: int) -> list[T]:
+  l = list(l)
+  l.insert(to_i, l.pop(from_i))
+  return l
+
+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 == 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(*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(*lists: Iterable[T]) -> list[T]:
+  return list(set.intersection(*map(set, lists)))
+
+def ensure_tuple(value: T | tuple[T, ...]) -> tuple[T, ...]:
+  return value if isinstance(value, tuple) else (value,)
+
+def key_of(dicts: Iterable[dict[T, U]], key: T) -> list[U]:
+  return [d[key] for d in dicts]
+
+def omit(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(d: dict[K, T], keys: Iterable[K]) -> dict[K, T]:
+  return {key: d[key] for key in keys}
+
+def dict_by(keys: Iterable[K], values: Iterable[T]) -> dict[K, T]:
+  return dict(zip(keys, values))
+
+def tuple_by(d: dict[K, T], keys: Iterable[K]) -> tuple[T, ...]:
+  return tuple(d[key] for key in keys)
+
+def flatten(l: Iterable[Iterable[T]]) -> list[T]:
+  return list(chain.from_iterable(l))
+
+def transpose(tuples, default_num_returns=0):
+  output = tuple(zip(*tuples))
+  if not output:
+    return ([],) * default_num_returns
+  return tuple(map(list, output))
+
+def map_dict(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(d: dict[tuple[K1], U]) -> dict[K1, U]: ...
+
+@overload
+def deepen_dict(d: dict[tuple[K1, K2], U]) -> dict[K1, dict[K2, U]]: ...
+
+@overload
+def deepen_dict(d: dict[tuple[K1, K2, K3], U]) -> dict[K1, dict[K2, dict[K3, U]]]: ...
+
+@overload
+def deepen_dict(d: dict[tuple[K1, K2, K3, K4], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, U]]]]: ...
+
+@overload
+def deepen_dict(d: dict[tuple[K1, K2, K3, K4, K5], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, dict[K5, U]]]]]: ...
+
+@overload
+def deepen_dict(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 = {}
+  for (*tail, head), value in d.items():
+    curr = output
+    for key in tail:
+      if key not in curr:
+        curr[key] = {}
+      curr = curr[key]
+    curr[head] = value
+  return output
+
+def group(pairs: Iterable[tuple[K, T]]) -> dict[K, list[T]]:
+  values_by_key = {}
+  for key, value in pairs:
+    if key not in values_by_key:
+      values_by_key[key] = []
+    values_by_key[key].append(value)
+  return values_by_key
+
+def get_at(d: dict, keys: Iterable[Any], default: T) -> T:
+  try:
+    for key in keys:
+      d = d[key]
+  except KeyError:
+    return default
+  return cast(Any, d)
+
+def sized_partitions(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(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):
+  return cats[np.tile(np.arange(len(cats)), n_tile)]
+
+def df_from_array(
+  value_cols: dict[str, np.ndarray],
+  dim_labels: list[tuple[str, list[str | int | float]]],
+  indexed=False,
+):
+  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.0.9/uv.lock

@@ -0,0 +1,62 @@
+version = 1
+requires-python = ">=3.12"
+
+[[package]]
+name = "numpy"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/54/a4/f8188c4f3e07f7737683588210c073478abcb542048cf4ab6fedad0b458a/numpy-2.1.0.tar.gz", hash = "sha256:7dc90da0081f7e1da49ec4e398ede6a8e9cc4f5ebe5f9e06b443ed889ee9aaa2", size = 18868922 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/eb/f5/a06a231cbeea4aff841ff744a12e4bf4d4407f2c753d13ce4563aa126c90/numpy-2.1.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fe76d75b345dc045acdbc006adcb197cc680754afd6c259de60d358d60c93736", size = 20882951 },
+    { url = "https://files.pythonhosted.org/packages/70/1d/4ad38e3a1840f72c29595c06b103ecd9119f260e897ff7e88a74adb0ca14/numpy-2.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f358ea9e47eb3c2d6eba121ab512dfff38a88db719c38d1e67349af210bc7529", size = 13491878 },
+    { url = "https://files.pythonhosted.org/packages/b4/3b/569055d01ed80634d6be6ceef8fb28eb0866e4f98c2d97667dcf9fae3e22/numpy-2.1.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:dd94ce596bda40a9618324547cfaaf6650b1a24f5390350142499aa4e34e53d1", size = 5087346 },
+    { url = "https://files.pythonhosted.org/packages/24/37/212dd6fbd298c467b80d4d6217b2bc902b520e96a967b59f72603bf1142f/numpy-2.1.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:b47c551c6724960479cefd7353656498b86e7232429e3a41ab83be4da1b109e8", size = 6618269 },
+    { url = "https://files.pythonhosted.org/packages/33/4d/435c143c06e16c8bfccbfd9af252b0a8ac7897e0c0e36e539d75a75e91b4/numpy-2.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0756a179afa766ad7cb6f036de622e8a8f16ffdd55aa31f296c870b5679d745", size = 13695244 },
+    { url = "https://files.pythonhosted.org/packages/48/3e/bf807eb050abc23adc556f34fcf931ca2d67ad8dfc9c17fcd9332c01347f/numpy-2.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:24003ba8ff22ea29a8c306e61d316ac74111cebf942afbf692df65509a05f111", size = 16040181 },
+    { url = "https://files.pythonhosted.org/packages/cd/a9/40dc96b5d43076836d82d1e84a3a4a6a4c2925a53ec0b7f31271434ff02c/numpy-2.1.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:b34fa5e3b5d6dc7e0a4243fa0f81367027cb6f4a7215a17852979634b5544ee0", size = 16407920 },
+    { url = "https://files.pythonhosted.org/packages/cc/77/39e44cf0a6eb0f93b18ffb00f1964b2c471b1df5605aee486c221b06a8e4/numpy-2.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c4f982715e65036c34897eb598d64aef15150c447be2cfc6643ec7a11af06574", size = 14170943 },
+    { url = "https://files.pythonhosted.org/packages/54/02/f0a3c2ec1622dc4346bd126e2578948c7192b3838c893a3d215738fb367b/numpy-2.1.0-cp312-cp312-win32.whl", hash = "sha256:c4cd94dfefbefec3f8b544f61286584292d740e6e9d4677769bc76b8f41deb02", size = 6235947 },
+    { url = "https://files.pythonhosted.org/packages/8c/bf/d9d214a9dff020ad1663f1536f45d34e052e4c7f630c46cd363e785e3231/numpy-2.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:a0cdef204199278f5c461a0bed6ed2e052998276e6d8ab2963d5b5c39a0500bc", size = 12566546 },
+    { url = "https://files.pythonhosted.org/packages/c3/16/6b536e1b67624178e3631a3fa60c9c1b5ee7cda2fa9492c4f2de01bfcb06/numpy-2.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8ab81ccd753859ab89e67199b9da62c543850f819993761c1e94a75a814ed667", size = 20833354 },
+    { url = "https://files.pythonhosted.org/packages/52/87/130e95aa8a6383fc3de4fdaf7adc629289b79b88548fb6e35e9d924697d7/numpy-2.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:442596f01913656d579309edcd179a2a2f9977d9a14ff41d042475280fc7f34e", size = 13506169 },
+    { url = "https://files.pythonhosted.org/packages/d9/c2/0fcf68c67681f9ad9d76156b4606f60b48748ead76d4ba19b90aecd4b626/numpy-2.1.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:848c6b5cad9898e4b9ef251b6f934fa34630371f2e916261070a4eb9092ffd33", size = 5072908 },
+    { url = "https://files.pythonhosted.org/packages/72/40/e21bbbfae665ef5fa1dfd7eae1c5dc93ba9d3b36e39d2d38789dd8c22d56/numpy-2.1.0-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:54c6a63e9d81efe64bfb7bcb0ec64332a87d0b87575f6009c8ba67ea6374770b", size = 6604906 },
+    { url = "https://files.pythonhosted.org/packages/0e/ce/848967516bf8dd4f769886a883a4852dbc62e9b63b1137d2b9900f595222/numpy-2.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:652e92fc409e278abdd61e9505649e3938f6d04ce7ef1953f2ec598a50e7c195", size = 13690864 },
+    { url = "https://files.pythonhosted.org/packages/15/72/2cebe04758e1123f625ed3221cb3c48602175ad619dd9b47de69689b4656/numpy-2.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ab32eb9170bf8ffcbb14f11613f4a0b108d3ffee0832457c5d4808233ba8977", size = 16036272 },
+    { url = "https://files.pythonhosted.org/packages/a7/b7/ae34ced7864b551e0ea01ce4e7acbe7ddf5946afb623dea39760b19bc8b0/numpy-2.1.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:8fb49a0ba4d8f41198ae2d52118b050fd34dace4b8f3fb0ee34e23eb4ae775b1", size = 16408978 },
+    { url = "https://files.pythonhosted.org/packages/4d/22/c9d696b87c5ce25e857d7745fe4f090373a2daf8c26f5e15b32b5db7bff7/numpy-2.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:44e44973262dc3ae79e9063a1284a73e09d01b894b534a769732ccd46c28cc62", size = 14168398 },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/63f74dccf86d4832d593bdbe06544f4a0a1b7e18e86e0db1e8231bf47c49/numpy-2.1.0-cp313-cp313-win32.whl", hash = "sha256:ab83adc099ec62e044b1fbb3a05499fa1e99f6d53a1dde102b2d85eff66ed324", size = 6232743 },
+    { url = "https://files.pythonhosted.org/packages/23/4b/e30a3132478c69df3e3e587fa87dcbf2660455daec92d8d52e7028a92554/numpy-2.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:de844aaa4815b78f6023832590d77da0e3b6805c644c33ce94a1e449f16d6ab5", size = 12560212 },
+    { url = "https://files.pythonhosted.org/packages/5a/1b/40e881a3a272c4861de1e43a3e7ee1559988dd12187463726d3b395a8874/numpy-2.1.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:343e3e152bf5a087511cd325e3b7ecfd5b92d369e80e74c12cd87826e263ec06", size = 20840821 },
+    { url = "https://files.pythonhosted.org/packages/d0/8e/5b7c08f9238f6cc18037f6fd92f83feaa8c19e9decb6bd075cad81f71fae/numpy-2.1.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f07fa2f15dabe91259828ce7d71b5ca9e2eb7c8c26baa822c825ce43552f4883", size = 13500478 },
+    { url = "https://files.pythonhosted.org/packages/65/32/bf9df25ef50761fcb3e089c745d2e195b35cc6506d032f12bb5cc28f6c43/numpy-2.1.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5474dad8c86ee9ba9bb776f4b99ef2d41b3b8f4e0d199d4f7304728ed34d0300", size = 5095825 },
+    { url = "https://files.pythonhosted.org/packages/50/34/d18c95bc5981ea3bb8e6f896aad12159a37dcc67b22cd9464fe3899612f7/numpy-2.1.0-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:1f817c71683fd1bb5cff1529a1d085a57f02ccd2ebc5cd2c566f9a01118e3b7d", size = 6611470 },
+    { url = "https://files.pythonhosted.org/packages/b4/4f/27d56e9f6222419951bfeef54bc0a71dc40c0ebeb248e1aa85655da6fa11/numpy-2.1.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3a3336fbfa0d38d3deacd3fe7f3d07e13597f29c13abf4d15c3b6dc2291cbbdd", size = 13647061 },
+    { url = "https://files.pythonhosted.org/packages/f9/e0/ae6e12a157c4ab415b380d0f3596cb9090a0c4acf48cd8cd7bc6d6b93d24/numpy-2.1.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a894c51fd8c4e834f00ac742abad73fc485df1062f1b875661a3c1e1fb1c2f6", size = 16006479 },
+    { url = "https://files.pythonhosted.org/packages/ab/da/b746668c7303bd73af262208abbfa8b1c86be12e9eccb0d3021ed8a58873/numpy-2.1.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:9156ca1f79fc4acc226696e95bfcc2b486f165a6a59ebe22b2c1f82ab190384a", size = 16383064 },
+    { url = "https://files.pythonhosted.org/packages/f4/51/c0dcadea0c281be5db32b29f7b977b17bdb53b7dbfcbc3b4f49288de8696/numpy-2.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:624884b572dff8ca8f60fab591413f077471de64e376b17d291b19f56504b2bb", size = 14135556 },
+]
+
+[[package]]
+name = "relib"
+version = "1.0.9"
+source = { editable = "." }
+dependencies = [
+    { name = "numpy" },
+    { name = "termcolor" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "numpy" },
+    { name = "termcolor" },
+]
+
+[[package]]
+name = "termcolor"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/10/56/d7d66a84f96d804155f6ff2873d065368b25a07222a6fd51c4f24ef6d764/termcolor-2.4.0.tar.gz", hash = "sha256:aab9e56047c8ac41ed798fa36d892a37aca6b3e9159f3e0c24bc64a9b3ac7b7a", size = 12664 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/5f/8c716e47b3a50cbd7c146f45881e11d9414def768b7cd9c5e6650ec2a80a/termcolor-2.4.0-py3-none-any.whl", hash = "sha256:9297c0df9c99445c2412e832e882a7884038a25617c60cea2ad69488d4040d63", size = 7719 },
+]