fast-hash-utils 0.2.0__tar.gz

fast_hash_utils-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,36 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+      - run: pip install ruff
+      - run: ruff check .
+      - run: ruff format --check .
+
+  test:
+    needs: lint
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
+        os: [ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          allow-prereleases: true
+      - run: pip install -e ".[dev]"
+      - run: pytest -v

fast_hash_utils-0.2.0/.github/workflows/release.yml

@@ -0,0 +1,88 @@
+name: Release
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+      - run: pip install build
+      - run: python -m build --sdist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  wheels:
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            arch: x86_64
+            skip: "pp* *-musllinux_*"
+            name: linux-x86_64-manylinux
+          - os: ubuntu-latest
+            arch: x86_64
+            skip: "pp* *-manylinux_*"
+            name: linux-x86_64-musllinux
+          - os: ubuntu-latest
+            arch: aarch64
+            skip: "pp* *-musllinux_*"
+            name: linux-aarch64-manylinux
+            qemu: true
+          - os: ubuntu-latest
+            arch: aarch64
+            skip: "pp* *-manylinux_*"
+            name: linux-aarch64-musllinux
+            qemu: true
+          - os: macos-latest
+            arch: x86_64
+            skip: "pp*"
+            name: macos-x86_64
+          - os: macos-latest
+            arch: arm64
+            skip: "pp*"
+            name: macos-arm64
+          - os: windows-latest
+            arch: AMD64
+            skip: "pp*"
+            name: windows-x86_64
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: docker/setup-qemu-action@v3
+        if: matrix.qemu
+        with:
+          platforms: arm64
+      - uses: pypa/cibuildwheel@v2.23
+        env:
+          CIBW_ARCHS: ${{ matrix.arch }}
+          CIBW_SKIP: ${{ matrix.skip }}
+          CIBW_BUILD: cp39-* cp310-* cp311-* cp312-* cp313-* cp314-*
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.name }}
+          path: wheelhouse/*.whl
+
+  publish:
+    needs: [sdist, wheels]
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    environment: pypi
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@release/v1

fast_hash_utils-0.2.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.py[cod]
+*.so
+*.pyd
+*.egg-info/
+dist/
+build/
+.venv/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/

fast_hash_utils-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Toby Mao
+
+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.

fast_hash_utils-0.2.0/Makefile

@@ -0,0 +1,27 @@
+.PHONY: install install-release build test test-compiled bench style clean
+
+install:
+	MYPYC_OPT_LEVEL=0 pip install -e ".[dev]"
+
+install-release:
+	MYPYC_OPT_LEVEL=3 pip install -e ".[dev]"
+
+build:
+	mypyc hash_utils/_core.py
+
+test:
+	pytest -v
+
+test-compiled: build test
+
+bench:
+	python benchmarks/bench.py
+
+style:
+	ruff check --fix .
+	ruff format .
+
+clean:
+	rm -rf build/ dist/ *.egg-info .pytest_cache
+	rm -f hash_utils/*.so hash_utils/*.pyd
+	find . -type d -name __pycache__ -exec rm -rf {} +

fast_hash_utils-0.2.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: fast-hash-utils
+Version: 0.2.0
+Summary: Fast deterministic dict hashing via mypyc
+Author: Toby Mao
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/tobymao/hash-utils
+Project-URL: Repository, https://github.com/tobymao/hash-utils
+Project-URL: Issues, https://github.com/tobymao/hash-utils/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+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: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mypy-extensions>=1.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.19; extra == "dev"
+Requires-Dist: pytest>=8.4; extra == "dev"
+Requires-Dist: ruff>=0.15; extra == "dev"
+Dynamic: license-file
+
+# hash-utils
+
+Fast deterministic dict hashing via mypyc.
+
+## Functions
+
+- **`dict_hash(d)`** — deterministic hash of a nested dict's full content (keys + values)
+- **`shape_hash(d)`** — structural hash that ignores string/int/float values, only hashing keys, value types, bools, and container lengths
+
+## Install
+
+```bash
+pip install hash-utils
+```
+
+## Usage
+
+```python
+from hash_utils import dict_hash, shape_hash
+
+d1 = {"name": "alice", "config": {"enabled": True, "tags": []}}
+d2 = {"name": "bob",   "config": {"enabled": True, "tags": []}}
+
+# Full content hash — different names produce different hashes
+dict_hash(d1) != dict_hash(d2)
+
+# Shape hash — same structure produces same hash
+shape_hash(d1) == shape_hash(d2)
+```
+
+## Why
+
+`shape_hash` enables massive deduplication for jsonschema validation. If 13,000 dicts share the same structure but differ only in string values, they collapse to 1 unique shape — skip 12,999 redundant validations.
+
+## Performance
+
+Compiled via mypyc to native C. ~400K ops/s for nested dicts on a single core.
+
+| Method | ops/s | Deterministic |
+|---|---|---|
+| `shape_hash` (mypyc) | 445K | Yes |
+| `dict_hash` (mypyc) | 405K | Yes |
+| `hash(repr())` | 312K | No |
+| `json.dumps + hash` | 206K | Yes |
+
+## Development
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+make install    # editable install with dev deps
+make test       # run tests (pure Python or compiled)
+make lint       # ruff check + format check
+make clean      # remove build artifacts
+```
+
+## License
+
+MIT

fast_hash_utils-0.2.0/README.md

@@ -0,0 +1,58 @@
+# hash-utils
+
+Fast deterministic dict hashing via mypyc.
+
+## Functions
+
+- **`dict_hash(d)`** — deterministic hash of a nested dict's full content (keys + values)
+- **`shape_hash(d)`** — structural hash that ignores string/int/float values, only hashing keys, value types, bools, and container lengths
+
+## Install
+
+```bash
+pip install hash-utils
+```
+
+## Usage
+
+```python
+from hash_utils import dict_hash, shape_hash
+
+d1 = {"name": "alice", "config": {"enabled": True, "tags": []}}
+d2 = {"name": "bob",   "config": {"enabled": True, "tags": []}}
+
+# Full content hash — different names produce different hashes
+dict_hash(d1) != dict_hash(d2)
+
+# Shape hash — same structure produces same hash
+shape_hash(d1) == shape_hash(d2)
+```
+
+## Why
+
+`shape_hash` enables massive deduplication for jsonschema validation. If 13,000 dicts share the same structure but differ only in string values, they collapse to 1 unique shape — skip 12,999 redundant validations.
+
+## Performance
+
+Compiled via mypyc to native C. ~400K ops/s for nested dicts on a single core.
+
+| Method | ops/s | Deterministic |
+|---|---|---|
+| `shape_hash` (mypyc) | 445K | Yes |
+| `dict_hash` (mypyc) | 405K | Yes |
+| `hash(repr())` | 312K | No |
+| `json.dumps + hash` | 206K | Yes |
+
+## Development
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+make install    # editable install with dev deps
+make test       # run tests (pure Python or compiled)
+make lint       # ruff check + format check
+make clean      # remove build artifacts
+```
+
+## License
+
+MIT

fast_hash_utils-0.2.0/benchmarks/bench.py

@@ -0,0 +1,94 @@
+"""Benchmarks for dict_hash and shape_hash (pure Python vs mypyc)."""
+
+import json
+import time
+
+N = 10_000
+
+
+def make_dicts(n: int) -> list[dict]:
+    """Generate n realistic nested dicts."""
+    return [
+        {
+            "name": f"test_node_{i}",
+            "unique_id": f"project.model.{i}",
+            "description": f"A test node for benchmarking purposes #{i}",
+            "config": {
+                "enabled": True,
+                "severity": "ERROR",
+                "warn_if": "!= 0",
+                "error_if": "> 10",
+                "tags": ["ci", "nightly"],
+                "meta": {"owner": "team-data", "priority": i % 5},
+            },
+            "columns": {
+                "id": {"type": "integer", "nullable": False},
+                "name": {"type": "string", "nullable": True},
+                "value": {"type": "float", "nullable": True},
+            },
+        }
+        for i in range(n)
+    ]
+
+
+def bench(name: str, fn, dicts: list[dict]) -> float:
+    # Warmup
+    for d in dicts[:100]:
+        fn(d)
+
+    start = time.perf_counter()
+    for d in dicts:
+        fn(d)
+    elapsed = time.perf_counter() - start
+
+    ops = len(dicts) / elapsed
+    print(f"{name:40s}  {elapsed:.4f}s  {ops:>10,.0f} ops/s")
+    return elapsed
+
+
+def json_hash(d: dict) -> int:
+    return hash(json.dumps(d, sort_keys=True))
+
+
+def main() -> None:
+    import hash_utils._core as core_mod
+
+    is_compiled = hasattr(core_mod, "__loader__") and "mypyc" in str(
+        getattr(core_mod, "__file__", "")
+    )
+    # More reliable: compiled modules are .so/.pyd, not .py
+    mod_file = getattr(core_mod, "__file__", "")
+    is_compiled = mod_file.endswith((".so", ".pyd"))
+
+    dicts = make_dicts(N)
+    print(f"Benchmarking {N:,} nested dicts")
+    print(f"mypyc compiled: {is_compiled}\n")
+    print(f"{'Method':40s}  {'Time':>7s}  {'Throughput':>12s}")
+    print("-" * 66)
+
+    # Pure Python versions (import the source directly)
+    import importlib
+    import importlib.util
+    import pathlib
+
+    core_py = pathlib.Path(__file__).resolve().parent.parent / "hash_utils" / "_core.py"
+    spec = importlib.util.spec_from_file_location("_core_pure", core_py)
+    pure = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(pure)
+
+    bench("dict_hash (pure python)", pure.dict_hash, dicts)
+    bench("shape_hash (pure python)", pure.shape_hash, dicts)
+
+    if is_compiled:
+        from hash_utils import dict_hash, shape_hash
+
+        bench("dict_hash (mypyc)", dict_hash, dicts)
+
+    bench("hash(json.dumps(sort_keys=True))", json_hash, dicts)
+
+    if is_compiled:
+        bench("shape_hash (mypyc)", shape_hash, dicts)
+
+
+if __name__ == "__main__":
+    main()

fast_hash_utils-0.2.0/fast_hash_utils.egg-info/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: fast-hash-utils
+Version: 0.2.0
+Summary: Fast deterministic dict hashing via mypyc
+Author: Toby Mao
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/tobymao/hash-utils
+Project-URL: Repository, https://github.com/tobymao/hash-utils
+Project-URL: Issues, https://github.com/tobymao/hash-utils/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+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: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mypy-extensions>=1.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.19; extra == "dev"
+Requires-Dist: pytest>=8.4; extra == "dev"
+Requires-Dist: ruff>=0.15; extra == "dev"
+Dynamic: license-file
+
+# hash-utils
+
+Fast deterministic dict hashing via mypyc.
+
+## Functions
+
+- **`dict_hash(d)`** — deterministic hash of a nested dict's full content (keys + values)
+- **`shape_hash(d)`** — structural hash that ignores string/int/float values, only hashing keys, value types, bools, and container lengths
+
+## Install
+
+```bash
+pip install hash-utils
+```
+
+## Usage
+
+```python
+from hash_utils import dict_hash, shape_hash
+
+d1 = {"name": "alice", "config": {"enabled": True, "tags": []}}
+d2 = {"name": "bob",   "config": {"enabled": True, "tags": []}}
+
+# Full content hash — different names produce different hashes
+dict_hash(d1) != dict_hash(d2)
+
+# Shape hash — same structure produces same hash
+shape_hash(d1) == shape_hash(d2)
+```
+
+## Why
+
+`shape_hash` enables massive deduplication for jsonschema validation. If 13,000 dicts share the same structure but differ only in string values, they collapse to 1 unique shape — skip 12,999 redundant validations.
+
+## Performance
+
+Compiled via mypyc to native C. ~400K ops/s for nested dicts on a single core.
+
+| Method | ops/s | Deterministic |
+|---|---|---|
+| `shape_hash` (mypyc) | 445K | Yes |
+| `dict_hash` (mypyc) | 405K | Yes |
+| `hash(repr())` | 312K | No |
+| `json.dumps + hash` | 206K | Yes |
+
+## Development
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+make install    # editable install with dev deps
+make test       # run tests (pure Python or compiled)
+make lint       # ruff check + format check
+make clean      # remove build artifacts
+```
+
+## License
+
+MIT

fast_hash_utils-0.2.0/fast_hash_utils.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+.gitignore
+LICENSE
+Makefile
+README.md
+pyproject.toml
+setup.py
+.github/workflows/ci.yml
+.github/workflows/release.yml
+benchmarks/bench.py
+fast_hash_utils.egg-info/PKG-INFO
+fast_hash_utils.egg-info/SOURCES.txt
+fast_hash_utils.egg-info/dependency_links.txt
+fast_hash_utils.egg-info/requires.txt
+fast_hash_utils.egg-info/top_level.txt
+hash_utils/__init__.py
+hash_utils/_core.py
+tests/test_hash_utils.py

fast_hash_utils-0.2.0/fast_hash_utils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fast_hash_utils-0.2.0/fast_hash_utils.egg-info/requires.txt

@@ -0,0 +1,6 @@
+mypy-extensions>=1.0
+
+[dev]
+mypy>=1.19
+pytest>=8.4
+ruff>=0.15

fast_hash_utils-0.2.0/fast_hash_utils.egg-info/top_level.txt

@@ -0,0 +1 @@
+hash_utils

fast_hash_utils-0.2.0/hash_utils/__init__.py

@@ -0,0 +1,8 @@
+"""Fast deterministic dict hashing via mypyc."""
+
+from importlib.metadata import version
+
+from hash_utils._core import dict_hash, shape_hash
+
+__version__ = version("fast-hash-utils")
+__all__ = ["dict_hash", "shape_hash"]

fast_hash_utils-0.2.0/hash_utils/_core.py

@@ -0,0 +1,120 @@
+"""Fast deterministic dict hashing for deduplication.
+
+Iteratively traverses a nested dict/list/scalar structure using an
+explicit stack.  Accumulates a native i64 hash via bit mixing.
+Designed to be compiled with mypyc.
+"""
+
+from typing import Dict, List
+
+from mypy_extensions import i64
+
+# Type tags for shape hashing — distinct primes for good mixing
+_TAG_NONE: i64 = 7
+_TAG_BOOL_T: i64 = 11
+_TAG_BOOL_F: i64 = 13
+_TAG_INT: i64 = 17
+_TAG_FLOAT: i64 = 19
+_TAG_STR: i64 = 23
+_TAG_DICT: i64 = 29
+_TAG_LIST: i64 = 31
+_TAG_OTHER: i64 = 37
+
+
+def _hash_to_i64(obj: object) -> i64:
+    """Get the Python hash of an object as a native i64."""
+    return i64(hash(obj))
+
+
+def _mix(h: i64, v: i64) -> i64:
+    """Murmur-inspired bit mixing using native i64 arithmetic."""
+    h = h ^ v
+    h = (h << 13) | ((h >> 51) & 0x1FFF)
+    h = h * 0x5BD1E995
+    return h
+
+
+def dict_hash(d: Dict[object, object]) -> int:
+    """Deterministic hash of a nested dict — full values."""
+    h: i64 = 0
+    stack: List[object] = [d]
+
+    while stack:
+        item: object = stack.pop()
+
+        if item is None:
+            h = _mix(h, _TAG_NONE)
+        elif isinstance(item, bool):
+            h = _mix(h, 1 if item else 2)
+        elif isinstance(item, int):
+            h = _mix(h, _hash_to_i64(item))
+        elif isinstance(item, float):
+            h = _mix(h, _hash_to_i64(item))
+        elif isinstance(item, str):
+            h = _mix(h, _hash_to_i64(item))
+            h = _mix(h, i64(len(item)))
+        elif isinstance(item, dict):
+            h = _mix(h, i64(len(item)))
+            keys: List[str] = sorted(item.keys())
+            i: i64 = i64(len(keys)) - 1
+            while i >= 0:
+                k: str = keys[i]
+                stack.append(item[k])
+                stack.append(k)
+                i -= 1
+        elif isinstance(item, list):
+            h = _mix(h, i64(len(item)))
+            i = i64(len(item)) - 1
+            while i >= 0:
+                stack.append(item[i])
+                i -= 1
+        else:
+            h = _mix(h, _hash_to_i64(item))
+
+    return int(h)
+
+
+def shape_hash(d: Dict[object, object]) -> int:
+    """Deterministic hash of a nested dict — shape only.
+
+    Hashes keys and value types but ignores string/int/float content.
+    Two dicts with the same structure always produce the same
+    jsonschema validation result, so this is safe for dedup.
+    """
+    h: i64 = 0
+    stack: List[object] = [d]
+
+    while stack:
+        item: object = stack.pop()
+
+        if item is None:
+            h = _mix(h, _TAG_NONE)
+        elif isinstance(item, bool):
+            h = _mix(h, _TAG_BOOL_T if item else _TAG_BOOL_F)
+        elif isinstance(item, int):
+            h = _mix(h, _TAG_INT)
+        elif isinstance(item, float):
+            h = _mix(h, _TAG_FLOAT)
+        elif isinstance(item, str):
+            h = _mix(h, _TAG_STR)
+        elif isinstance(item, dict):
+            h = _mix(h, _TAG_DICT)
+            h = _mix(h, i64(len(item)))
+            keys: List[str] = sorted(item.keys())
+            i: i64 = i64(len(keys)) - 1
+            while i >= 0:
+                k: str = keys[i]
+                h = _mix(h, _hash_to_i64(k))
+                stack.append(item[k])
+                i -= 1
+        elif isinstance(item, list):
+            h = _mix(h, _TAG_LIST)
+            h = _mix(h, i64(len(item)))
+            i = i64(len(item)) - 1
+            while i >= 0:
+                stack.append(item[i])
+                i -= 1
+        else:
+            h = _mix(h, _TAG_OTHER)
+
+    return int(h)

fast_hash_utils-0.2.0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["setuptools>=68", "setuptools-scm>=8", "mypy>=1.0", "mypy-extensions>=1.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fast-hash-utils"
+dynamic = ["version"]
+description = "Fast deterministic dict hashing via mypyc"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [{name = "Toby Mao"}]
+dependencies = ["mypy-extensions>=1.0"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "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",
+    "Typing :: Typed",
+]
+
+[project.optional-dependencies]
+dev = [
+    "mypy>=1.19",
+    "pytest>=8.4",
+    "ruff>=0.15",
+]
+
+[project.urls]
+Homepage = "https://github.com/tobymao/hash-utils"
+Repository = "https://github.com/tobymao/hash-utils"
+Issues = "https://github.com/tobymao/hash-utils/issues"
+
+[tool.setuptools_scm]
+
+[tool.setuptools.packages.find]
+include = ["hash_utils*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]
+
+[tool.ruff.lint.per-file-ignores]
+"hash_utils/_core.py" = ["UP006", "UP035"]  # typing.Dict/List required for mypyc + Python 3.9

fast_hash_utils-0.2.0/setup.cfg

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

fast_hash_utils-0.2.0/setup.py

@@ -0,0 +1,13 @@
+import os
+
+from setuptools import setup
+
+try:
+    from mypyc.build import mypycify
+
+    opt_level = os.environ.get("MYPYC_OPT_LEVEL", "3")
+    ext_modules = mypycify(["hash_utils/_core.py"], opt_level=opt_level)
+except ImportError:
+    ext_modules = []
+
+setup(ext_modules=ext_modules)

fast_hash_utils-0.2.0/tests/test_hash_utils.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+from hash_utils import dict_hash, shape_hash
+
+
+class TestDictHash:
+    """Tests for dict_hash — full content hashing."""
+
+    def test_deterministic(self):
+        d = {"a": 1, "b": "hello", "c": [1, 2, 3]}
+        assert dict_hash(d) == dict_hash(d)
+
+    def test_key_order_independent(self):
+        """Sorted keys means insertion order doesn't matter."""
+        d1 = {"a": 1, "b": 2}
+        d2 = {"b": 2, "a": 1}
+        assert dict_hash(d1) == dict_hash(d2)
+
+    def test_different_values_differ(self):
+        d1 = {"a": 1}
+        d2 = {"a": 2}
+        assert dict_hash(d1) != dict_hash(d2)
+
+    def test_different_keys_differ(self):
+        d1 = {"a": 1}
+        d2 = {"b": 1}
+        assert dict_hash(d1) != dict_hash(d2)
+
+    def test_nested_dicts(self):
+        d1 = {"a": {"b": {"c": 1}}}
+        d2 = {"a": {"b": {"c": 1}}}
+        assert dict_hash(d1) == dict_hash(d2)
+
+    def test_nested_dicts_differ(self):
+        d1 = {"a": {"b": {"c": 1}}}
+        d2 = {"a": {"b": {"c": 2}}}
+        assert dict_hash(d1) != dict_hash(d2)
+
+    def test_lists(self):
+        d1 = {"a": [1, 2, 3]}
+        d2 = {"a": [1, 2, 3]}
+        assert dict_hash(d1) == dict_hash(d2)
+
+    def test_list_order_matters(self):
+        d1 = {"a": [1, 2]}
+        d2 = {"a": [2, 1]}
+        assert dict_hash(d1) != dict_hash(d2)
+
+    def test_empty_dict(self):
+        assert dict_hash({}) == dict_hash({})
+
+    def test_none_values(self):
+        d1 = {"a": None}
+        d2 = {"a": None}
+        assert dict_hash(d1) == dict_hash(d2)
+
+    def test_none_vs_zero(self):
+        d1 = {"a": None}
+        d2 = {"a": 0}
+        assert dict_hash(d1) != dict_hash(d2)
+
+    def test_bool_values(self):
+        d1 = {"a": True}
+        d2 = {"a": False}
+        assert dict_hash(d1) != dict_hash(d2)
+
+    def test_float_values(self):
+        d1 = {"a": 1.5}
+        d2 = {"a": 1.5}
+        assert dict_hash(d1) == dict_hash(d2)
+
+    def test_mixed_types(self):
+        d = {
+            "str": "hello",
+            "int": 42,
+            "float": 3.14,
+            "bool": True,
+            "none": None,
+            "list": [1, "two", 3.0],
+            "dict": {"nested": True},
+        }
+        assert dict_hash(d) == dict_hash(d)
+
+    def test_string_length_matters(self):
+        """Strings with same hash prefix but different length should differ."""
+        d1 = {"a": "x"}
+        d2 = {"a": "xx"}
+        assert dict_hash(d1) != dict_hash(d2)
+
+    def test_returns_int(self):
+        assert isinstance(dict_hash({"a": 1}), int)
+
+
+class TestShapeHash:
+    """Tests for shape_hash — structural hashing."""
+
+    def test_deterministic(self):
+        d = {"a": 1, "b": "hello"}
+        assert shape_hash(d) == shape_hash(d)
+
+    def test_ignores_string_values(self):
+        d1 = {"name": "alice", "city": "london"}
+        d2 = {"name": "bob", "city": "paris"}
+        assert shape_hash(d1) == shape_hash(d2)
+
+    def test_ignores_int_values(self):
+        d1 = {"count": 1, "total": 100}
+        d2 = {"count": 999, "total": 0}
+        assert shape_hash(d1) == shape_hash(d2)
+
+    def test_ignores_float_values(self):
+        d1 = {"score": 1.5}
+        d2 = {"score": 99.9}
+        assert shape_hash(d1) == shape_hash(d2)
+
+    def test_different_keys_differ(self):
+        d1 = {"a": 1}
+        d2 = {"b": 1}
+        assert shape_hash(d1) != shape_hash(d2)
+
+    def test_bool_values_matter(self):
+        d1 = {"enabled": True}
+        d2 = {"enabled": False}
+        assert shape_hash(d1) != shape_hash(d2)
+
+    def test_different_value_types_differ(self):
+        d1 = {"a": "string"}
+        d2 = {"a": 42}
+        assert shape_hash(d1) != shape_hash(d2)
+
+    def test_dict_length_matters(self):
+        d1 = {"a": 1, "b": 2}
+        d2 = {"a": 1}
+        assert shape_hash(d1) != shape_hash(d2)
+
+    def test_list_length_matters(self):
+        d1 = {"items": [1, 2, 3]}
+        d2 = {"items": [1]}
+        assert shape_hash(d1) != shape_hash(d2)
+
+    def test_nested_shape_same(self):
+        """Two dicts with identical structure but different leaf values."""
+        d1 = {
+            "name": "test_user",
+            "config": {"enabled": True, "severity": "ERROR", "tags": []},
+        }
+        d2 = {
+            "name": "other_user",
+            "config": {"enabled": True, "severity": "WARNING", "tags": []},
+        }
+        assert shape_hash(d1) == shape_hash(d2)
+
+    def test_nested_shape_differs(self):
+        """Different structure should produce different hashes."""
+        d1 = {"config": {"enabled": True}}
+        d2 = {"config": {"enabled": True, "extra": "field"}}
+        assert shape_hash(d1) != shape_hash(d2)
+
+    def test_empty_dict(self):
+        assert shape_hash({}) == shape_hash({})
+
+    def test_none_tagged(self):
+        d1 = {"a": None}
+        d2 = {"a": "hello"}
+        assert shape_hash(d1) != shape_hash(d2)
+
+    def test_key_order_independent(self):
+        d1 = {"a": 1, "b": 2}
+        d2 = {"b": 2, "a": 1}
+        assert shape_hash(d1) == shape_hash(d2)
+
+    def test_returns_int(self):
+        assert isinstance(shape_hash({"a": 1}), int)
+
+    def test_realistic_dedup(self):
+        """Simulate the jsonschema validation dedup use case."""
+        # Generate 100 dicts that differ only in string/int values
+        dicts = []
+        for i in range(100):
+            d = {
+                "name": f"test_node_{i}",
+                "unique_id": f"project.model.{i}",
+                "config": {
+                    "enabled": True,
+                    "severity": "ERROR",
+                    "tags": [],
+                },
+                "columns": {},
+            }
+            dicts.append(d)
+
+        hashes = {shape_hash(d) for d in dicts}
+        assert len(hashes) == 1, f"Expected 1 unique shape, got {len(hashes)}"
+
+
+class TestDictHashVsShapeHash:
+    """Verify the two functions behave differently where expected."""
+
+    def test_dict_hash_distinguishes_values(self):
+        d1 = {"a": "hello"}
+        d2 = {"a": "world"}
+        assert dict_hash(d1) != dict_hash(d2)
+        assert shape_hash(d1) == shape_hash(d2)
+
+    def test_both_distinguish_keys(self):
+        d1 = {"a": 1}
+        d2 = {"b": 1}
+        assert dict_hash(d1) != dict_hash(d2)
+        assert shape_hash(d1) != shape_hash(d2)
+
+    def test_both_distinguish_structure(self):
+        d1 = {"a": [1, 2]}
+        d2 = {"a": {"b": 1}}
+        assert dict_hash(d1) != dict_hash(d2)
+        assert shape_hash(d1) != shape_hash(d2)