ulid-transform 0.10.1__pp310-pypy310_pp73-macosx_14_0_arm64.whl

ulid_transform/_ulid_impl.pyx

@@ -0,0 +1,41 @@
+# distutils: language = c++
+from libcpp.string cimport string
+
+from time import time
+from typing import Optional
+
+import cython
+
+
+cdef extern from "ulid_wrapper.h":
+    string _cpp_ulid_at_time(double timestamp)
+    string _cpp_ulid_to_bytes(const char * ulid_string)
+    string _cpp_ulid()
+    string _cpp_bytes_to_ulid(string ulid_bytes)
+
+
+def _ulid_now() -> str:
+    return _cpp_ulid().decode("ascii")
+
+def _ulid_at_time(_time: float) -> str:
+    return _cpp_ulid_at_time(_time).decode("ascii")
+
+def _ulid_to_bytes(ulid_str: str) -> bytes:
+    if len(ulid_str) != 26:
+        raise ValueError(f"ULID must be a 26 character string: {ulid_str}")
+    return _cpp_ulid_to_bytes(ulid_str.encode("ascii"))
+
+def _bytes_to_ulid(ulid_bytes: bytes) -> str:
+    if len(ulid_bytes) != 16:
+        raise ValueError(f"ULID bytes be 16 bytes: {ulid_bytes}")
+    return _cpp_bytes_to_ulid(ulid_bytes).decode("ascii")
+
+def _ulid_to_bytes_or_none(ulid_str: Optional[str]) -> Optional[bytes]:
+    if ulid_str is None or len(ulid_str) != 26:
+        return None
+    return _cpp_ulid_to_bytes(ulid_str.encode("ascii"))
+
+def _bytes_to_ulid_or_none(ulid_bytes: Optional[bytes]) -> Optional[str]:
+    if ulid_bytes is None or len(ulid_bytes) != 16:
+        return None
+    return _cpp_bytes_to_ulid(ulid_bytes).decode("ascii")

ulid_transform/ulid.hh

@@ -0,0 +1,17 @@
+// Originally from https://github.com/suyash/ulid
+
+#ifndef ULID_HH
+#define ULID_HH
+
+// http://stackoverflow.com/a/23981011
+#ifdef __SIZEOF_INT128__
+#define ULIDUINT128
+#endif
+
+#ifdef ULIDUINT128
+#include "ulid_uint128.hh"
+#else
+#include "ulid_struct.hh"
+#endif // ULIDUINT128
+
+#endif // ULID_HH

ulid_transform/ulid_impl.py

@@ -0,0 +1,453 @@
+import array
+from random import getrandbits
+from time import time
+
+# From https://github.com/ahawker/ulid/blob/06289583e9de4286b4d80b4ad000d137816502ca/ulid/base32.py#L102
+#: Array that maps encoded string char byte values to enable O(1) lookups.
+_DECODE = array.array(
+    "B",
+    (
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0x00,
+        0x01,
+        0x02,
+        0x03,
+        0x04,
+        0x05,
+        0x06,
+        0x07,
+        0x08,
+        0x09,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0x0A,
+        0x0B,
+        0x0C,
+        0x0D,
+        0x0E,
+        0x0F,
+        0x10,
+        0x11,
+        0x01,
+        0x12,
+        0x13,
+        0x01,
+        0x14,
+        0x15,
+        0x00,
+        0x16,
+        0x17,
+        0x18,
+        0x19,
+        0x1A,
+        0xFF,
+        0x1B,
+        0x1C,
+        0x1D,
+        0x1E,
+        0x1F,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0x0A,
+        0x0B,
+        0x0C,
+        0x0D,
+        0x0E,
+        0x0F,
+        0x10,
+        0x11,
+        0x01,
+        0x12,
+        0x13,
+        0x01,
+        0x14,
+        0x15,
+        0x00,
+        0x16,
+        0x17,
+        0x18,
+        0x19,
+        0x1A,
+        0xFF,
+        0x1B,
+        0x1C,
+        0x1D,
+        0x1E,
+        0x1F,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+    ),
+)
+
+
+def ulid_hex() -> str:
+    """Generate a ULID in lowercase hex that will work for a UUID.
+
+    This ulid should not be used for cryptographically secure
+    operations.
+
+    This string can be converted with https://github.com/ahawker/ulid
+
+    ulid.from_uuid(uuid.UUID(ulid_hex))
+    """
+    return f"{int(time()*1000):012x}{getrandbits(80):020x}"
+
+
+def ulid_now() -> str:
+    """Generate a ULID."""
+    return ulid_at_time(time())
+
+
+def ulid_at_time(timestamp: float) -> str:
+    """Generate a ULID.
+
+    This ulid should not be used for cryptographically secure
+    operations.
+
+     01AN4Z07BY      79KA1307SR9X4MV3
+    |----------|    |----------------|
+     Timestamp          Randomness
+       48bits             80bits
+
+    This string can be loaded directly with https://github.com/ahawker/ulid
+
+    import ulid_transform as ulid_util
+    import ulid
+    ulid.parse(ulid_util.ulid())
+    """
+    return _encode(
+        int((timestamp) * 1000).to_bytes(6, byteorder="big")
+        + int(getrandbits(80)).to_bytes(10, byteorder="big")
+    )
+
+
+def _encode(ulid_bytes: bytes) -> str:
+    # This is base32 crockford encoding with the loop unrolled for performance
+    #
+    # This code is adapted from:
+    # https://github.com/ahawker/ulid/blob/06289583e9de4286b4d80b4ad000d137816502ca/ulid/base32.py#L102
+    #
+    enc = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
+    return (
+        enc[(ulid_bytes[0] & 224) >> 5]
+        + enc[ulid_bytes[0] & 31]
+        + enc[(ulid_bytes[1] & 248) >> 3]
+        + enc[((ulid_bytes[1] & 7) << 2) | ((ulid_bytes[2] & 192) >> 6)]
+        + enc[((ulid_bytes[2] & 62) >> 1)]
+        + enc[((ulid_bytes[2] & 1) << 4) | ((ulid_bytes[3] & 240) >> 4)]
+        + enc[((ulid_bytes[3] & 15) << 1) | ((ulid_bytes[4] & 128) >> 7)]
+        + enc[(ulid_bytes[4] & 124) >> 2]
+        + enc[((ulid_bytes[4] & 3) << 3) | ((ulid_bytes[5] & 224) >> 5)]
+        + enc[ulid_bytes[5] & 31]
+        + enc[(ulid_bytes[6] & 248) >> 3]
+        + enc[((ulid_bytes[6] & 7) << 2) | ((ulid_bytes[7] & 192) >> 6)]
+        + enc[(ulid_bytes[7] & 62) >> 1]
+        + enc[((ulid_bytes[7] & 1) << 4) | ((ulid_bytes[8] & 240) >> 4)]
+        + enc[((ulid_bytes[8] & 15) << 1) | ((ulid_bytes[9] & 128) >> 7)]
+        + enc[(ulid_bytes[9] & 124) >> 2]
+        + enc[((ulid_bytes[9] & 3) << 3) | ((ulid_bytes[10] & 224) >> 5)]
+        + enc[ulid_bytes[10] & 31]
+        + enc[(ulid_bytes[11] & 248) >> 3]
+        + enc[((ulid_bytes[11] & 7) << 2) | ((ulid_bytes[12] & 192) >> 6)]
+        + enc[(ulid_bytes[12] & 62) >> 1]
+        + enc[((ulid_bytes[12] & 1) << 4) | ((ulid_bytes[13] & 240) >> 4)]
+        + enc[((ulid_bytes[13] & 15) << 1) | ((ulid_bytes[14] & 128) >> 7)]
+        + enc[(ulid_bytes[14] & 124) >> 2]
+        + enc[((ulid_bytes[14] & 3) << 3) | ((ulid_bytes[15] & 224) >> 5)]
+        + enc[ulid_bytes[15] & 31]
+    )
+
+
+def ulid_to_bytes(value: str) -> bytes:
+    """Decode a ulid to bytes."""
+    if len(value) != 26:
+        raise ValueError(f"ULID must be a 26 character string: {value}")
+    encoded = value.encode("ascii")
+    decoding = _DECODE
+    return bytes(
+        (
+            ((decoding[encoded[0]] << 5) | decoding[encoded[1]]) & 0xFF,
+            ((decoding[encoded[2]] << 3) | (decoding[encoded[3]] >> 2)) & 0xFF,
+            (
+                (decoding[encoded[3]] << 6)
+                | (decoding[encoded[4]] << 1)
+                | (decoding[encoded[5]] >> 4)
+            )
+            & 0xFF,
+            ((decoding[encoded[5]] << 4) | (decoding[encoded[6]] >> 1)) & 0xFF,
+            (
+                (decoding[encoded[6]] << 7)
+                | (decoding[encoded[7]] << 2)
+                | (decoding[encoded[8]] >> 3)
+            )
+            & 0xFF,
+            ((decoding[encoded[8]] << 5) | (decoding[encoded[9]])) & 0xFF,
+            ((decoding[encoded[10]] << 3) | (decoding[encoded[11]] >> 2)) & 0xFF,
+            (
+                (decoding[encoded[11]] << 6)
+                | (decoding[encoded[12]] << 1)
+                | (decoding[encoded[13]] >> 4)
+            )
+            & 0xFF,
+            ((decoding[encoded[13]] << 4) | (decoding[encoded[14]] >> 1)) & 0xFF,
+            (
+                (decoding[encoded[14]] << 7)
+                | (decoding[encoded[15]] << 2)
+                | (decoding[encoded[16]] >> 3)
+            )
+            & 0xFF,
+            ((decoding[encoded[16]] << 5) | (decoding[encoded[17]])) & 0xFF,
+            ((decoding[encoded[18]] << 3) | (decoding[encoded[19]] >> 2)) & 0xFF,
+            (
+                (decoding[encoded[19]] << 6)
+                | (decoding[encoded[20]] << 1)
+                | (decoding[encoded[21]] >> 4)
+            )
+            & 0xFF,
+            ((decoding[encoded[21]] << 4) | (decoding[encoded[22]] >> 1)) & 0xFF,
+            (
+                (decoding[encoded[22]] << 7)
+                | (decoding[encoded[23]] << 2)
+                | (decoding[encoded[24]] >> 3)
+            )
+            & 0xFF,
+            ((decoding[encoded[24]] << 5) | (decoding[encoded[25]])) & 0xFF,
+        )
+    )
+
+
+def bytes_to_ulid(value: bytes) -> str:
+    """Encode bytes to a ulid."""
+    if len(value) != 16:
+        raise ValueError(f"ULID bytes must be 16 bytes: {value!r}")
+    return _encode(value)
+
+
+def ulid_to_bytes_or_none(ulid: str | None) -> bytes | None:
+    """Convert an ulid to bytes."""
+    if ulid is None:
+        return None
+    try:
+        return ulid_to_bytes(ulid)
+    except ValueError:
+        return None
+
+
+def bytes_to_ulid_or_none(_bytes: bytes | None) -> str | None:
+    """Convert bytes to a ulid."""
+    if _bytes is None:
+        return None
+    try:
+        return bytes_to_ulid(_bytes)
+    except ValueError:
+        return None
+
+
+try:
+    from ._ulid_impl import (  # type: ignore[no-redef] # noqa: F811 F401 # pragma: no cover
+        _bytes_to_ulid as bytes_to_ulid,
+    )
+    from ._ulid_impl import (  # type: ignore[no-redef] # noqa: F811 F401 # pragma: no cover
+        _bytes_to_ulid_or_none as bytes_to_ulid_or_none,
+    )
+    from ._ulid_impl import (  # type: ignore[no-redef] # noqa: F811 F401 # pragma: no cover
+        _ulid_at_time as ulid_at_time,
+    )
+    from ._ulid_impl import (  # type: ignore[no-redef] # noqa: F811 F401 # pragma: no cover
+        _ulid_now as ulid_now,
+    )
+    from ._ulid_impl import (  # type: ignore[no-redef] # noqa: F811 F401 # pragma: no cover
+        _ulid_to_bytes as ulid_to_bytes,
+    )
+    from ._ulid_impl import (  # type: ignore[no-redef] # noqa: F811 F401 # pragma: no cover
+        _ulid_to_bytes_or_none as ulid_to_bytes_or_none,
+    )
+except ImportError:  # pragma: no cover
+    pass  # pragma: no cover