relib 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

relib/__init__.py

@@ -1,6 +1,6 @@
 from .utils import (
-  clear_console,
   non_none,
+  as_any,
   list_split,
   drop_none,
   distinct,
@@ -25,11 +25,13 @@ from .utils import (
   group,
   reversed_enumerate,
   get_at,
+  for_each,
   sized_partitions,
   num_partitions,
   df_from_array,
   StrFilter,
   str_filterer,
 )
-from .hashing import hash
+from .system import read_json, write_json, clear_console, console_link
+from .hashing import hash, hash_obj
 from .measure_duration import measure_duration

relib/hashing.py

@@ -1,8 +1,3 @@
-"""
-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.
@@ -11,30 +6,25 @@ import pickle
 import hashlib
 import sys
 import types
-import struct
 import io
 import decimal
 
+try:
+  import numpy
+except:
+  has_numpy = False
+else:
+  has_numpy = True
+
 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))
+      self._sequence = sorted(map(hash_obj, set_sequence))
 
 
 class _MyHash(object):
@@ -45,35 +35,30 @@ class _MyHash(object):
 
 
 class Hasher(Pickler):
-  """ A subclass of pickler, to do cryptographic hashing, rather than
-    pickling.
-  """
+  """ A subclass of pickler, to do cryptographic hashing, rather than pickling. """
 
-  def __init__(self, hash_name='md5'):
+  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
+    # We want a pickle protocol that only changes with major Python versions
     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):
+  def hash(self, obj) -> str:
     try:
       self.dump(obj)
     except pickle.PicklingError as e:
-      e.args += ('PicklingError while hashing %r: %r' % (obj, 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()
+    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__'):
+      if hasattr(obj, "__func__"):
         func_name = obj.__func__.__name__
       else:
         func_name = obj.__name__
@@ -90,28 +75,25 @@ class Hasher(Pickler):
 
   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]]
+    # 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):
+    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, pack=struct.pack):
+  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__
-    kwargs = dict(name=name, pack=pack)
-    if sys.version_info >= (3, 4):
-      del kwargs['pack']
     try:
-      Pickler.save_global(self, obj, **kwargs)
+      Pickler.save_global(self, obj, name=name)
     except pickle.PicklingError:
-      Pickler.save_global(self, obj, **kwargs)
+      Pickler.save_global(self, obj, name=name)
       module = getattr(obj, "__module__", None)
-      if module == '__main__':
+      if module == "__main__":
         my_name = name
         if my_name is None:
           my_name = obj.__name__
@@ -121,67 +103,35 @@ class Hasher(Pickler):
           # 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)))
+      Pickler._batch_setitems(self, iter(sorted((hash_obj(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 = 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):
-  """ 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
+  def __init__(self, hash_name="md5"):
     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:
+    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 == ():
@@ -198,31 +148,14 @@ class NumpyHasher(Hasher):
         # 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.
+      # 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 = (klass, ('HASHED', obj.dtype, obj.shape, obj.strides))
-    elif isinstance(obj, self.np.dtype):
+      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')
+      # 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
@@ -232,24 +165,15 @@ class NumpyHasher(Hasher):
       # 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))
+      obj = (obj.__class__, ("HASHED", obj.descr))
+
     Hasher.save(self, obj)
 
 
-def hash(obj, hash_name='md5', coerce_mmap=False) -> str:
-  """ 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)
+def hash_obj(obj, hash_name="md5") -> str:
+  if has_numpy:
+    return NumpyHasher(hash_name=hash_name).hash(obj)
   else:
-    hasher = Hasher(hash_name=hash_name)
-  return hasher.hash(obj)
+    return Hasher(hash_name=hash_name).hash(obj)
+
+hash = hash_obj

relib/system.py

@@ -0,0 +1,18 @@
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+def read_json(path: Path) -> Any:
+  with path.open("r") as f:
+    return json.load(f)
+
+def write_json(path: Path, obj: Any) -> None:
+  with path.open("w") as f:
+    return json.dump(obj, f)
+
+def clear_console() -> None:
+  os.system("cls" if os.name == "nt" else "clear")
+
+def console_link(text, url) -> str:
+  return f"\033]8;;{url}\033\\{text}\033]8;;\033\\"

relib/utils.py

@@ -1,21 +1,15 @@
-import os
 import re
-from typing import TypeVar, Iterable, Callable, Any, cast, overload
+from typing import Iterable, Callable, Any, overload
 from itertools import chain
 
-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 clear_console():
-  os.system("cls" if os.name == "nt" else "clear")
-
-def non_none(obj: T | None) -> T:
+def non_none[T](obj: T | None) -> T:
   assert obj is not None
   return obj
 
-def list_split(l: list[T], sep: T) -> list[list[T]]:
+def as_any(obj: Any) -> Any:
+  return obj
+
+def list_split[T](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:]))
@@ -24,17 +18,17 @@ def list_split(l: list[T], sep: T) -> list[list[T]]:
     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 drop_none[T](iterable: Iterable[T | None]) -> list[T]:
+  return [x for x in iterable if x is not None]
 
-def distinct(items: Iterable[T]) -> list[T]:
-  return list(set(items))
+def distinct[T](items: Iterable[T]) -> list[T]:
+  return list(dict.fromkeys(items))
 
-def first(iterable: Iterable[T]) -> T | None:
+def first[T](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)
+def move_value[T](iterable: Iterable[T], from_i: int, to_i: int) -> list[T]:
+  l = list(iterable)
   l.insert(to_i, l.pop(from_i))
   return l
 
@@ -53,7 +47,7 @@ def transpose_dict(des):
       {key: des[key][i] for key in keys}
       for i in range(length)
     ]
-  raise ValueError('transpose_dict only accepts dict or list')
+  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
@@ -67,7 +61,7 @@ def make_combinations_by_dict(des, keys=None, pairs=[]):
     for pair in new_pairs
   ])
 
-def merge_dicts(*dicts: dict[K, T]) -> dict[K, T]:
+def merge_dicts[T, K](*dicts: dict[K, T]) -> dict[K, T]:
   if len(dicts) == 1:
     return dicts[0]
   result = {}
@@ -75,33 +69,33 @@ def merge_dicts(*dicts: dict[K, T]) -> dict[K, T]:
     result.update(d)
   return result
 
-def intersect(*lists: Iterable[T]) -> list[T]:
-  return list(set.intersection(*map(set, lists)))
+def intersect[T](*iterables: Iterable[T]) -> list[T]:
+  return list(set.intersection(*map(set, iterables)))
 
-def ensure_tuple(value: T | tuple[T, ...]) -> tuple[T, ...]:
+def ensure_tuple[T](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]:
+def key_of[T, U](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]:
+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(d: dict[K, T], keys: Iterable[K]) -> dict[K, T]:
+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(keys: Iterable[K], values: Iterable[T]) -> dict[K, T]:
+def dict_by[T, K](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, ...]:
+def tuple_by[T, K](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 flatten[T](iterable: Iterable[Iterable[T]]) -> list[T]:
+  return list(chain.from_iterable(iterable))
 
 def transpose(tuples, default_num_returns=0):
   output = tuple(zip(*tuples))
@@ -109,27 +103,21 @@ def transpose(tuples, default_num_returns=0):
     return ([],) * default_num_returns
   return tuple(map(list, output))
 
-def map_dict(fn: Callable[[T], U], d: dict[K, T]) -> dict[K, U]:
+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(d: dict[tuple[K1], U]) -> dict[K1, U]: ...
-
+def deepen_dict[K1, U](d: dict[tuple[K1], U]) -> dict[K1, U]: ...
 @overload
-def deepen_dict(d: dict[tuple[K1, K2], U]) -> dict[K1, dict[K2, U]]: ...
-
+def deepen_dict[K1, K2, U](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]]]: ...
-
+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(d: dict[tuple[K1, K2, K3, K4], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, U]]]]: ...
-
+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(d: dict[tuple[K1, K2, K3, K4, K5], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, dict[K5, U]]]]]: ...
-
+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(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[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:
@@ -151,31 +139,35 @@ def flatten_dict_inner(d, prefix=()):
 def flatten_dict(deep_dict: dict, prefix=()) -> dict:
   return dict(flatten_dict_inner(deep_dict, prefix))
 
-def group(pairs: Iterable[tuple[K, T]]) -> dict[K, list[T]]:
+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(l: list[T] | tuple[T, ...]) -> Iterable[tuple[int, T]]:
+def reversed_enumerate[T](l: list[T] | tuple[T, ...]) -> Iterable[tuple[int, T]]:
   return zip(reversed(range(len(l))), reversed(l))
 
-def get_at(d: dict, keys: Iterable[Any], default: T) -> T:
+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 cast(Any, d)
+  return as_any(d)
+
+def for_each[T](func: Callable[[T]], iterable: Iterable[T]) -> None:
+  for item in iterable:
+    func(item)
 
-def sized_partitions(values: Iterable[T], part_size: int) -> list[list[T]]:
+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(values: Iterable[T], num_parts: int) -> list[list[T]]:
+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__()

{relib-1.2.0.dist-info → relib-1.2.2.dist-info}/METADATA

@@ -1,13 +1,14 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: relib
-Version: 1.2.0
+Version: 1.2.2
 Project-URL: Repository, https://github.com/Reddan/relib.git
 Author: Hampus Hallman
-License: Copyright 2023 Hampus Hallman
+License: Copyright 2018-2025 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

relib-1.2.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+relib/__init__.py,sha256=dLFft8umAfLeZfTiecZ2Cx_-C-nKoBepUk-aWivI5ZE,627
+relib/hashing.py,sha256=DB_fnkj0ls01FgZbf4nPFHl4EBU8X_0OrmDvty4HlRE,6020
+relib/measure_duration.py,sha256=LCTo_D_qReNprD3fhtJ0daeWycS6xQE_cwxeg2_h0xo,456
+relib/system.py,sha256=H-SJccCVLNTDhWTT5jo1NFUiQJzHv2Z1xvq0OVrnJcM,431
+relib/utils.py,sha256=GXvz4BPvEXzOxqCg1hV2F2x1xmaftlSdfCobaF0UBK8,6900
+relib-1.2.2.dist-info/METADATA,sha256=tl7KPaFKh8TTJ9XPpHbvwmpdjpbLWu_q4Nq3jfFsNkE,1295
+relib-1.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+relib-1.2.2.dist-info/licenses/LICENSE,sha256=9xVsdtv_-uSyY9Xl9yujwAPm4-mjcCLeVy-ljwXEWbo,1059
+relib-1.2.2.dist-info/RECORD,,

{relib-1.2.0.dist-info → relib-1.2.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

{relib-1.2.0.dist-info → relib-1.2.2.dist-info}/licenses/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2023 Hampus Hallman
+Copyright 2018-2025 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:
 

relib-1.2.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-relib/__init__.py,sha256=BX3u0WkfNZhplVWOYvDwoAOWqpxSx2XZuJ1hw-x7Xy4,541
-relib/hashing.py,sha256=A3uNivDp51WRfNgvDiYDeAyIutG9GracQIzDhQkykdI,8950
-relib/measure_duration.py,sha256=LCTo_D_qReNprD3fhtJ0daeWycS6xQE_cwxeg2_h0xo,456
-relib/utils.py,sha256=qr1NSOI6Q41JKC9_lqPnCyXdh8J-4z_nHs5u-F_-ULg,6769
-relib-1.2.0.dist-info/METADATA,sha256=4WvNiywokzHmiv6SaQ_0hOMOlbxWfp1JFOV20xNCOfk,1268
-relib-1.2.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-relib-1.2.0.dist-info/licenses/LICENSE,sha256=t9LfkVbmcvZjP0x3Sq-jR38UfTNbNtRQvc0Q8HWmLak,1054
-relib-1.2.0.dist-info/RECORD,,