uuid-utils 0.7.0__tar.gz → 0.8.0__tar.gz

{uuid_utils-0.7.0 → uuid_utils-0.8.0}/.github/workflows/ci.yml

@@ -8,9 +8,6 @@ on:
       - "*"
   pull_request:
 
-permissions:
-  contents: read
-
 env:
   RUSTFLAGS: "--cfg uuid_unstable"
 
@@ -26,23 +23,22 @@ jobs:
       - name: Install dependencies
         run: pip install -r requirements.txt
       - name: Check code
-        run: |
-          black --check --diff .
-          isort --check --project=uuid_utils .
-          mypy .
-          ruff .
+        run: make lint
+      - name: Check docs
+        run: make docs_build
 
   linux:
-    name: "Linux: ${{ matrix.target }}"
+    name: "Linux: ${{ matrix.target }} Python ${{ matrix.python-version }}"
     runs-on: ubuntu-latest
     strategy:
       matrix:
         target: [x86_64, i686]
+        python-version: ["3.10", "3.11", "3.12"]
     steps:
       - uses: actions/checkout@v3
       - uses: actions/setup-python@v4
         with:
-          python-version: "3.11"
+          python-version: "${{ matrix.python-version }}"
       - name: Build wheels
         uses: PyO3/maturin-action@v1
         with:
@@ -261,3 +257,15 @@ jobs:
         with:
           command: upload
           args: --skip-existing *
+
+  docs:
+    name: Publish docs
+    runs-on: ubuntu-latest
+    if: "startsWith(github.ref, 'refs/tags/')"
+    needs: [release]
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build and publish docs
+        run: |
+          pip install -r requirements.txt
+          make docs_build && make docs_deploy

{uuid_utils-0.7.0 → uuid_utils-0.8.0}/Cargo.lock

@@ -406,7 +406,7 @@ dependencies = [
 
 [[package]]
 name = "uuid-utils"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "mac_address",
  "pyo3",

{uuid_utils-0.7.0 → uuid_utils-0.8.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "uuid-utils"
-version = "0.7.0"
+version = "0.8.0"
 edition = "2021"
 
 [lib]

uuid_utils-0.8.0/Makefile

@@ -0,0 +1,39 @@
+.DEFAULT_GOAL := all
+
+.PHONY: build
+build:
+	RUSTFLAGS="--cfg uuid_unstable" maturin develop --release
+
+.PHONY: format
+format:
+	ruff check --fix python/ tests/
+	ruff format python/ tests/
+	cargo fmt
+
+.PHONY: lint
+lint:
+	ruff check python/ tests/
+	ruff format --check --diff python/ tests/
+	mypy python/ tests/
+.PHONY: test
+test:
+	pytest tests -vvv
+
+.PHONY: bench
+bench:
+	richbench benchmarks/
+
+.PHONY: docs_build
+docs_build:
+	mkdocs build
+
+.PHONY: docs_serve
+docs_serve:
+	mkdocs serve --dev-addr localhost:8080
+
+.PHONY: docs_deploy
+docs_deploy:
+	mkdocs gh-deploy --force
+
+.PHONY: all
+all: format build lint test

{uuid_utils-0.7.0 → uuid_utils-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: uuid_utils
-Version: 0.7.0
+Version: 0.8.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
@@ -41,8 +41,8 @@ Python UUID implementation using Rust's UUID library.
 This will make `uuid4` function around 10x faster.
 
 This package can be a drop-in replacement to the standard library UUID
-which implements existing UUID versions like V4 in Rust
-and also adds draft UUID versions like V6.
+which implements existing UUID versions like v4 in Rust
+and also adds draft UUID versions like v6.
 
 Avaialble UUID versions:
 
@@ -57,10 +57,15 @@ Avaialble UUID versions:
 <sup>Please note that UUID versions 6, 7 and 8 are still in draft RFC.</sup><br>
 
 ## Installation
-
+Using `pip`:
 ```shell
 $ pip install uuid-utils
 ```
+or, using `conda`:
+
+```shell
+$ conda install -c conda-forge uuid-utils
+```
 
 ## Example
 
@@ -84,12 +89,12 @@ UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')
 UUID('6fa459ea-ee8a-3ca4-894e-db77e160355e')
 ```
 
-## Compat module
+## Compatibility
 
-In some cases you might need `UUID` instances to be returned
+In some cases, for example if you are using `Django`, you might need `UUID` instances to be returned
 from the standrad-library `uuid`, not a custom `UUID` class.
 In that case you can use the `uuid_utils.compat` which comes with a performance penalty
-in comparison with the `uuid_utils` default behaviour, but still faster than the standard-library.
+in comparison with the `uuid_utils` default behaviour, but is still faster than the standard-library.
 
 ```py
 >>> import uuid_utils.compat as uuid
@@ -101,16 +106,16 @@ UUID('ffe95fcc-b818-4aca-a350-e0a35b9de6ec')
 
 ## Benchmarks
 
-|       Benchmark | Min     | Max     | Mean    | Min (+)         | Max (+)         | Mean (+)        |
-|-----------------|---------|---------|---------|-----------------|-----------------|-----------------|
-|         UUID V1 | 0.058   | 0.059   | 0.058   | 0.005 (12.0x)   | 0.005 (11.9x)   | 0.005 (12.0x)   |
-|         UUID V3 | 0.063   | 0.064   | 0.063   | 0.008 (7.9x)    | 0.008 (8.1x)    | 0.008 (8.0x)    |
-|         UUID V4 | 0.041   | 0.041   | 0.041   | 0.004 (11.1x)   | 0.004 (10.8x)   | 0.004 (10.9x)   |
-|         UUID V5 | 0.064   | 0.066   | 0.065   | 0.008 (8.1x)    | 0.008 (8.1x)    | 0.008 (8.1x)    |
-|   UUID from hex | 0.024   | 0.025   | 0.024   | 0.004 (6.7x)    | 0.004 (6.6x)    | 0.004 (6.6x)    |
-| UUID from bytes | 0.024   | 0.025   | 0.024   | 0.004 (6.7x)    | 0.004 (6.6x)    | 0.004 (6.7x)    |
-|   UUID from int | 0.024   | 0.025   | 0.024   | 0.004 (6.6x)    | 0.004 (6.7x)    | 0.004 (6.6x)    |
-| UUID from fields | 0.028   | 0.028   | 0.028   | 0.009 (3.1x)    | 0.009 (3.1x)    | 0.009 (3.1x)    |
+| Benchmark        | Min   | Max   | Mean  | Min (+)       | Max (+)       | Mean (+)      |
+| ---------------- | ----- | ----- | ----- | ------------- | ------------- | ------------- |
+| UUID v1          | 0.058 | 0.059 | 0.058 | 0.005 (12.0x) | 0.005 (11.9x) | 0.005 (12.0x) |
+| UUID v3          | 0.063 | 0.064 | 0.063 | 0.008 (7.9x)  | 0.008 (8.1x)  | 0.008 (8.0x)  |
+| UUID v4          | 0.041 | 0.041 | 0.041 | 0.004 (11.1x) | 0.004 (10.8x) | 0.004 (10.9x) |
+| UUID v5          | 0.064 | 0.066 | 0.065 | 0.008 (8.1x)  | 0.008 (8.1x)  | 0.008 (8.1x)  |
+| UUID from hex    | 0.024 | 0.025 | 0.024 | 0.004 (6.7x)  | 0.004 (6.6x)  | 0.004 (6.6x)  |
+| UUID from bytes  | 0.024 | 0.025 | 0.024 | 0.004 (6.7x)  | 0.004 (6.6x)  | 0.004 (6.7x)  |
+| UUID from int    | 0.024 | 0.025 | 0.024 | 0.004 (6.6x)  | 0.004 (6.7x)  | 0.004 (6.6x)  |
+| UUID from fields | 0.028 | 0.028 | 0.028 | 0.009 (3.1x)  | 0.009 (3.1x)  | 0.009 (3.1x)  |
 
 ## How to develop locally
 

{uuid_utils-0.7.0 → uuid_utils-0.8.0}/README.md

@@ -15,8 +15,8 @@ Python UUID implementation using Rust's UUID library.
 This will make `uuid4` function around 10x faster.
 
 This package can be a drop-in replacement to the standard library UUID
-which implements existing UUID versions like V4 in Rust
-and also adds draft UUID versions like V6.
+which implements existing UUID versions like v4 in Rust
+and also adds draft UUID versions like v6.
 
 Avaialble UUID versions:
 
@@ -31,10 +31,15 @@ Avaialble UUID versions:
 <sup>Please note that UUID versions 6, 7 and 8 are still in draft RFC.</sup><br>
 
 ## Installation
-
+Using `pip`:
 ```shell
 $ pip install uuid-utils
 ```
+or, using `conda`:
+
+```shell
+$ conda install -c conda-forge uuid-utils
+```
 
 ## Example
 
@@ -58,12 +63,12 @@ UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')
 UUID('6fa459ea-ee8a-3ca4-894e-db77e160355e')
 ```
 
-## Compat module
+## Compatibility
 
-In some cases you might need `UUID` instances to be returned
+In some cases, for example if you are using `Django`, you might need `UUID` instances to be returned
 from the standrad-library `uuid`, not a custom `UUID` class.
 In that case you can use the `uuid_utils.compat` which comes with a performance penalty
-in comparison with the `uuid_utils` default behaviour, but still faster than the standard-library.
+in comparison with the `uuid_utils` default behaviour, but is still faster than the standard-library.
 
 ```py
 >>> import uuid_utils.compat as uuid
@@ -75,16 +80,16 @@ UUID('ffe95fcc-b818-4aca-a350-e0a35b9de6ec')
 
 ## Benchmarks
 
-|       Benchmark | Min     | Max     | Mean    | Min (+)         | Max (+)         | Mean (+)        |
-|-----------------|---------|---------|---------|-----------------|-----------------|-----------------|
-|         UUID V1 | 0.058   | 0.059   | 0.058   | 0.005 (12.0x)   | 0.005 (11.9x)   | 0.005 (12.0x)   |
-|         UUID V3 | 0.063   | 0.064   | 0.063   | 0.008 (7.9x)    | 0.008 (8.1x)    | 0.008 (8.0x)    |
-|         UUID V4 | 0.041   | 0.041   | 0.041   | 0.004 (11.1x)   | 0.004 (10.8x)   | 0.004 (10.9x)   |
-|         UUID V5 | 0.064   | 0.066   | 0.065   | 0.008 (8.1x)    | 0.008 (8.1x)    | 0.008 (8.1x)    |
-|   UUID from hex | 0.024   | 0.025   | 0.024   | 0.004 (6.7x)    | 0.004 (6.6x)    | 0.004 (6.6x)    |
-| UUID from bytes | 0.024   | 0.025   | 0.024   | 0.004 (6.7x)    | 0.004 (6.6x)    | 0.004 (6.7x)    |
-|   UUID from int | 0.024   | 0.025   | 0.024   | 0.004 (6.6x)    | 0.004 (6.7x)    | 0.004 (6.6x)    |
-| UUID from fields | 0.028   | 0.028   | 0.028   | 0.009 (3.1x)    | 0.009 (3.1x)    | 0.009 (3.1x)    |
+| Benchmark        | Min   | Max   | Mean  | Min (+)       | Max (+)       | Mean (+)      |
+| ---------------- | ----- | ----- | ----- | ------------- | ------------- | ------------- |
+| UUID v1          | 0.058 | 0.059 | 0.058 | 0.005 (12.0x) | 0.005 (11.9x) | 0.005 (12.0x) |
+| UUID v3          | 0.063 | 0.064 | 0.063 | 0.008 (7.9x)  | 0.008 (8.1x)  | 0.008 (8.0x)  |
+| UUID v4          | 0.041 | 0.041 | 0.041 | 0.004 (11.1x) | 0.004 (10.8x) | 0.004 (10.9x) |
+| UUID v5          | 0.064 | 0.066 | 0.065 | 0.008 (8.1x)  | 0.008 (8.1x)  | 0.008 (8.1x)  |
+| UUID from hex    | 0.024 | 0.025 | 0.024 | 0.004 (6.7x)  | 0.004 (6.6x)  | 0.004 (6.6x)  |
+| UUID from bytes  | 0.024 | 0.025 | 0.024 | 0.004 (6.7x)  | 0.004 (6.6x)  | 0.004 (6.7x)  |
+| UUID from int    | 0.024 | 0.025 | 0.024 | 0.004 (6.6x)  | 0.004 (6.7x)  | 0.004 (6.6x)  |
+| UUID from fields | 0.028 | 0.028 | 0.028 | 0.009 (3.1x)  | 0.009 (3.1x)  | 0.009 (3.1x)  |
 
 ## How to develop locally
 

{uuid_utils-0.7.0 → uuid_utils-0.8.0}/benchmarks/bench_generator.py

@@ -46,8 +46,8 @@ def uuid_utils_uuid5() -> None:
 
 
 __benchmarks__ = [
-    (uuid_uuid1, uuid_utils_uuid1, "UUID V1"),
-    (uuid_uuid3, uuid_utils_uuid3, "UUID V3"),
-    (uuid_uuid4, uuid_utils_uuid4, "UUID V4"),
-    (uuid_uuid5, uuid_utils_uuid5, "UUID V5"),
+    (uuid_uuid1, uuid_utils_uuid1, "UUID v1"),
+    (uuid_uuid3, uuid_utils_uuid3, "UUID v3"),
+    (uuid_uuid4, uuid_utils_uuid4, "UUID v4"),
+    (uuid_uuid5, uuid_utils_uuid5, "UUID v5"),
 ]

uuid_utils-0.8.0/docs/api.md

@@ -0,0 +1,27 @@
+class `uuid_utils.UUID`
+
+| Property    | Description                                                                                                                                     |
+| ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+| `bytes`     | the UUID as a 16-byte string (containing the six integer fields in big-endian byte order)                                                       |
+| `bytes_le`  | the UUID as a 16-byte string (with time_low, time_mid, and time_hi_version in little-endian byte order)                                         |
+| `fields`    | a tuple of the six integer fields of the UUID, which are also available as six individual attributes and two derived attributes                 |
+| `hex`       | the UUID as a 32-character hexadecimal string                                                                                                   |
+| `int`       | the UUID as a 128-bit integer                                                                                                                   |
+| `urn`       | the UUID as a URN as specified in RFC 4122                                                                                                      |
+| `variant`   | the UUID variant (one of the constants RESERVED_NCS, RFC_4122, RESERVED_MICROSOFT, or RESERVED_FUTURE)                                          |
+| `version`   | the UUID version number                                                                                                                         |
+| `is_safe`   | An enum indicating whether the UUID has been generated in a way that is safe for multiprocessing applications, via `uuid_generate_time_safe(3)` |
+| `timestamp` | The timestamp of the UUID in milliseconds since epoch. Only works for UUID versions 1, 6 and 7, otherwise raises `ValueError`.                  |
+
+module `uuid_utils`
+
+| Function  | Description                                                                                                                                                                                                                                                          |
+| --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `uuid1`   | Generate a UUID from a host ID, sequence number, and the current time. If `node` is not given, `getnode()` is used to obtain the hardware address.  If `clock_seq` is given, it is used as the sequence number; otherwise a random 14-bit sequence number is chosen. |
+| `uuid3`   | Generate a UUID from the MD5 hash of a namespace UUID and a name.                                                                                                                                                                                                    |
+| `uuid4`   | Generate a random UUID.                                                                                                                                                                                                                                              |
+| `uuid5`   | Generate a UUID from the SHA-1 hash of a namespace UUID and a name.                                                                                                                                                                                                  |
+| `uuid6`   | Generate a version 6 UUID using the given timestamp and a host ID. This is similar to version 1 UUIDs, except that it is lexicographically sortable by timestamp.                                                                                                    |
+| `uuid7`   | Generate a version 7 UUID using a time value and random bytes.                                                                                                                                                                                                       |
+| `uuid8`   | Generate a custom UUID comprised almost entirely of user-supplied bytes.                                                                                                                                                                                             |
+| `getnode` | Get the hardware address as a 48-bit positive integer.                                                                                                                                                                                                               |

uuid_utils-0.8.0/docs/index.md

@@ -0,0 +1,105 @@
+# Python UUID Utils
+
+<p align="center">
+<a href="https://pypi.org/project/uuid-utils/">
+    <img src="https://badge.fury.io/py/uuid-utils.svg" alt="Package version">
+</a>
+<a href="https://pypi.org/project/uuid-utils" target="_blank">
+    <img src="https://img.shields.io/pypi/pyversions/uuid-utils.svg?color=%2334D058" alt="Supported Python versions">
+</a>
+</p>
+
+---
+
+Python UUID implementation using Rust's UUID library.
+This will make `uuid4` function around 10x faster.
+
+This package can be a drop-in replacement to the standard library UUID
+which implements existing UUID versions like v4 in Rust
+and also adds draft UUID versions like v6.
+
+Avaialble UUID versions:
+
+- `uuid1` - Version 1 UUIDs using a timestamp and monotonic counter.
+- `uuid3` - Version 3 UUIDs based on the MD5 hash of some data.
+- `uuid4` - Version 4 UUIDs with random data.
+- `uuid5` - Version 5 UUIDs based on the SHA1 hash of some data.
+- `uuid6` - Version 6 UUIDs using a timestamp and monotonic counter.
+- `uuid7` - Version 7 UUIDs using a Unix timestamp ordered by time.
+- `uuid8` - Version 8 UUIDs using user-defined data.
+
+<sup>Please note that UUID versions 6, 7 and 8 are still in draft RFC.</sup><br>
+
+## Installation
+Using `pip`:
+```shell
+$ pip install uuid-utils
+```
+or, using `conda`:
+
+```shell
+$ conda install -c conda-forge uuid-utils
+```
+
+## Example
+
+```shell
+>>> import uuid_utils as uuid
+
+>>> # make a random UUID
+>>> uuid.uuid4()
+UUID('ffe95fcc-b818-4aca-a350-e0a35b9de6ec')
+
+>>> # make a random UUID using a Unix timestamp which is time-ordered.
+>>> uuid.uuid7()
+UUID('018afa4a-0d21-7e6c-b857-012bc678552b')
+
+>>> # make a UUID using a SHA-1 hash of a namespace UUID and a name
+>>> uuid.uuid5(uuid.NAMESPACE_DNS, 'python.org')
+UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')
+
+>>> # make a UUID using an MD5 hash of a namespace UUID and a name
+>>> uuid.uuid3(uuid.NAMESPACE_DNS, 'python.org')
+UUID('6fa459ea-ee8a-3ca4-894e-db77e160355e')
+```
+
+## Compatibility
+
+In some cases, for example if you are using `Django`, you might need `UUID` instances to be returned
+from the standrad-library `uuid`, not a custom `UUID` class.
+In that case you can use the `uuid_utils.compat` which comes with a performance penalty
+in comparison with the `uuid_utils` default behaviour, but is still faster than the standard-library.
+
+```py
+>>> import uuid_utils.compat as uuid
+
+>>> # make a random UUID
+>>> uuid.uuid4()
+UUID('ffe95fcc-b818-4aca-a350-e0a35b9de6ec')
+```
+
+## Benchmarks
+
+| Benchmark        | Min   | Max   | Mean  | Min (+)       | Max (+)       | Mean (+)      |
+| ---------------- | ----- | ----- | ----- | ------------- | ------------- | ------------- |
+| UUID v1          | 0.058 | 0.059 | 0.058 | 0.005 (12.0x) | 0.005 (11.9x) | 0.005 (12.0x) |
+| UUID v3          | 0.063 | 0.064 | 0.063 | 0.008 (7.9x)  | 0.008 (8.1x)  | 0.008 (8.0x)  |
+| UUID v4          | 0.041 | 0.041 | 0.041 | 0.004 (11.1x) | 0.004 (10.8x) | 0.004 (10.9x) |
+| UUID v5          | 0.064 | 0.066 | 0.065 | 0.008 (8.1x)  | 0.008 (8.1x)  | 0.008 (8.1x)  |
+| UUID from hex    | 0.024 | 0.025 | 0.024 | 0.004 (6.7x)  | 0.004 (6.6x)  | 0.004 (6.6x)  |
+| UUID from bytes  | 0.024 | 0.025 | 0.024 | 0.004 (6.7x)  | 0.004 (6.6x)  | 0.004 (6.7x)  |
+| UUID from int    | 0.024 | 0.025 | 0.024 | 0.004 (6.6x)  | 0.004 (6.7x)  | 0.004 (6.6x)  |
+| UUID from fields | 0.028 | 0.028 | 0.028 | 0.009 (3.1x)  | 0.009 (3.1x)  | 0.009 (3.1x)  |
+
+## How to develop locally
+
+```shell
+$ make build
+$ make test
+```
+
+Or:
+
+```shell
+$ RUSTFLAGS="--cfg uuid_unstable" maturin develop --release
+```

uuid_utils-0.8.0/mkdocs.yml

@@ -0,0 +1,45 @@
+site_name: UUID-Utils
+site_description: Python bindings to Rust UUID
+site_url: https://aminalaee.dev/uuid-utils
+
+theme:
+  name: "material"
+  palette:
+    primary: white
+  features:
+    - content.code.copy
+
+repo_name: aminalaee/uuid-utils
+repo_url: https://github.com/aminalaee/uuid-utils
+edit_uri: ""
+
+nav:
+  - Introduction: "index.md"
+  - API: "api.md"
+
+markdown_extensions:
+  - markdown.extensions.codehilite:
+      guess_lang: false
+  - tables
+  - pymdownx.details
+  - pymdownx.highlight
+  - pymdownx.tabbed
+  - pymdownx.superfences
+
+watch:
+  - python/
+
+plugins:
+  - search
+
+extra:
+  analytics:
+    provider: google
+    property: G-MV427T1Z9X
+  social:
+    - icon: fontawesome/brands/github
+      link: https://github.com/aminalaee
+    - icon: fontawesome/brands/twitter
+      link: https://twitter.com/aminalaee
+    - icon: fontawesome/brands/linkedin
+      link: https://www.linkedin.com/in/amin-alaee

{uuid_utils-0.7.0 → uuid_utils-0.8.0}/pyproject.toml

@@ -42,6 +42,12 @@ ignore_missing_imports = true
 show_error_codes = true
 no_implicit_optional = true
 
-[tool.isort]
-profile = "black"
-combine_as_imports = true
+[tool.ruff.lint]
+select = [
+    "E",
+    "W",
+    "F",
+    "I",
+    "C4",
+    "UP",
+]

{uuid_utils-0.7.0 → uuid_utils-0.8.0}/python/uuid_utils/__init__.pyi

@@ -60,12 +60,15 @@ class UUID:
         variant     the UUID variant (one of the constants RESERVED_NCS,
                     RFC_4122, RESERVED_MICROSOFT, or RESERVED_FUTURE)
 
-        version     the UUID version number (1 through 5, meaningful only
-                    when the variant is RFC_4122)
+        version     the UUID version number
 
         is_safe     An enum indicating whether the UUID has been generated in
                     a way that is safe for multiprocessing applications, via
                     uuid_generate_time_safe(3).
+
+        timestamp   The timestamp of the UUID in milliseconds since epoch.
+                    Only works for UUID versions 1, 6 and 7,
+                    otherwise raises ValueError.
     """
 
     def __init__(
@@ -139,31 +142,43 @@ def uuid1(node: _Int | None = None, clock_seq: _Int | None = None) -> UUID:
     otherwise a random 14-bit sequence number is chosen."""
     ...
 
-def uuid3(namespace: UUID, name: str) -> UUID:
-    """Generate a UUID from the MD5 hash of a namespace UUID and a name."""
-    ...
+if sys.version_info >= (3, 12):
+    def uuid3(namespace: UUID, name: str | bytes) -> UUID:
+        """Generate a UUID from the MD5 hash of a namespace UUID and a name."""
+        ...
+else:
+    def uuid3(namespace: UUID, name: str) -> UUID:
+        """Generate a UUID from the MD5 hash of a namespace UUID and a name."""
+        ...
 
 def uuid4() -> UUID:
     """Generate a random UUID."""
     ...
 
-def uuid5(namespace: UUID, name: str) -> UUID:
-    """Generate a UUID from the SHA-1 hash of a namespace UUID and a name."""
-    ...
+if sys.version_info >= (3, 12):
+    def uuid5(namespace: UUID, name: str | bytes) -> UUID:
+        """Generate a UUID from the SHA-1 hash of a namespace UUID and a name."""
+        ...
+else:
+    def uuid5(namespace: UUID, name: str) -> UUID:
+        """Generate a UUID from the SHA-1 hash of a namespace UUID and a name."""
+        ...
 
-def uuid6(node: _Int | None = None, timestamp: _Int | None = None) -> UUID:
+def uuid6(
+    node: _Int | None = None, timestamp: _Int | None = None, nanos: _Int | None = None
+) -> UUID:
     """Generate a version 6 UUID using the given timestamp and a host ID.
     This is similar to version 1 UUIDs,
     except that it is lexicographically sortable by timestamp.
     """
     ...
 
-def uuid7(timestamp: _Int | None = None) -> UUID:
+def uuid7(timestamp: _Int | None = None, nanos: _Int | None = None) -> UUID:
     """Generate a version 7 UUID using a time value and random bytes."""
     ...
 
 def uuid8(bytes: _Bytes) -> UUID:
-    """Generate a custom UUID comprised almost entirely of user-supplied bytes.."""
+    """Generate a custom UUID comprised almost entirely of user-supplied bytes."""
     ...
 
 NAMESPACE_DNS: UUID

{uuid_utils-0.7.0 → uuid_utils-0.8.0}/python/uuid_utils/compat/__init__.pyi

@@ -1,7 +1,34 @@
-from uuid import UUID
+import sys
+from uuid import (
+    NAMESPACE_DNS,
+    NAMESPACE_OID,
+    NAMESPACE_URL,
+    NAMESPACE_X500,
+    RESERVED_FUTURE,
+    RESERVED_MICROSOFT,
+    RESERVED_NCS,
+    RFC_4122,
+    UUID,
+    SafeUUID,
+    getnode,
+)
 
 from typing_extensions import TypeAlias
 
+__all__ = [
+    "NAMESPACE_DNS",
+    "NAMESPACE_OID",
+    "NAMESPACE_URL",
+    "NAMESPACE_X500",
+    "RESERVED_FUTURE",
+    "RESERVED_MICROSOFT",
+    "RESERVED_NCS",
+    "RFC_4122",
+    "UUID",
+    "SafeUUID",
+    "getnode",
+]
+
 # Because UUID has properties called int and bytes we need to rename these temporarily.
 _Int: TypeAlias = int
 _Bytes: TypeAlias = bytes
@@ -13,17 +40,28 @@ def uuid1(node: _Int | None = None, clock_seq: _Int | None = None) -> UUID:
     otherwise a random 14-bit sequence number is chosen."""
     ...
 
-def uuid3(namespace: UUID, name: str) -> UUID:
-    """Generate a UUID from the MD5 hash of a namespace UUID and a name."""
-    ...
+if sys.version_info >= (3, 12):
+    def uuid3(namespace: UUID, name: str | bytes) -> UUID:
+        """Generate a UUID from the MD5 hash of a namespace UUID and a name."""
+        ...
+
+else:
+    def uuid3(namespace: UUID, name: str) -> UUID:
+        """Generate a UUID from the MD5 hash of a namespace UUID and a name."""
+        ...
 
 def uuid4() -> UUID:
     """Generate a random UUID."""
     ...
 
-def uuid5(namespace: UUID, name: str) -> UUID:
-    """Generate a UUID from the SHA-1 hash of a namespace UUID and a name."""
-    ...
+if sys.version_info >= (3, 12):
+    def uuid5(namespace: UUID, name: str | bytes) -> UUID:
+        """Generate a UUID from the SHA-1 hash of a namespace UUID and a name."""
+        ...
+else:
+    def uuid5(namespace: UUID, name: str) -> UUID:
+        """Generate a UUID from the SHA-1 hash of a namespace UUID and a name."""
+        ...
 
 def uuid6(node: _Int | None = None, timestamp: _Int | None = None) -> UUID:
     """Generate a version 6 UUID using the given timestamp and a host ID.

uuid_utils-0.8.0/requirements.txt

@@ -0,0 +1,5 @@
+mkdocs==1.6.0
+mkdocs-material==9.5.26
+mypy==1.10.0
+pytest==8.2.0
+ruff==0.4.8

{uuid_utils-0.7.0 → uuid_utils-0.8.0}/src/lib.rs

@@ -18,6 +18,14 @@ pub const RFC_4122: &str = "specified in RFC 4122";
 pub const RESERVED_MICROSOFT: &str = "reserved for Microsoft compatibility";
 pub const RESERVED_FUTURE: &str = "reserved for future definition";
 
+#[derive(FromPyObject)]
+enum StringOrBytes {
+    #[pyo3(transparent, annotation = "str")]
+    String(String),
+    #[pyo3(transparent, annotation = "bytes")]
+    Bytes(Vec<u8>),
+}
+
 #[pyclass(subclass, module = "uuid_utils")]
 #[derive(Clone, Debug)]
 struct UUID {
@@ -317,10 +325,15 @@ fn uuid1(node: Option<u64>, clock_seq: Option<u64>) -> PyResult<UUID> {
 }
 
 #[pyfunction]
-fn uuid3(namespace: UUID, name: &str) -> PyResult<UUID> {
-    Ok(UUID {
-        uuid: Uuid::new_v3(&namespace.uuid, name.as_bytes()),
-    })
+fn uuid3(namespace: UUID, name: StringOrBytes) -> PyResult<UUID> {
+    match name {
+        StringOrBytes::String(name) => Ok(UUID {
+            uuid: Uuid::new_v3(&namespace.uuid, name.as_bytes()),
+        }),
+        StringOrBytes::Bytes(name) => Ok(UUID {
+            uuid: Uuid::new_v3(&namespace.uuid, &name),
+        }),
+    }
 }
 
 #[pyfunction]
@@ -331,14 +344,19 @@ fn uuid4() -> PyResult<UUID> {
 }
 
 #[pyfunction]
-fn uuid5(namespace: &UUID, name: &str) -> PyResult<UUID> {
-    Ok(UUID {
-        uuid: Uuid::new_v5(&namespace.uuid, name.as_bytes()),
-    })
+fn uuid5(namespace: &UUID, name: StringOrBytes) -> PyResult<UUID> {
+    match name {
+        StringOrBytes::String(name) => Ok(UUID {
+            uuid: Uuid::new_v5(&namespace.uuid, name.as_bytes()),
+        }),
+        StringOrBytes::Bytes(name) => Ok(UUID {
+            uuid: Uuid::new_v5(&namespace.uuid, &name),
+        }),
+    }
 }
 
 #[pyfunction]
-fn uuid6(node: Option<u64>, timestamp: Option<u64>) -> PyResult<UUID> {
+fn uuid6(node: Option<u64>, timestamp: Option<u64>, nanos: Option<u32>) -> PyResult<UUID> {
     let node = match node {
         Some(node) => node.to_ne_bytes(),
         None => _getnode().to_ne_bytes(),
@@ -347,7 +365,8 @@ fn uuid6(node: Option<u64>, timestamp: Option<u64>) -> PyResult<UUID> {
 
     let uuid = match timestamp {
         Some(timestamp) => {
-            let timestamp = Timestamp::from_unix(&Context::new_random(), timestamp, 0);
+            let timestamp =
+                Timestamp::from_unix(&Context::new_random(), timestamp, nanos.unwrap_or(0));
             return Ok(UUID {
                 uuid: Uuid::new_v6(timestamp, node),
             });
@@ -358,10 +377,11 @@ fn uuid6(node: Option<u64>, timestamp: Option<u64>) -> PyResult<UUID> {
 }
 
 #[pyfunction]
-fn uuid7(timestamp: Option<u64>) -> PyResult<UUID> {
+fn uuid7(timestamp: Option<u64>, nanos: Option<u32>) -> PyResult<UUID> {
     let uuid = match timestamp {
         Some(timestamp) => {
-            let timestamp = Timestamp::from_unix(&Context::new_random(), timestamp, 0);
+            let timestamp =
+                Timestamp::from_unix(&Context::new_random(), timestamp, nanos.unwrap_or(0));
             return Ok(UUID {
                 uuid: Uuid::new_v7(timestamp),
             });

{uuid_utils-0.7.0 → uuid_utils-0.8.0}/tests/test_compat/test_compat.py

@@ -2,7 +2,6 @@ import uuid
 from typing import Callable
 
 import pytest
-
 from uuid_utils.compat import uuid1, uuid3, uuid4, uuid5, uuid6, uuid7, uuid8
 
 

{uuid_utils-0.7.0 → uuid_utils-0.8.0}/tests/test_uuid.py

@@ -1,10 +1,10 @@
 import copy
 import pickle
 import sys
+from datetime import datetime
 from uuid import UUID, getnode
 
 import pytest
-
 import uuid_utils
 
 
@@ -73,8 +73,9 @@ def test_uuid1() -> None:
     assert isinstance(uuid, uuid_utils.UUID)
 
 
-def test_uuid3() -> None:
-    uuid = uuid_utils.uuid3(namespace=uuid_utils.NAMESPACE_DNS, name="python.org")
+@pytest.mark.parametrize("name", ["python.org", b"python.org"])
+def test_uuid3(name: str) -> None:
+    uuid = uuid_utils.uuid3(namespace=uuid_utils.NAMESPACE_DNS, name=name)
     assert isinstance(uuid, uuid_utils.UUID)
 
 
@@ -83,8 +84,9 @@ def test_uuid4() -> None:
     assert isinstance(uuid, uuid_utils.UUID)
 
 
-def test_uuid5() -> None:
-    uuid = uuid_utils.uuid5(namespace=uuid_utils.NAMESPACE_DNS, name="python.org")
+@pytest.mark.parametrize("name", ["python.org", b"python.org"])
+def test_uuid5(name: str) -> None:
+    uuid = uuid_utils.uuid5(namespace=uuid_utils.NAMESPACE_DNS, name=name)
     assert isinstance(uuid, uuid_utils.UUID)
 
 
@@ -92,6 +94,9 @@ def test_uuid6() -> None:
     uuid = uuid_utils.uuid6(getnode(), 1679665408)
     assert isinstance(uuid, uuid_utils.UUID)
 
+    uuid = uuid_utils.uuid6(getnode(), 1679665408, 123)
+    assert isinstance(uuid, uuid_utils.UUID)
+
     uuid = uuid_utils.uuid6()
     assert isinstance(uuid, uuid_utils.UUID)
 
@@ -100,9 +105,18 @@ def test_uuid7() -> None:
     uuid = uuid_utils.uuid7(1679665408)
     assert isinstance(uuid, uuid_utils.UUID)
 
+    uuid = uuid_utils.uuid7(1679665408, 999)
+    assert isinstance(uuid, uuid_utils.UUID)
+
     uuid = uuid_utils.uuid7()
     assert isinstance(uuid, uuid_utils.UUID)
 
+    ts = datetime(
+        year=2024, month=1, day=2, hour=3, minute=4, second=5, microsecond=123000
+    )
+    uuid = uuid_utils.uuid7(int(ts.timestamp()), ts.microsecond * 1_000)
+    assert uuid.timestamp == int(ts.timestamp() * 1000)
+
 
 def test_uuid8() -> None:
     uuid = uuid_utils.uuid8(b"1234567812345678")

uuid_utils-0.7.0/Makefile

@@ -1,28 +0,0 @@
-.DEFAULT_GOAL := all
-
-.PHONY: build
-build:
-	RUSTFLAGS="--cfg uuid_unstable" maturin develop --release
-
-.PHONY: format
-format:
-	ruff --fix python/ tests/
-	black python/ tests/
-	cargo fmt
-
-.PHONY: lint
-lint:
-	ruff python/ tests/
-	black --check --diff python/ tests/
-	mypy python/ tests/
-.PHONY: test
-test:
-	pytest tests -vvv
-
-
-.PHONY: bench
-bench:
-	richbench benchmarks/
-
-.PHONY: all
-all: format build lint test

uuid_utils-0.7.0/requirements.txt

@@ -1,5 +0,0 @@
-black==24.4.2
-isort==5.13.2
-mypy==1.10.0
-pytest==8.2.0
-ruff==0.4.2