spookyhash 2.0.2__tar.gz → 2.1.1__tar.gz

spookyhash-2.1.1/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.0.2 → spookyhash-2.1.1}/MANIFEST.in

@@ -1 +1 @@
-include src/*.pyx src/*.pxd src/*.cpp src/*.h
+include src/*.pyx src/*.pxd src/*.cpp src/*.h

spookyhash-2.1.1/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: spookyhash
+Version: 2.1.1
+Summary: A Python wrapper for SpookyHash version 2
+Author-email: Alen Buhanec <alen.buhanec@gmail.com>
+License: 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.7
+Classifier: Programming Language :: Python :: 3.8
+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: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: hypothesis; 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)).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.0.2 → spookyhash-2.1.1}/README.md

@@ -1,4 +1,4 @@
-# spookyhash [<img src="https://img.shields.io/gitlab/pipeline/alen/spookyhash/main?gitlab_url=https%3A%2F%2Fgitlab.home.alen.sh%2F&label=Gitlab%20CI&style=flat-square" align="right">](https://gitlab.home.alen.sh/alen/spookyhash) [<img src="https://img.shields.io/travis/buhanec/spookyhash/main.svg?label=Travis+CI&style=flat-square" align="right">](https://travis-ci.org/buhanec/spookyhash) [<img src="https://img.shields.io/azure-devops/build/buhanec/aa771e37-5a75-4d92-8d99-d27975af994e/2/main?label=Azure%20DevOps&style=flat-square" align="right">](https://dev.azure.com/buhanec/spookyhash/_build)
+# 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.   
 
@@ -50,16 +50,38 @@ Available through [spookyhash - PyPI](https://pypi.org/project/spookyhash/) usin
 >>> 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)).hexdigest()
+'43ab5363ad362c74'
+
+>>> spookyhash.Hash64(memoryview(b'hello world')).hexdigest()
+'5d12ff9b81984ece'
 ```
 
 # Platform Independence

spookyhash-2.1.1/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+    "wheel",
+    "cython"
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+authors = [{name = "Alen Buhanec", email = "alen.buhanec@gmail.com"}]
+name = "spookyhash"
+description = "A Python wrapper for SpookyHash version 2"
+readme = "README.md"
+keywords = ["SpookyHash", "hashlib"]
+license = {text = "MIT"}
+classifiers = [
+    "Topic :: Software Development :: Libraries",
+    "Development Status :: 5 - Production/Stable",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Typing :: Typed",
+]
+dynamic = ["version"]
+
+[project.urls]
+Homepage = "https://github.com/buhanec/spookyhash"
+Repository = "https://github.com/buhanec/spookyhash"
+Issues = "https://github.com/buhanec/spookyhash/issues"
+
+[project.optional-dependencies]
+test = ["pytest", "hypothesis"]
+
+[tool.setuptools]
+py-modules = ["spookyhash"]
+
+[tool.setuptools.dynamic]
+version = {attr = "spookyhash.__version__"}

{spookyhash-2.0.2 → spookyhash-2.1.1}/setup.cfg

@@ -1,4 +1,4 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-
+[egg_info]
+tag_build = 
+tag_date = 0
+

spookyhash-2.1.1/setup.py

@@ -0,0 +1,22 @@
+from Cython.Build import cythonize
+from setuptools import Extension, setup
+
+
+setup(
+    ext_modules=cythonize(
+        [
+            Extension(
+                "_spookyhash",
+                ["src/spookyhash.pyx", "src/SpookyV2.cpp"],
+                language="c++",
+            ),
+        ],
+        compiler_directives={
+            "cdivision": True,
+            "boundscheck": False,
+            "wraparound": False,
+            "embedsignature": True,
+            "language_level": 3,
+        },
+    ),
+)

spookyhash-2.1.1/spookyhash.egg-info/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: spookyhash
+Version: 2.1.1
+Summary: A Python wrapper for SpookyHash version 2
+Author-email: Alen Buhanec <alen.buhanec@gmail.com>
+License: 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.7
+Classifier: Programming Language :: Python :: 3.8
+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: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: hypothesis; 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)).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.0.2 → spookyhash-2.1.1}/spookyhash.egg-info/SOURCES.txt

@@ -1,15 +1,18 @@
+LICENSE
 MANIFEST.in
 README.md
 pyproject.toml
 setup.py
+spookyhash.py
 spookyhash.egg-info/PKG-INFO
 spookyhash.egg-info/SOURCES.txt
 spookyhash.egg-info/dependency_links.txt
+spookyhash.egg-info/requires.txt
 spookyhash.egg-info/top_level.txt
 src/SpookyV2.cpp
 src/SpookyV2.h
 src/SpookyV2.pxd
 src/spookyhash.cpp
 src/spookyhash.pyx
-tests/__init__.py
+tests/test_readme.py
 tests/test_spooky_hash.py

spookyhash-2.1.1/spookyhash.egg-info/requires.txt

@@ -0,0 +1,4 @@
+
+[test]
+pytest
+hypothesis

spookyhash-2.1.1/spookyhash.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+_spookyhash
+spookyhash

spookyhash-2.1.1/spookyhash.py

@@ -0,0 +1,240 @@
+"""A Python wrapper for SpookyHash version 2."""
+
+import struct
+from abc import ABC, abstractmethod
+from binascii import hexlify
+from typing import ClassVar, TYPE_CHECKING, Tuple, Type, Union, cast
+
+import _spookyhash
+
+if TYPE_CHECKING:
+    from typing import Self
+
+__all__ = ('hash32', 'hash64', 'hash128', 'Hash32', 'Hash64', 'Hash128')
+__version__ = '2.1.1'
+
+
+# Utility function for homogenising data
+
+def _char_arr(message: Union[bytes, memoryview, None]) -> memoryview:
+    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')
+    return message
+
+
+# Oneshot hash functions
+
+def hash32(message: Union[bytes, memoryview], 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: Union[bytes, memoryview], 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: Union[bytes, memoryview],
+    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 cast(Tuple[int, int], struct.unpack('=QQ', digest))
+
+
+def hash128(
+    message: Union[bytes, memoryview],
+    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: ClassVar[int]
+    _hash_cls: ClassVar[Type[_spookyhash.Hash]]
+
+    def __init__(
+        self,
+        message: Union[bytes, memoryview, 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)
+
+    @property
+    def digest_size(self) -> int:
+        """
+        Digest size.
+
+        :return: Digest size
+        """
+        return self._hash.digest_size
+
+    def update(self, message: Union[bytes, memoryview, None]) -> '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
+        """
+        return NotImplemented
+
+
+class Hash32(Hash):
+    """32-bit incremental hash builder."""
+
+    _hash_cls = _spookyhash.Hash32
+
+    def __init__(
+        self,
+        message: Union[bytes, memoryview, 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 struct.unpack('=L', self.digest())[0]
+
+
+class Hash64(Hash):
+
+    _hash_cls = _spookyhash.Hash64
+
+    def __init__(
+        self,
+        message: Union[bytes, memoryview, 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 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 cast(Tuple[int, int], 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-2.0.2 → spookyhash-2.1.1}/src/SpookyV2.pxd

@@ -1,12 +1,12 @@
 from libc.stdint cimport uint32_t, uint64_t
 
-cdef extern from 'SpookyV2.h':
+cdef extern from 'SpookyV2.h' nogil:
   cdef cppclass SpookyHash:
     void Init(uint64_t seed1, uint64_t seed2)
     void Update(const char *message, size_t length)
     void Final(uint64_t *hash1, uint64_t *hash2)
 
-cdef extern from 'SpookyV2.h' namespace 'SpookyHash':
+cdef extern from 'SpookyV2.h' namespace 'SpookyHash' nogil:
     void Hash128(const char *message, size_t length, uint64_t *hash1, uint64_t *hash2)
     uint64_t Hash64(const char *message, size_t length, uint64_t seed)
     uint32_t Hash32(const char *message, size_t length, uint32_t seed)