uuid-utils 0.11.0__cp39-abi3-win_arm64.whl

uuid_utils/__init__.py

@@ -0,0 +1,44 @@
+from uuid import SafeUUID
+
+from ._uuid_utils import (
+    NAMESPACE_DNS,
+    NAMESPACE_OID,
+    NAMESPACE_URL,
+    NAMESPACE_X500,
+    RESERVED_FUTURE,
+    RESERVED_MICROSOFT,
+    RESERVED_NCS,
+    RFC_4122,
+    UUID,
+    __version__,
+    getnode,
+    uuid1,
+    uuid3,
+    uuid4,
+    uuid5,
+    uuid6,
+    uuid7,
+    uuid8,
+)
+
+__all__ = [
+    "NAMESPACE_DNS",
+    "NAMESPACE_OID",
+    "NAMESPACE_URL",
+    "NAMESPACE_X500",
+    "RESERVED_FUTURE",
+    "RESERVED_MICROSOFT",
+    "RESERVED_NCS",
+    "RFC_4122",
+    "UUID",
+    "SafeUUID",
+    "__version__",
+    "getnode",
+    "uuid1",
+    "uuid3",
+    "uuid4",
+    "uuid5",
+    "uuid6",
+    "uuid7",
+    "uuid8",
+]

uuid_utils/__init__.pyi

@@ -0,0 +1,201 @@
+import builtins
+import sys
+from uuid import SafeUUID
+
+from typing_extensions import TypeAlias
+
+# Because UUID has properties called int and bytes we need to rename these temporarily.
+_FieldsType: TypeAlias = tuple[int, int, int, int, int, int]
+
+__version__: str
+
+class UUID:
+    """Instances of the UUID class represent UUIDs as specified in RFC 4122.
+    UUID objects are immutable, hashable, and usable as dictionary keys.
+    Converting a UUID to a string with str() yields something in the form
+    '12345678-1234-1234-1234-123456789abc'.  The UUID constructor accepts
+    five possible forms: a similar string of hexadecimal digits, or a tuple
+    of six integer fields (with 32-bit, 16-bit, 16-bit, 8-bit, 8-bit, and
+    48-bit values respectively) as an argument named 'fields', or a string
+    of 16 bytes (with all the integer fields in big-endian order) as an
+    argument named 'bytes', or a string of 16 bytes (with the first three
+    fields in little-endian order) as an argument named 'bytes_le', or a
+    single 128-bit integer as an argument named 'int'.
+
+    UUIDs have these read-only attributes:
+
+        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:
+
+            time_low                the first 32 bits of the UUID
+            time_mid                the next 16 bits of the UUID
+            time_hi_version         the next 16 bits of the UUID
+            clock_seq_hi_variant    the next 8 bits of the UUID
+            clock_seq_low           the next 8 bits of the UUID
+            node                    the last 48 bits of the UUID
+
+            time                    the 60-bit timestamp
+            clock_seq               the 14-bit sequence number
+
+        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.
+    """
+
+    def __init__(
+        self,
+        hex: str | None = None,
+        bytes: builtins.bytes | None = None,
+        bytes_le: builtins.bytes | None = None,
+        fields: _FieldsType | None = None,
+        int: builtins.int | None = None,
+        version: builtins.int | None = None,
+        *,
+        is_safe: SafeUUID = ...,
+    ) -> None: ...
+    @property
+    def is_safe(self) -> SafeUUID: ...
+    @property
+    def bytes(self) -> builtins.bytes: ...
+    @property
+    def bytes_le(self) -> builtins.bytes: ...
+    @property
+    def clock_seq(self) -> builtins.int: ...
+    @property
+    def clock_seq_hi_variant(self) -> builtins.int: ...
+    @property
+    def clock_seq_low(self) -> builtins.int: ...
+    @property
+    def fields(self) -> _FieldsType: ...
+    @property
+    def hex(self) -> str: ...
+    @property
+    def int(self) -> builtins.int: ...
+    @property
+    def node(self) -> builtins.int: ...
+    @property
+    def time(self) -> builtins.int: ...
+    @property
+    def time_hi_version(self) -> builtins.int: ...
+    @property
+    def time_low(self) -> builtins.int: ...
+    @property
+    def time_mid(self) -> builtins.int: ...
+    @property
+    def timestamp(self) -> builtins.int:
+        """Get UUID timestamp milliseconds since epoch.
+        Only works for UUID versions 1, 6 and 7, otherwise raises ValueError."""
+        ...
+
+    @property
+    def urn(self) -> str: ...
+    @property
+    def variant(self) -> str: ...
+    @property
+    def version(self) -> builtins.int | None: ...
+    def __int__(self) -> builtins.int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __lt__(self, other: UUID) -> bool: ...
+    def __le__(self, other: UUID) -> bool: ...
+    def __gt__(self, other: UUID) -> bool: ...
+    def __ge__(self, other: UUID) -> bool: ...
+
+def getnode() -> int: ...
+def uuid1(node: int | None = None, clock_seq: int | None = None) -> UUID:
+    """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."""
+    ...
+
+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."""
+    ...
+
+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, 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, 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."""
+    ...
+
+NAMESPACE_DNS: UUID
+NAMESPACE_URL: UUID
+NAMESPACE_OID: UUID
+NAMESPACE_X500: UUID
+RESERVED_NCS: str
+RFC_4122: str
+RESERVED_MICROSOFT: str
+RESERVED_FUTURE: str
+
+__all__ = [
+    "NAMESPACE_DNS",
+    "NAMESPACE_OID",
+    "NAMESPACE_URL",
+    "NAMESPACE_X500",
+    "RESERVED_FUTURE",
+    "RESERVED_MICROSOFT",
+    "RESERVED_NCS",
+    "RFC_4122",
+    "UUID",
+    "SafeUUID",
+    "__version__",
+    "getnode",
+    "uuid1",
+    "uuid3",
+    "uuid4",
+    "uuid5",
+    "uuid6",
+    "uuid7",
+    "uuid8",
+]

uuid_utils/compat/__init__.py

@@ -0,0 +1,77 @@
+from uuid import (
+    NAMESPACE_DNS,
+    NAMESPACE_OID,
+    NAMESPACE_URL,
+    NAMESPACE_X500,
+    RESERVED_FUTURE,
+    RESERVED_MICROSOFT,
+    RESERVED_NCS,
+    RFC_4122,
+    UUID,
+    getnode,
+)
+
+import uuid_utils
+
+__all__ = [
+    "NAMESPACE_DNS",
+    "NAMESPACE_OID",
+    "NAMESPACE_URL",
+    "NAMESPACE_X500",
+    "RESERVED_FUTURE",
+    "RESERVED_MICROSOFT",
+    "RESERVED_NCS",
+    "RFC_4122",
+    "UUID",
+    "getnode",
+    "uuid1",
+    "uuid3",
+    "uuid4",
+    "uuid5",
+    "uuid6",
+    "uuid7",
+    "uuid8",
+]
+
+
+def uuid1(node=None, clock_seq=None):
+    """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."""
+    return UUID(int=uuid_utils.uuid1(node, clock_seq).int)
+
+
+def uuid3(namespace, name):
+    """Generate a UUID from the MD5 hash of a namespace UUID and a name."""
+    namespace = uuid_utils.UUID(namespace.hex) if namespace else namespace
+    return UUID(int=uuid_utils.uuid3(namespace, name).int)
+
+
+def uuid4():
+    """Generate a random UUID."""
+    return UUID(int=uuid_utils.uuid4().int)
+
+
+def uuid5(namespace, name):
+    """Generate a UUID from the SHA-1 hash of a namespace UUID and a name."""
+    namespace = uuid_utils.UUID(namespace.hex) if namespace else namespace
+    return UUID(int=uuid_utils.uuid5(namespace, name).int)
+
+
+def uuid6(node=None, timestamp=None):
+    """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.
+    """
+    return UUID(int=uuid_utils.uuid6(node, timestamp).int)
+
+
+def uuid7(timestamp=None):
+    """Generate a version 7 UUID using a time value and random bytes."""
+    return UUID(int=uuid_utils.uuid7(timestamp).int)
+
+
+def uuid8(bytes):
+    """Generate a custom UUID comprised almost entirely of user-supplied bytes.."""
+    return UUID(bytes=uuid_utils.uuid8(bytes).bytes)

uuid_utils/compat/__init__.pyi

@@ -0,0 +1,79 @@
+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
+
+def uuid1(node: _Int | None = None, clock_seq: _Int | None = None) -> UUID:
+    """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."""
+    ...
+
+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."""
+    ...
+
+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.
+    This is similar to version 1 UUIDs,
+    except that it is lexicographically sortable by timestamp.
+    """
+    ...
+
+def uuid7(timestamp: _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.."""
+    ...

uuid_utils-0.11.0.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: uuid_utils
+Version: 0.11.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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 :: Rust
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+License-File: LICENSE.md
+Summary: Drop-in replacement for Python UUID with bindings in Rust
+Keywords: rust,uuid
+Author-email: Amin Alaee <me@aminalaee.dev>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Documentation, https://github.com/aminalaee/uuid-utils
+Project-URL: Issues, https://github.com/aminalaee/uuid-utils/issues
+Project-URL: Source, https://github.com/aminalaee/uuid-utils
+
+# 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.
+
+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.
+
+## 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.061   | 0.299   | 0.194   | 0.019 (3.3x)    | 0.019 (15.4x)   | 0.019 (10.1x)   |
+|          UUID v3 | 0.267   | 0.307   | 0.293   | 0.035 (7.6x)    | 0.041 (7.5x)    | 0.039 (7.5x)    |
+|          UUID v4 | 0.145   | 0.301   | 0.249   | 0.004 (38.5x)   | 0.005 (54.8x)   | 0.005 (53.0x)   |
+|          UUID v5 | 0.058   | 0.189   | 0.146   | 0.008 (7.6x)    | 0.038 (5.0x)    | 0.016 (9.0x)    |
+|    UUID from hex | 0.128   | 0.139   | 0.135   | 0.016 (8.2x)    | 0.017 (8.0x)    | 0.016 (8.3x)    |
+|  UUID from bytes | 0.031   | 0.135   | 0.093   | 0.016 (2.0x)    | 0.016 (8.6x)    | 0.016 (5.9x)    |
+|    UUID from int | 0.027   | 0.102   | 0.043   | 0.003 (8.3x)    | 0.004 (25.0x)   | 0.003 (12.4x)   |
+| UUID from fields | 0.031   | 0.162   | 0.077   | 0.005 (6.0x)    | 0.005 (30.6x)   | 0.005 (14.7x)   |
+
+<sup>Benchmark results might vary in different environments, but in most cases the uuid_utils should outperform stdlib uuid.</sup><br>
+
+## How to develop locally
+
+```shell
+$ make build
+$ make test
+```
+
+Or:
+
+```shell
+$ RUSTFLAGS="--cfg uuid_unstable" maturin develop --release
+```
+

uuid_utils-0.11.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+uuid_utils-0.11.0.dist-info/METADATA,sha256=1IxzJ6cxyDjls-gFk2Ks7N1_Jw0lVif3_uqb6U5QhFo,4839
+uuid_utils-0.11.0.dist-info/WHEEL,sha256=wnpaYzw6DTRETs-AgcmcTw1aT0IqEATWae88mnkmgyc,94
+uuid_utils-0.11.0.dist-info/licenses/LICENSE.md,sha256=IJMw6B06iYYOnseem_iUvnBfB1Wjhp13qgkfxKL5GQM,1513
+uuid_utils/__init__.py,sha256=d8wMPt50wY4SCUdfC2VVcAI_8fW0g2lVA-7lIjAjBgI,709
+uuid_utils/__init__.pyi,sha256=VF0h5095ufcHgTly-6kao4qXTZmzH0Y2h1WMQSN3HMc,7060
+uuid_utils/_uuid_utils.pyd,sha256=NmN9nWIgnsmu5JeHSBAPxwEBOq-r7tpnCZ_VShNZ8t8,376320
+uuid_utils/compat/__init__.py,sha256=QEAcG2N9_8Rr_9REdG11ZTvUtEPK98lfkku2RRWnR3g,2148
+uuid_utils/compat/__init__.pyi,sha256=3zv8W-A9UTdq-jK5dW2H0wkv2Uugn6DMPipy2EdOosM,2338
+uuid_utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uuid_utils-0.11.0.dist-info/RECORD,,

uuid_utils-0.11.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.8.6)
+Root-Is-Purelib: false
+Tag: cp39-abi3-win_arm64

uuid_utils-0.11.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,27 @@
+Copyright © 2023, Amin Alaee.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.