spookyhash 2.1.2__cp315-cp315-win32.whl

spookyhash/__init__.py

@@ -0,0 +1,243 @@
+"""A Python wrapper for SpookyHash version 2."""
+
+from __future__ import annotations
+
+import struct
+import typing
+from abc import ABC, abstractmethod
+from binascii import hexlify
+
+from . import _spookyhash
+
+if typing.TYPE_CHECKING:
+    import typing_extensions
+
+    _MessageT = bytes | memoryview[bytes] | typing_extensions.Buffer
+
+__all__ = ("hash32", "hash64", "hash128", "Hash32", "Hash64", "Hash128")
+__version__ = "2.1.2"
+
+
+# Utility function for homogenising data
+
+def _char_arr(message: _MessageT | None) -> memoryview[bytes]:
+    if message is None:
+        return memoryview(b"").cast("c")
+    if not isinstance(message, memoryview):
+        try:
+            message = memoryview(message)
+        except TypeError as e:
+            raise TypeError(
+                f"Expecting message to be bytes, memoryview, None, or a type "
+                f"that can be interpreted as memoryview (e.g. NumPy "
+                f"arrays); instead found "
+                f"{type(message).__module__}.{type(message).__name__}"
+            ) from e
+    if message.format != "c" or not message.contiguous:
+        message = message.cast("c")
+    if typing.TYPE_CHECKING:
+        message = typing.cast(memoryview[bytes], message)
+    return message
+
+
+# Oneshot hash functions
+
+
+def hash32(message: _MessageT, seed: int = 0) -> int:
+    """
+    Hash a single message in one call, produce 32-bit output.
+
+    :param message: message to hash
+    :param seed: 32-bit seed
+    :return: 32-bit hash
+    """
+    return _spookyhash.hash32(_char_arr(message), seed)
+
+
+def hash64(message: _MessageT, seed: int = 0) -> int:
+    """
+    Hash a single message in one call, produce 64-bit output.
+
+    :param message: message to hash
+    :param seed: 64-bit seed
+    :return: 64-bit hash
+    """
+    return _spookyhash.hash64(_char_arr(message), seed)
+
+
+def hash128_pair(
+    message: _MessageT,
+    seed1: int = 0,
+    seed2: int = 0,
+) -> tuple[int, int]:
+    """
+    Hash a single message in one call, produce 128-bit output.
+
+    :param message: message to hash
+    :param seed1: 64-bit seed 1
+    :param seed2: 64-bit seed 2
+    :return: Pair of 64-bit hash values
+    """
+    digest = _spookyhash.hash128(_char_arr(message), seed1=seed1, seed2=seed2)
+    return struct.unpack("=QQ", digest)
+
+
+def hash128(
+    message: _MessageT,
+    seed1: int = 0,
+    seed2: int = 0,
+) -> int:
+    """
+    Hash a single message in one call, produce 128-bit output.
+
+    :param message: message to hash
+    :param seed1: 64-bit seed 1
+    :param seed2: 64-bit seed 2
+    :return: 128-bit hash
+    """
+    val1, val2 = hash128_pair(message, seed1=seed1, seed2=seed2)
+    return val2 << 64 | val1
+
+
+# Incremental hash builders
+
+
+class Hash(ABC):
+    """Base class for incremental hash builders."""
+
+    digest_size: typing.ClassVar[int]
+    _hash_cls: typing.ClassVar[type[_spookyhash.Hash]]
+
+    def __init__(
+        self,
+        message: _MessageT | None = None,
+        seed1: int = 0,
+        seed2: int = 0,
+    ) -> None:
+        """
+        Initialise hash.
+
+        :param message: Optional initial message fragment
+        :param seed1: first seed
+        :param seed2: second seed
+        """
+        self._hash = self._hash_cls(seed1, seed2)
+        if message is not None:
+            self.update(message)
+
+    def __init_subclass__(cls) -> None:
+        super().__init_subclass__()
+        cls.digest_size = cls._hash_cls(0, 0).digest_size
+
+    def update(self, message: _MessageT | None) -> typing_extensions.Self:
+        """
+        Incrementally update hash with message fragment.
+
+        :param message: Message fragment
+        :return: Self
+        """
+        if message is not None:
+            self._hash.update(_char_arr(message))
+        return self
+
+    def digest(self) -> bytes:
+        """
+        Compute digest.
+
+        :return: Digest
+        """
+        return self._hash.digest()
+
+    def hexdigest(self) -> str:
+        """
+        Compute hex digest.
+
+        :return: Hex digest
+        """
+        return hexlify(self.digest()).decode("utf-8")
+
+    @abstractmethod
+    def final(self) -> int:
+        """
+        Compute the hash for the concatenation of all message fragments.
+
+        :return: Hash
+        """
+        raise NotImplementedError
+
+
+class Hash32(Hash):
+    """32-bit incremental hash builder."""
+
+    _hash_cls = _spookyhash.Hash32
+
+    def __init__(
+        self,
+        message: _MessageT | None = None,
+        seed: int = 0,
+    ) -> None:
+        """
+        Initialise 32-bit hash.
+
+        :param message: Optional initial message fragment
+        :param seed: 32-bit seed
+        """
+        super().__init__(message, seed, seed)
+
+    def final(self) -> int:
+        """
+        Compute the hash for the concatenation of all message fragments.
+
+        :return: Hash
+        """
+        return typing.cast(int, struct.unpack("=L", self.digest())[0])
+
+
+class Hash64(Hash):
+
+    _hash_cls = _spookyhash.Hash64
+
+    def __init__(
+        self,
+        message: _MessageT | None = None,
+        seed: int = 0,
+    ) -> None:
+        """
+        Initialise 64-bit hash.
+
+        :param message: Optional initial message fragment
+        :param seed: 64-bit seed
+        """
+        super().__init__(message, seed, seed)
+
+    def final(self) -> int:
+        """
+        Compute the hash for the concatenation of all message fragments.
+
+        :return: Hash
+        """
+        return typing.cast(int, struct.unpack("=Q", self.digest())[0])
+
+
+class Hash128(Hash):
+
+    _hash_cls = _spookyhash.Hash128
+
+    def final_pair(self) -> tuple[int, int]:
+        """
+        Compute the hash for the concatenation of all message fragments.
+
+        Returns a pair of 64-bit integer to match other common implementations.
+
+        :return: Pair of 64-bit integers representing the hash
+        """
+        return struct.unpack("=QQ", self.digest())
+
+    def final(self) -> int:
+        """
+        Compute the hash for the concatenation of all message fragments.
+
+        :return: Hash
+        """
+        hash1, hash2 = self.final_pair()
+        return hash2 << 64 | hash1

spookyhash/_spookyhash.pyi

@@ -0,0 +1,25 @@
+"""Type stubs for SpookyHash Cython code."""
+
+import typing
+
+import typing_extensions
+
+__all__ = ("hash32", "hash64", "hash128", "Hash", "Hash32", "Hash64", "Hash128")
+__version__: str
+
+def hash32(message: bytes | memoryview[bytes], seed: int = 0) -> int: ...
+def hash64(message: bytes | memoryview[bytes], seed: int = 0) -> int: ...
+def hash128(message: bytes | memoryview[bytes], seed1: int = 0, seed2: int = 0) -> bytes: ...
+
+@typing_extensions.disjoint_base
+class Hash:
+    def __new__(cls, seed1: int, seed2: int) -> typing_extensions.Self: ...
+
+    digest_size: int
+
+    def update(self, message: bytes | memoryview[bytes]) -> None: ...
+    def digest(self) -> bytes: ...
+
+class Hash32(Hash): ...
+class Hash64(Hash): ...
+class Hash128(Hash): ...

spookyhash-2.1.2.dist-info/METADATA

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: spookyhash
+Version: 2.1.2
+Summary: A Python wrapper for SpookyHash version 2
+Author-email: Alen Buhanec <alen.buhanec@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/buhanec/spookyhash
+Project-URL: Repository, https://github.com/buhanec/spookyhash
+Project-URL: Issues, https://github.com/buhanec/spookyhash/issues
+Keywords: SpookyHash,hashlib
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: typing
+Requires-Dist: mypy>=1.18; extra == "typing"
+Requires-Dist: typing-extensions; extra == "typing"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: hypothesis; extra == "test"
+Requires-Dist: numpy; (python_version >= "3.11" or sys_platform != "win32" or platform_machine != "ARM64") and extra == "test"
+Dynamic: license-file
+
+# spookyhash
+
+A Python wrapper of Bob Jenkins' [SpookyHash version 2](http://burtleburtle.net/bob/hash/spooky.html). Offers 32- 64- and 128-bit oneshot and incremental hashes.   
+
+# License
+
+> Licensed under the MIT license. See the LICENSE file in the repository root for more details.
+
+# Usage
+
+## Installation
+
+Available through [spookyhash - PyPI](https://pypi.org/project/spookyhash/) using `pip install spookyhash`.
+
+## Oneshot Hashes
+
+```python
+>>> import spookyhash
+
+>>> spookyhash.hash32(b'hello world')
+2617184861
+>>> spookyhash.hash32(b'hello world', seed=0x12345678)
+3380090220
+
+>>> spookyhash.hash64(b'hello world')
+14865987102431973981
+>>> spookyhash.hash64(b'hello world', seed=123)
+5719863273689036421
+
+>>> spookyhash.hash128(b'hello world')
+185933735475381961281710998418114941533
+>>> spookyhash.hash128(b'hello world', seed1=123_000, seed2=456_000)
+144121310386202441278894605216246194925
+
+>>> # For a more comparable result to other libraries
+>>> spookyhash.hash128_pair(b'hello world')
+(14865987102431973981, 10079487997037711397)
+>>> spookyhash.hash128_pair(b'hello world', seed1=123_000, seed2=456_000)
+(12678109464562819821, 7812831891108919044)
+```
+
+## Incremental Hashes
+
+```python
+>>> import spookyhash
+
+>>> sh = spookyhash.Hash32()
+>>> sh.update(b'hello')
+>>> sh.update(b' ')
+>>> sh.update(b'world')
+>>> sh.final()
+2617184861
+>>> sh.hexdigest()
+'5d12ff9b'
+
+>>> spookyhash.Hash64(b'hello ', seed=123).update(b'world').final()
+5719863273689036421
+
+>>> spookyhash.Hash64(b'hello ', seed=123).update(b'world').hexdigest()
+'85b609a05709614f'
+
+>>> sh = spookyhash.Hash128(seed1=123_000, seed2=456_000)
+>>> sh.update(b'hello world')
+>>> sh.final()
+144121310386202441278894605216246194925
+>>> sh.final_pair()
+(12678109464562819821, 7812831891108919044)
+>>> sh.hexdigest()
+'ede2c8f262b1f1af04f763f735c16c6c'
+```
+
+## `memoryview` Support
+
+Includes `memoryview` compatible types, such as NumPy arrays.
+
+```python
+>>> import spookyhash
+>>> import numpy as np
+
+>>> spookyhash.Hash64(np.arange(100, dtype=np.int32)).hexdigest()
+'43ab5363ad362c74'
+
+>>> spookyhash.Hash64(memoryview(b'hello world')).hexdigest()
+'5d12ff9b81984ece'
+```
+
+# Platform Independence
+
+If run on a big-endian system, the code would produce different hashes, but of equal quality.

spookyhash-2.1.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+spookyhash/__init__.py,sha256=oZjA7qdTpUzEfkpThNTWZR4VKWIweHYaIJXtYiWfibY,6335
+spookyhash/_spookyhash.cp315-win32.pyd,sha256=BH85roGVARwVMssODOy6Qb2ZioH3_T8NISCBju1KAho,144896
+spookyhash/_spookyhash.pyi,sha256=6tnHILp49jP7vQd30axW9gTNta53D8qICur8nfQxwHU,777
+spookyhash/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spookyhash-2.1.2.dist-info/licenses/LICENSE,sha256=_ap0xdBj8tPRjmdLWBpcz90D4o1c8YMe1hlOS4mT_6o,1090
+spookyhash-2.1.2.dist-info/METADATA,sha256=e13xm68lpsOiYALkS3ed8ImvpmdFAHDiHzkZU4pIVMM,3837
+spookyhash-2.1.2.dist-info/WHEEL,sha256=hw69xxiYuOcOqid9WoScsymTbZ3eDs5HQ4gUZZtdDhs,97
+spookyhash-2.1.2.dist-info/top_level.txt,sha256=zl2dLX8mCzkff0kkntLozTPeYaB2IZxT7_xQLb8s0NQ,11
+spookyhash-2.1.2.dist-info/RECORD,,

spookyhash-2.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: false
+Tag: cp315-cp315-win32
+

spookyhash-2.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Alen Buhanec
+
+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.

spookyhash-2.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+spookyhash