gxhash 0.1.0__tar.gz → 0.1.2__tar.gz

gxhash-0.1.2/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: gxhash
+Version: 0.1.2
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# gxhash-py
+
+Python bindings for [GxHash](https://github.com/ogxd/gxhash), a blazingly fast and robust non-cryptographic hashing algorithm.
+
+## Features
+
+- **Blazingly Fast**: Minimal-overhead binding to leverage the full speed of GxHash.
+- **Zero Python**: Pure Rust backend with zero additional Python runtime overhead.
+- **Fine-Grained Control**: Build true multi-threaded or async hashing pipelines with GIL-free APIs.
+- **Faster File Hashing**: Hash files using memory-mapped I/O via Rust — 3x faster than Python's sequential I/O.
+- **Async-Ready**: Tokio-powered async hashing for fast and efficient concurrency.
+- **Fully Typesafe**: Predictable, clean API with complete type safety.
+
+## Installation
+
+```bash
+pip install gxhash
+```
+
+## Usage
+
+Hashing bytes.
+
+```python
+from gxhash import GxHash32
+
+def main():
+    gxhash = GxHash32(seed=0)
+    result = gxhash.hash(b"Hello, world!")
+
+if __name__ == "__main__":
+    main()
+```
+
+Hashing a file.
+
+```python
+from gxhash import GxHash64
+
+def main():
+    gxhash = GxHash64(seed=0)
+    file = open("path/to/file.dmg", "rb")
+    result = gxhash.hash_file(file)
+
+if __name__ == "__main__":
+    main()
+```
+
+Hashing a file asynchronously.
+
+```python
+from asyncio import run
+from gxhash import GxHash128
+
+async def main():
+    gxhash = GxHash128(seed=0)
+    file = open("path/to/file.dmg", "rb")
+    result = await gxhash.hash_file_async(file)
+
+if __name__ == "__main__":
+    run(main())
+```
+

gxhash-0.1.2/py-gxhash/README.md

@@ -0,0 +1,62 @@
+# gxhash-py
+
+Python bindings for [GxHash](https://github.com/ogxd/gxhash), a blazingly fast and robust non-cryptographic hashing algorithm.
+
+## Features
+
+- **Blazingly Fast**: Minimal-overhead binding to leverage the full speed of GxHash.
+- **Zero Python**: Pure Rust backend with zero additional Python runtime overhead.
+- **Fine-Grained Control**: Build true multi-threaded or async hashing pipelines with GIL-free APIs.
+- **Faster File Hashing**: Hash files using memory-mapped I/O via Rust — 3x faster than Python's sequential I/O.
+- **Async-Ready**: Tokio-powered async hashing for fast and efficient concurrency.
+- **Fully Typesafe**: Predictable, clean API with complete type safety.
+
+## Installation
+
+```bash
+pip install gxhash
+```
+
+## Usage
+
+Hashing bytes.
+
+```python
+from gxhash import GxHash32
+
+def main():
+    gxhash = GxHash32(seed=0)
+    result = gxhash.hash(b"Hello, world!")
+
+if __name__ == "__main__":
+    main()
+```
+
+Hashing a file.
+
+```python
+from gxhash import GxHash64
+
+def main():
+    gxhash = GxHash64(seed=0)
+    file = open("path/to/file.dmg", "rb")
+    result = gxhash.hash_file(file)
+
+if __name__ == "__main__":
+    main()
+```
+
+Hashing a file asynchronously.
+
+```python
+from asyncio import run
+from gxhash import GxHash128
+
+async def main():
+    gxhash = GxHash128(seed=0)
+    file = open("path/to/file.dmg", "rb")
+    result = await gxhash.hash_file_async(file)
+
+if __name__ == "__main__":
+    run(main())
+```

{gxhash-0.1.0 → gxhash-0.1.2}/py-gxhash/main.py

@@ -89,17 +89,16 @@ collected=7
 
 async def main():
     try:
-        input_bytes = bytes([42] * 10000000)
+        with Path("gentoo_root.img").open("rb") as img:
+            input_bytes = img.read()
+        # input_bytes = bytes([42] * 10000000)
+
         seed = 1234
-        file = TemporaryFile()
-        event_loop = get_running_loop()
-        file.write(input_bytes)
-        file.seek(0)
-        gxhash128 = GxHash128(seed=seed)
+        gxhash64 = GxHash64(seed=seed)
+        thread_pool = ThreadPoolExecutor()
 
         start = perf_counter_ns()
-        thread_pool = ThreadPoolExecutor()
-        futures = [gxhash128.hash(input_bytes) for _ in range(1)]
+        futures = [gxhash64.hash(input_bytes) for _ in range(1)]
         print(f"{(perf_counter_ns() - start) / 1_000_000} ms")
 
         tempfiles = [TemporaryFile() for _ in range(1)]
@@ -108,7 +107,7 @@ async def main():
             tfile.seek(0)
 
         start = perf_counter_ns()
-        hash128_async = [gxhash128.hash_file(tfile) for tfile in tempfiles]
+        hash128_async = [await gxhash64.hash_async(input_bytes) for tfile in tempfiles]
         print(f"{(perf_counter_ns() - start) / 1_000_000} ms")
 
         # await asyncio.gather(gxhash(), collect())
@@ -121,33 +120,33 @@ if __name__ == "__main__":
     run(main())
 
 
-async def main():
-    seed = 1234
-    input_bytes = bytes([42] * 1000)
-    file = TemporaryFile()
-    file.write(input_bytes)
-    file.seek(0)
-    gxhash32 = GxHash32(seed=seed)
-    gxhash64 = GxHash64(seed=seed)
-    gxhash128 = GxHash128(seed=seed)
-
-    hash32 = gxhash32.hash(input_bytes)
-    hash32_nogil = gxhash32.hash_nogil(input_bytes)
-    hash32_file = gxhash32.hash_file(file)
-    file.seek(0)
-    hash32_file_async = await gxhash32.hash_file_async(file)
-    assert hash32 == hash32_nogil == hash32_file == hash32_file_async
-
-    hash64 = gxhash64.hash(input_bytes)
-    hash64_nogil = gxhash64.hash_nogil(input_bytes)
-    hash64_file = gxhash64.hash_file(file)
-    file.seek(0)
-    hash64_file_async = await gxhash64.hash_file_async(file)
-    assert hash64 == hash64_nogil == hash64_file == hash64_file_async
-
-    hash128 = gxhash128.hash(input_bytes)
-    hash128_nogil = gxhash128.hash_nogil(input_bytes)
-    hash128_file = gxhash128.hash_file(file)
-    file.seek(0)
-    hash128_file_async = await gxhash128.hash_file_async(file)
-    assert hash128 == hash128_nogil == hash128_file == hash128_file_async
+# async def main():
+#     seed = 1234
+#     input_bytes = bytes([42] * 1000)
+#     file = TemporaryFile()
+#     file.write(input_bytes)
+#     file.seek(0)
+#     gxhash32 = GxHash32(seed=seed)
+#     gxhash64 = GxHash64(seed=seed)
+#     gxhash128 = GxHash128(seed=seed)
+
+#     hash32 = gxhash32.hash(input_bytes)
+#     hash32_nogil = gxhash32.hash_nogil(input_bytes)
+#     hash32_file = gxhash32.hash_file(file)
+#     file.seek(0)
+#     hash32_file_async = await gxhash32.hash_file_async(file)
+#     assert hash32 == hash32_nogil == hash32_file == hash32_file_async
+
+#     hash64 = gxhash64.hash(input_bytes)
+#     hash64_nogil = gxhash64.hash_nogil(input_bytes)
+#     hash64_file = gxhash64.hash_file(file)
+#     file.seek(0)
+#     hash64_file_async = await gxhash64.hash_file_async(file)
+#     assert hash64 == hash64_nogil == hash64_file == hash64_file_async
+
+#     hash128 = gxhash128.hash(input_bytes)
+#     hash128_nogil = gxhash128.hash_nogil(input_bytes)
+#     hash128_file = gxhash128.hash_file(file)
+#     file.seek(0)
+#     hash128_file_async = await gxhash128.hash_file_async(file)
+#     assert hash128 == hash128_nogil == hash128_file == hash128_file_async

{gxhash-0.1.0 → gxhash-0.1.2}/py-gxhash/src/lib.rs

@@ -17,7 +17,6 @@ fn gxhash_nogil<T: Send>(py: Python, hasher: fn(&[u8], i64) -> T, bytes: &[u8],
 fn gxhash_file<T>(hasher: fn(&[u8], i64) -> T, file_descriptor: i32, seed: i64) -> PyResult<T> {
     let file = unsafe { std::fs::File::from_raw_fd(libc::dup(file_descriptor)) };
     let mmap = unsafe { memmap2::Mmap::map(&file)? };
-    drop(file);
     Ok(hasher(&mmap, seed))
 }
 

{gxhash-0.1.0 → gxhash-0.1.2}/pyproject.toml

@@ -1,9 +1,6 @@
-[build-system]
-requires = ["maturin>=1.7,<2.0"]
-build-backend = "maturin"
-
 [project]
 name = "gxhash"
+version = "0.1.2"
 requires-python = ">=3.7"
 dynamic = ["version"]
 classifiers = [
@@ -12,9 +9,13 @@ classifiers = [
     "Programming Language :: Python :: Implementation :: PyPy",
 ]
 
+[dependency-groups]
+dev = ["maturin>=1.7.4"]
+
+[build-system]
+requires = ["maturin>=1.7,<2.0"]
+build-backend = "maturin"
+
 [tool.maturin]
 features = ["pyo3/extension-module"]
 manifest-path = "py-gxhash/Cargo.toml"
-
-[dependency-groups]
-dev = ["maturin>=1.7.4"]

gxhash-0.1.0/PKG-INFO

@@ -1,15 +0,0 @@
-Metadata-Version: 2.4
-Name: gxhash
-Version: 0.1.0
-Classifier: Programming Language :: Rust
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-
-# py-gxhash
-
-```bash
-uv sync --reinstall
-```
-

gxhash-0.1.0/py-gxhash/README.md

@@ -1,5 +0,0 @@
-# py-gxhash
-
-```bash
-uv sync --reinstall
-```