relib 1.2.0__tar.gz → 1.2.1__tar.gz

{relib-1.2.0 → relib-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: relib
-Version: 1.2.0
+Version: 1.2.1
 Project-URL: Repository, https://github.com/Reddan/relib.git
 Author: Hampus Hallman
 License: Copyright 2023 Hampus Hallman
@@ -10,4 +10,5 @@ License: Copyright 2023 Hampus Hallman
         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.0 → relib-1.2.1}/pyproject.toml

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

{relib-1.2.0 → relib-1.2.1}/relib/__init__.py

@@ -1,6 +1,8 @@
 from .utils import (
   clear_console,
+  console_link,
   non_none,
+  as_any,
   list_split,
   drop_none,
   distinct,
@@ -31,5 +33,5 @@ from .utils import (
   StrFilter,
   str_filterer,
 )
-from .hashing import hash
+from .hashing import hash, hash_obj
 from .measure_duration import measure_duration

relib-1.2.1/relib/hashing.py

@@ -0,0 +1,179 @@
+# 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.0 → relib-1.2.1}/relib/utils.py

@@ -1,21 +1,22 @@
 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 console_link(text, url):
+  return f"\033]8;;{url}\033\\{text}\033]8;;\033\\"
+
+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,16 +25,16 @@ 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]:
+def drop_none[T](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 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]:
+def move_value[T](l: Iterable[T], from_i: int, to_i: int) -> list[T]:
   l = list(l)
   l.insert(to_i, l.pop(from_i))
   return l
@@ -53,7 +54,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 +68,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,32 +76,32 @@ def merge_dicts(*dicts: dict[K, T]) -> dict[K, T]:
     result.update(d)
   return result
 
-def intersect(*lists: Iterable[T]) -> list[T]:
+def intersect[T](*lists: Iterable[T]) -> list[T]:
   return list(set.intersection(*map(set, lists)))
 
-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]:
+def flatten[T](l: Iterable[Iterable[T]]) -> list[T]:
   return list(chain.from_iterable(l))
 
 def transpose(tuples, default_num_returns=0):
@@ -109,27 +110,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 +146,31 @@ 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 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 → relib-1.2.1}/uv.lock

@@ -3,5 +3,5 @@ requires-python = ">=3.12"
 
 [[package]]
 name = "relib"
-version = "1.2.0"
+version = "1.2.1"
 source = { editable = "." }

relib-1.2.0/relib/hashing.py

@@ -1,255 +0,0 @@
-"""
-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) -> 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)
-  else:
-    hasher = Hasher(hash_name=hash_name)
-  return hasher.hash(obj)