uuid_utils 0.14.0__cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

uuid_utils/__init__.py

@@ -0,0 +1,58 @@
+import os
+from uuid import SafeUUID
+
+from ._uuid_utils import (
+    MAX,
+    NAMESPACE_DNS,
+    NAMESPACE_OID,
+    NAMESPACE_URL,
+    NAMESPACE_X500,
+    NIL,
+    RESERVED_FUTURE,
+    RESERVED_MICROSOFT,
+    RESERVED_NCS,
+    RFC_4122,
+    UUID,
+    __version__,
+    getnode,
+    uuid1,
+    uuid3,
+    uuid4,
+    uuid5,
+    uuid6,
+    uuid7,
+    uuid8,
+)
+from ._uuid_utils import (
+    reseed as reseed_rng,
+)
+
+# Reseed the RNG in the child process after a fork.
+# Otherwise both parent and child processes may generate the same UUIDs for some time.
+if hasattr(os, "fork"):
+    os.register_at_fork(after_in_child=reseed_rng)
+
+__all__ = [
+    "MAX",
+    "NAMESPACE_DNS",
+    "NAMESPACE_OID",
+    "NAMESPACE_URL",
+    "NAMESPACE_X500",
+    "NIL",
+    "RESERVED_FUTURE",
+    "RESERVED_MICROSOFT",
+    "RESERVED_NCS",
+    "RFC_4122",
+    "UUID",
+    "SafeUUID",
+    "__version__",
+    "getnode",
+    "reseed_rng",
+    "uuid1",
+    "uuid3",
+    "uuid4",
+    "uuid5",
+    "uuid6",
+    "uuid7",
+    "uuid8",
+]

uuid_utils/__init__.pyi

@@ -0,0 +1,218 @@
+import builtins
+import sys
+from typing import Final
+from uuid import SafeUUID
+
+from typing_extensions import LiteralString, 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.
+    """
+
+    is_safe: Final[SafeUUID]
+    int: Final[builtins.int]
+
+    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 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 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 __hash__(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 reseed_rng() -> None:
+    """
+    Reseeds the underlying rng.
+    This is useful in cases where you fork, as without reseeding the
+    generated uuids may be identical. This can be called manually in the child process,
+    or automatically run after fork with:
+
+    os.register_at_fork(after_in_child=uuid_utils.reseed_rng)
+    """
+    ...
+
+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: Final[UUID]
+NAMESPACE_URL: Final[UUID]
+NAMESPACE_OID: Final[UUID]
+NAMESPACE_X500: Final[UUID]
+RESERVED_NCS: Final[LiteralString]
+RFC_4122: Final[LiteralString]
+RESERVED_MICROSOFT: Final[LiteralString]
+RESERVED_FUTURE: Final[LiteralString]
+NIL: Final[UUID]
+MAX: Final[UUID]
+
+__all__ = [
+    "MAX",
+    "NAMESPACE_DNS",
+    "NAMESPACE_OID",
+    "NAMESPACE_URL",
+    "NAMESPACE_X500",
+    "NIL",
+    "RESERVED_FUTURE",
+    "RESERVED_MICROSOFT",
+    "RESERVED_NCS",
+    "RFC_4122",
+    "UUID",
+    "SafeUUID",
+    "__version__",
+    "getnode",
+    "reseed_rng",
+    "uuid1",
+    "uuid3",
+    "uuid4",
+    "uuid5",
+    "uuid6",
+    "uuid7",
+    "uuid8",
+]

uuid_utils/compat/__init__.py

@@ -0,0 +1,83 @@
+from uuid import (
+    NAMESPACE_DNS,
+    NAMESPACE_OID,
+    NAMESPACE_URL,
+    NAMESPACE_X500,
+    RESERVED_FUTURE,
+    RESERVED_MICROSOFT,
+    RESERVED_NCS,
+    RFC_4122,
+    UUID,
+    getnode,
+)
+
+import uuid_utils
+
+NIL = UUID("00000000-0000-0000-0000-000000000000")
+MAX = UUID("ffffffff-ffff-ffff-ffff-ffffffffffff")
+
+
+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, nanos=None):
+    """Generate a version 7 UUID using a time value and random bytes."""
+    return UUID(int=uuid_utils.uuid7(timestamp, nanos).int)
+
+
+def uuid8(bytes):
+    """Generate a custom UUID comprised almost entirely of user-supplied bytes.."""
+    return UUID(bytes=uuid_utils.uuid8(bytes).bytes)
+
+
+__all__ = [
+    "MAX",
+    "NAMESPACE_DNS",
+    "NAMESPACE_OID",
+    "NAMESPACE_URL",
+    "NAMESPACE_X500",
+    "NIL",
+    "RESERVED_FUTURE",
+    "RESERVED_MICROSOFT",
+    "RESERVED_NCS",
+    "RFC_4122",
+    "UUID",
+    "getnode",
+    "uuid1",
+    "uuid3",
+    "uuid4",
+    "uuid5",
+    "uuid6",
+    "uuid7",
+    "uuid8",
+]

uuid_utils/compat/__init__.pyi

@@ -0,0 +1,79 @@
+import sys
+from typing import Final
+from uuid import (
+    NAMESPACE_DNS,
+    NAMESPACE_OID,
+    NAMESPACE_URL,
+    NAMESPACE_X500,
+    RESERVED_FUTURE,
+    RESERVED_MICROSOFT,
+    RESERVED_NCS,
+    RFC_4122,
+    UUID,
+    SafeUUID,
+    getnode,
+)
+
+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, 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.."""
+    ...
+
+NIL: Final[UUID]
+MAX: Final[UUID]
+
+__all__ = [
+    "MAX",
+    "NAMESPACE_DNS",
+    "NAMESPACE_OID",
+    "NAMESPACE_URL",
+    "NAMESPACE_X500",
+    "NIL",
+    "RESERVED_FUTURE",
+    "RESERVED_MICROSOFT",
+    "RESERVED_NCS",
+    "RFC_4122",
+    "UUID",
+    "SafeUUID",
+    "getnode",
+]

uuid_utils-0.14.0.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: uuid_utils
+Version: 0.14.0
+Classifier: Development Status :: 4 - Beta
+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 :: Python :: 3.14
+Classifier: Programming Language :: Rust
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+License-File: LICENSE.md
+Summary: Fast, drop-in replacement for Python's uuid module, powered by Rust.
+Keywords: rust,uuid
+Author-email: Amin Alaee <mohammadamin.alaee@gmail.com>
+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
+
+<div align="center">
+
+[![Package version](https://badge.fury.io/py/uuid-utils.svg)](https://pypi.org/project/uuid-utils/)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/uuid-utils.svg?color=%2334D058)](https://pypi.org/project/uuid-utils)
+[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/aminalaee/uuid-utils?utm_source=badge)
+
+</div>
+
+---
+
+Fast, drop-in replacement for Python's uuid module, powered by Rust.
+
+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 with Python UUID
+
+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.073 | 0.119 | 0.083 | 0.005 (15.2x) | 0.005 (24.6x) | 0.005 (17.1x) |
+| UUID v5          | 0.058 | 0.189 | 0.146 | 0.008 (7.6x)  | 0.038 (5.0x)  | 0.016 (9.0x)  |
+| UUID v6          | 0.032 | 0.033 | 0.032 | 0.003 (10.1x) | 0.003 (10.3x) | 0.003 (10.1x) |
+| UUID v7          | 0.063 | 0.063 | 0.063 | 0.004 (16.1x) | 0.004 (16.0x) | 0.004 (16.1x) |
+| 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.14.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+uuid_utils/__init__.py,sha256=IK1KFAgXf56uuZMbXIXiR2RM77SGpovcvQiVYk1vncE,1003
+uuid_utils/__init__.pyi,sha256=l6Lox5NQQ5GaS9s6ED9rWAEUFXEc_q3Ih35SvTBeSKQ,7411
+uuid_utils/_uuid_utils.abi3.so,sha256=UFUhgIylfcqIRNKhWZvpwooJT7tT7du1ybNcfONjIQQ,822240
+uuid_utils/compat/__init__.py,sha256=ng6cZaL3Oj38xPGOVCQmthDJJhWsNfQaXV9_1Hse-g4,2216
+uuid_utils/compat/__init__.pyi,sha256=d75Gv0r1xxiiQUNeiYpsJnyWKa8iCPZhbVFX_38ZSrw,2183
+uuid_utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uuid_utils-0.14.0.dist-info/METADATA,sha256=lIddL_Ap-YjOuEhN2O1wGlI9r7R9Ag5mfbGrwdwPQQg,4852
+uuid_utils-0.14.0.dist-info/WHEEL,sha256=btCZOUXJMzNcRkylrJSGktvUfAhpsQmBEeAGzSFPuxs,145
+uuid_utils-0.14.0.dist-info/licenses/LICENSE.md,sha256=DEf1K0xIS9BMeOfJaVQu6jGv5kT1h_O4qMzOhjUsYEY,1487
+uuid_utils-0.14.0.dist-info/RECORD,,

uuid_utils-0.14.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp39-abi3-manylinux_2_17_aarch64
+Tag: cp39-abi3-manylinux2014_aarch64

uuid_utils-0.14.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.