python-ulid 2.7.0__py3-none-any.whl → 3.1.0__py3-none-any.whl

{python_ulid-2.7.0.dist-info → python_ulid-3.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: python-ulid
-Version: 2.7.0
+Version: 3.1.0
 Summary: Universally unique lexicographically sortable identifier
 Project-URL: Homepage, https://github.com/mdomke/python-ulid
 Project-URL: Documentation, https://python-ulid.readthedocs.io
@@ -22,6 +22,7 @@ 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: Topic :: Software Development :: Libraries
 Requires-Python: >=3.9
 Provides-Extra: pydantic

python_ulid-3.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+ulid/__init__.py,sha256=g9Fb4nyq2mt3wGtLdmv3h9HutFJXLsrv_3HiVM-Qph8,12419
+ulid/__main__.py,sha256=TUo3dkWkJLfzRJyd55nfqGqvv1NcG7fBpsZHIi_p4rw,5421
+ulid/base32.py,sha256=iUE5BGPW5Dul-Eu3ITvcymk8acNkIFAVTlrL12YIPKI,5961
+ulid/constants.py,sha256=lbCLRNQXq8qnOdz_w-nJf_j5dC2X7Gjv-8GJUbs5jX8,503
+ulid/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_ulid-3.1.0.dist-info/METADATA,sha256=TM_dpKEq830WTj6mahb6qF_5wiVnL6-Rau-6REqSoSQ,5833
+python_ulid-3.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_ulid-3.1.0.dist-info/entry_points.txt,sha256=9214ghzfSgS8a-TjjlWDF7bI7KSaeewOCBKn5uz7bdU,50
+python_ulid-3.1.0.dist-info/licenses/LICENSE,sha256=DiDPNhW5yUHIqaKowvX0c1c9xWiI0xW4ji8R9N2NJbw,1056
+python_ulid-3.1.0.dist-info/RECORD,,

{python_ulid-2.7.0.dist-info → python_ulid-3.1.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.24.2
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

ulid/__init__.py

@@ -4,19 +4,24 @@ import functools
 import os
 import time
 import uuid
-from collections.abc import Callable
 from datetime import datetime
 from datetime import timezone
+from threading import Lock
 from typing import Any
+from typing import cast
 from typing import Generic
 from typing import TYPE_CHECKING
 from typing import TypeVar
 
+from typing_extensions import Self
+
 from ulid import base32
 from ulid import constants
 
 
 if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import Callable
+
     from pydantic import GetCoreSchemaHandler
     from pydantic import ValidatorFunctionWrapHandler
     from pydantic_core import CoreSchema
@@ -29,7 +34,6 @@ except ImportError:  # pragma: no cover
 
 __version__ = version("python-ulid")
 
-
 T = TypeVar("T", bound=type)
 R = TypeVar("R")
 
@@ -44,17 +48,50 @@ class validate_type(Generic[T]):  # noqa: N801
             if not isinstance(value, self.types):
                 message = "Value has to be of type "
                 message += " or ".join([t.__name__ for t in self.types])
-                raise ValueError(message)
+                raise TypeError(message)
             return func(cls, value)
 
         return wrapped
 
 
-U = TypeVar("U", bound="ULID")
+class ValueProvider:
+    def __init__(self) -> None:
+        self.lock = Lock()
+        self.prev_timestamp = constants.MIN_TIMESTAMP
+        self.prev_randomness = constants.MIN_RANDOMNESS
+
+    def timestamp(self, value: float | None = None) -> int:
+        if value is None:
+            value = time.time_ns() // constants.NANOSECS_IN_MILLISECS
+        elif isinstance(value, float):
+            value = int(value * constants.MILLISECS_IN_SECS)
+        if value > constants.MAX_TIMESTAMP:
+            raise ValueError("Value exceeds maximum possible timestamp")
+        return value
+
+    def randomness(self) -> bytes:
+        with self.lock:
+            current_timestamp = self.timestamp()
+            if current_timestamp == self.prev_timestamp:
+                if self.prev_randomness == constants.MAX_RANDOMNESS:
+                    raise ValueError("Randomness within same millisecond exhausted")
+                randomness = self.increment_bytes(self.prev_randomness)
+            else:
+                randomness = os.urandom(constants.RANDOMNESS_LEN)
+
+            self.prev_randomness = randomness
+            self.prev_timestamp = current_timestamp
+        return randomness
+
+    def increment_bytes(self, value: bytes) -> bytes:
+        length = len(value)
+        return (int.from_bytes(value, byteorder="big") + 1).to_bytes(length, byteorder="big")
 
 
 @functools.total_ordering
 class ULID:
+    provider = ValueProvider()
+
     """The :class:`ULID` object consists of a timestamp part of 48 bits and of 80 random bits.
 
     .. code-block:: text
@@ -82,13 +119,11 @@ class ULID:
     def __init__(self, value: bytes | None = None) -> None:
         if value is not None and len(value) != constants.BYTES_LEN:
             raise ValueError("ULID has to be exactly 16 bytes long.")
-        self.bytes: bytes = (
-            value or ULID.from_timestamp(time.time_ns() // constants.NANOSECS_IN_MILLISECS).bytes
-        )
+        self.bytes: bytes = value or ULID.from_timestamp(self.provider.timestamp()).bytes
 
     @classmethod
     @validate_type(datetime)
-    def from_datetime(cls: type[U], value: datetime) -> U:
+    def from_datetime(cls, value: datetime) -> Self:
         """Create a new :class:`ULID`-object from a :class:`datetime`. The timestamp part of the
         `ULID` will be set to the corresponding timestamp of the datetime.
 
@@ -102,7 +137,7 @@ class ULID:
 
     @classmethod
     @validate_type(int, float)
-    def from_timestamp(cls: type[U], value: int | float) -> U:
+    def from_timestamp(cls, value: float) -> Self:
         """Create a new :class:`ULID`-object from a timestamp. The timestamp can be either a
         `float` representing the time in seconds (as it would be returned by :func:`time.time()`)
         or an `int` in milliseconds.
@@ -113,15 +148,13 @@ class ULID:
             >>> ULID.from_timestamp(time.time())
             ULID(01E75QWN5HKQ0JAVX9FG1K4YP4)
         """
-        if isinstance(value, float):
-            value = int(value * constants.MILLISECS_IN_SECS)
-        timestamp = int.to_bytes(value, constants.TIMESTAMP_LEN, "big")
-        randomness = os.urandom(constants.RANDOMNESS_LEN)
+        timestamp = int.to_bytes(cls.provider.timestamp(value), constants.TIMESTAMP_LEN, "big")
+        randomness = cls.provider.randomness()
         return cls.from_bytes(timestamp + randomness)
 
     @classmethod
     @validate_type(uuid.UUID)
-    def from_uuid(cls: type[U], value: uuid.UUID) -> U:
+    def from_uuid(cls, value: uuid.UUID) -> Self:
         """Create a new :class:`ULID`-object from a :class:`uuid.UUID`. The timestamp part will be
         random in that case.
 
@@ -135,40 +168,73 @@ class ULID:
 
     @classmethod
     @validate_type(bytes)
-    def from_bytes(cls: type[U], bytes_: bytes) -> U:
+    def from_bytes(cls, bytes_: bytes) -> Self:
         """Create a new :class:`ULID`-object from sequence of 16 bytes."""
         return cls(bytes_)
 
     @classmethod
     @validate_type(str)
-    def from_hex(cls: type[U], value: str) -> U:
+    def from_hex(cls, value: str) -> Self:
         """Create a new :class:`ULID`-object from 32 character string of hex values."""
         return cls.from_bytes(bytes.fromhex(value))
 
     @classmethod
     @validate_type(str)
-    def from_str(cls: type[U], string: str) -> U:
+    def from_str(cls, string: str) -> Self:
         """Create a new :class:`ULID`-object from a 26 char long string representation."""
         return cls(base32.decode(string))
 
     @classmethod
     @validate_type(int)
-    def from_int(cls: type[U], value: int) -> U:
+    def from_int(cls, value: int) -> Self:
         """Create a new :class:`ULID`-object from an `int`."""
         return cls(int.to_bytes(value, constants.BYTES_LEN, "big"))
 
-    @property
+    @classmethod
+    def parse(cls, value: Any) -> Self:
+        """Create a new :class:`ULID`-object from a given value.
+
+        .. note::
+            This method should only be used when the caller is trying to parse a ULID from
+            a value when they're unsure what format/primitive type it will be given in.
+        """
+        if isinstance(value, ULID):
+            return cast(Self, value)
+        if isinstance(value, uuid.UUID):
+            return cls.from_uuid(value)
+        if isinstance(value, str):
+            len_value = len(value)
+            if len_value == constants.UUID_REPR_LEN:
+                return cls.from_uuid(uuid.UUID(value))
+            if len_value == constants.HEX_REPR_LEN:
+                return cls.from_hex(value)
+            if len_value == constants.REPR_LEN:
+                return cls.from_str(value)
+            raise ValueError(f"Cannot parse ULID from string of length {len_value}")
+        if isinstance(value, int):
+            if len(str(value)) == constants.INT_REPR_LEN:
+                return cls.from_int(value)
+            return cls.from_timestamp(value)
+        if isinstance(value, float):
+            return cls.from_timestamp(value)
+        if isinstance(value, datetime):
+            return cls.from_datetime(value)
+        if isinstance(value, bytes):
+            return cls.from_bytes(value)
+        raise TypeError(f"Cannot parse ULID from type {type(value)}")
+
+    @functools.cached_property
     def milliseconds(self) -> int:
         """The timestamp part as epoch time in milliseconds.
 
         Examples:
 
-            >>> ulid.timestamp
+            >>> ulid.milliseconds
             1588257207560
         """
         return int.from_bytes(self.bytes[: constants.TIMESTAMP_LEN], byteorder="big")
 
-    @property
+    @functools.cached_property
     def timestamp(self) -> float:
         """The timestamp part as epoch time in seconds.
 
@@ -179,7 +245,7 @@ class ULID:
         """
         return self.milliseconds / constants.MILLISECS_IN_SECS
 
-    @property
+    @functools.cached_property
     def datetime(self) -> datetime:
         """Return the timestamp part as timezone-aware :class:`datetime` in UTC.
 
@@ -190,7 +256,7 @@ class ULID:
         """
         return datetime.fromtimestamp(self.timestamp, timezone.utc)
 
-    @property
+    @functools.cached_property
     def hex(self) -> str:
         """Encode the :class:`ULID`-object as a 32 char sequence of hex values."""
         return self.bytes.hex()
@@ -233,22 +299,22 @@ class ULID:
     def __lt__(self, other: Any) -> bool:
         if isinstance(other, ULID):
             return self.bytes < other.bytes
-        elif isinstance(other, int):
+        if isinstance(other, int):
             return int(self) < other
-        elif isinstance(other, bytes):
+        if isinstance(other, bytes):
             return self.bytes < other
-        elif isinstance(other, str):
+        if isinstance(other, str):
             return str(self) < other
         return NotImplemented
 
-    def __eq__(self, other: Any) -> bool:
+    def __eq__(self, other: object) -> bool:
         if isinstance(other, ULID):
             return self.bytes == other.bytes
-        elif isinstance(other, int):
+        if isinstance(other, int):
             return int(self) == other
-        elif isinstance(other, bytes):
+        if isinstance(other, bytes):
             return self.bytes == other
-        elif isinstance(other, str):
+        if isinstance(other, str):
             return str(self) == other
         return NotImplemented
 
@@ -261,14 +327,16 @@ class ULID:
 
         return core_schema.no_info_wrap_validator_function(
             cls._pydantic_validate,
-            core_schema.union_schema(
-                [
-                    core_schema.is_instance_schema(ULID),
-                    core_schema.no_info_plain_validator_function(ULID),
-                    core_schema.str_schema(pattern=r"[A-Z0-9]{26}", min_length=26, max_length=26),
-                    core_schema.bytes_schema(min_length=16, max_length=16),
-                ]
-            ),
+            core_schema.union_schema([
+                core_schema.is_instance_schema(ULID),
+                core_schema.no_info_plain_validator_function(ULID),
+                core_schema.str_schema(
+                    pattern=rf"[0-7][{base32.ENCODE}]{{25}}",
+                    min_length=26,
+                    max_length=26,
+                ),
+                core_schema.bytes_schema(min_length=16, max_length=16),
+            ]),
             serialization=core_schema.to_string_ser_schema(
                 when_used="json-unless-none",
             ),
@@ -278,6 +346,7 @@ class ULID:
     def _pydantic_validate(cls, value: Any, handler: ValidatorFunctionWrapHandler) -> Any:
         from pydantic_core import PydanticCustomError
 
+        ulid: ULID
         try:
             if isinstance(value, int):
                 ulid = cls.from_int(value)

ulid/__main__.py

@@ -4,17 +4,21 @@ import argparse
 import shutil
 import sys
 import textwrap
-from collections.abc import Callable
-from collections.abc import Sequence
 from datetime import datetime
 from functools import partial
 from typing import Any
+from typing import TYPE_CHECKING
 from uuid import UUID
 
 import ulid
 from ulid import ULID
 
 
+if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import Callable
+    from collections.abc import Sequence
+
+
 def make_parser(prog: str | None = None) -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog=prog,
@@ -135,30 +139,30 @@ def show(args: argparse.Namespace) -> str:
     ulid: ULID = ULID.from_str(from_value_or_stdin(args.ulid))
     if args.uuid:
         return str(ulid.to_uuid())
-    elif args.uuid4:
+    if args.uuid4:
         return str(ulid.to_uuid4())
-    elif args.hex:
+    if args.hex:
         return ulid.hex
-    elif args.int:
+    if args.int:
         return str(int(ulid))
-    elif args.timestamp:
+    if args.timestamp:
         return str(ulid.timestamp)
-    elif args.datetime:
+    if args.datetime:
         return ulid.datetime.isoformat()
-    else:
-        return textwrap.dedent(
-            f"""
-            ULID:      {ulid!s}
-            Hex:       {ulid.hex}
-            Int:       {int(ulid)}
-            Timestamp: {ulid.timestamp}
-            Datetime:  {ulid.datetime.isoformat()}
-            """
-        ).strip()
+    return textwrap.dedent(
+        f"""
+        ULID:      {ulid!s}
+        Hex:       {ulid.hex}
+        Int:       {int(ulid)}
+        Timestamp: {ulid.timestamp}
+        Datetime:  {ulid.datetime.isoformat()}
+        """
+    ).strip()
 
 
 def entrypoint() -> None:  # pragma: no cover
-    print(main(sys.argv[1:]))
+    if (value := main(sys.argv[1:])) is not None:
+        print(value)  # noqa: T201
 
 
 if __name__ == "__main__":  # pragma: no cover

ulid/base32.py

@@ -153,46 +153,42 @@ def encode_timestamp(binary: bytes) -> str:
     if len(binary) != constants.TIMESTAMP_LEN:
         raise ValueError("Timestamp value has to be exactly 6 bytes long.")
     lut = ENCODE
-    return "".join(
-        [
-            lut[(binary[0] & 224) >> 5],
-            lut[(binary[0] & 31)],
-            lut[(binary[1] & 248) >> 3],
-            lut[((binary[1] & 7) << 2) | ((binary[2] & 192) >> 6)],
-            lut[((binary[2] & 62) >> 1)],
-            lut[((binary[2] & 1) << 4) | ((binary[3] & 240) >> 4)],
-            lut[((binary[3] & 15) << 1) | ((binary[4] & 128) >> 7)],
-            lut[(binary[4] & 124) >> 2],
-            lut[((binary[4] & 3) << 3) | ((binary[5] & 224) >> 5)],
-            lut[(binary[5] & 31)],
-        ]
-    )
+    return "".join([
+        lut[(binary[0] & 224) >> 5],
+        lut[(binary[0] & 31)],
+        lut[(binary[1] & 248) >> 3],
+        lut[((binary[1] & 7) << 2) | ((binary[2] & 192) >> 6)],
+        lut[((binary[2] & 62) >> 1)],
+        lut[((binary[2] & 1) << 4) | ((binary[3] & 240) >> 4)],
+        lut[((binary[3] & 15) << 1) | ((binary[4] & 128) >> 7)],
+        lut[(binary[4] & 124) >> 2],
+        lut[((binary[4] & 3) << 3) | ((binary[5] & 224) >> 5)],
+        lut[(binary[5] & 31)],
+    ])
 
 
 def encode_randomness(binary: bytes) -> str:
     if len(binary) != constants.RANDOMNESS_LEN:
         raise ValueError("Randomness value has to be exactly 10 bytes long.")
     lut = ENCODE
-    return "".join(
-        [
-            lut[(binary[0] & 248) >> 3],
-            lut[((binary[0] & 7) << 2) | ((binary[1] & 192) >> 6)],
-            lut[(binary[1] & 62) >> 1],
-            lut[((binary[1] & 1) << 4) | ((binary[2] & 240) >> 4)],
-            lut[((binary[2] & 15) << 1) | ((binary[3] & 128) >> 7)],
-            lut[(binary[3] & 124) >> 2],
-            lut[((binary[3] & 3) << 3) | ((binary[4] & 224) >> 5)],
-            lut[(binary[4] & 31)],
-            lut[(binary[5] & 248) >> 3],
-            lut[((binary[5] & 7) << 2) | ((binary[6] & 192) >> 6)],
-            lut[(binary[6] & 62) >> 1],
-            lut[((binary[6] & 1) << 4) | ((binary[7] & 240) >> 4)],
-            lut[((binary[7] & 15) << 1) | ((binary[8] & 128) >> 7)],
-            lut[(binary[8] & 124) >> 2],
-            lut[((binary[8] & 3) << 3) | ((binary[9] & 224) >> 5)],
-            lut[(binary[9] & 31)],
-        ]
-    )
+    return "".join([
+        lut[(binary[0] & 248) >> 3],
+        lut[((binary[0] & 7) << 2) | ((binary[1] & 192) >> 6)],
+        lut[(binary[1] & 62) >> 1],
+        lut[((binary[1] & 1) << 4) | ((binary[2] & 240) >> 4)],
+        lut[((binary[2] & 15) << 1) | ((binary[3] & 128) >> 7)],
+        lut[(binary[3] & 124) >> 2],
+        lut[((binary[3] & 3) << 3) | ((binary[4] & 224) >> 5)],
+        lut[(binary[4] & 31)],
+        lut[(binary[5] & 248) >> 3],
+        lut[((binary[5] & 7) << 2) | ((binary[6] & 192) >> 6)],
+        lut[(binary[6] & 62) >> 1],
+        lut[((binary[6] & 1) << 4) | ((binary[7] & 240) >> 4)],
+        lut[((binary[7] & 15) << 1) | ((binary[8] & 128) >> 7)],
+        lut[(binary[8] & 124) >> 2],
+        lut[((binary[8] & 3) << 3) | ((binary[9] & 224) >> 5)],
+        lut[(binary[9] & 31)],
+    ])
 
 
 def decode(encoded: str) -> bytes:
@@ -211,18 +207,16 @@ def decode_timestamp(encoded: str) -> bytes:
     lut = DECODE
     values: bytes = bytes(encoded, "ascii")
     # https://github.com/ulid/spec?tab=readme-ov-file#overflow-errors-when-parsing-base32-strings
-    if lut[values[0]] > 7:
+    if lut[values[0]] > 7:  # noqa: PLR2004
         raise ValueError(f"Timestamp value {encoded} is too large and will overflow 128-bits.")
-    return bytes(
-        [
-            ((lut[values[0]] << 5) | lut[values[1]]) & 0xFF,
-            ((lut[values[2]] << 3) | (lut[values[3]] >> 2)) & 0xFF,
-            ((lut[values[3]] << 6) | (lut[values[4]] << 1) | (lut[values[5]] >> 4)) & 0xFF,
-            ((lut[values[5]] << 4) | (lut[values[6]] >> 1)) & 0xFF,
-            ((lut[values[6]] << 7) | (lut[values[7]] << 2) | (lut[values[8]] >> 3)) & 0xFF,
-            ((lut[values[8]] << 5) | (lut[values[9]])) & 0xFF,
-        ]
-    )
+    return bytes([
+        ((lut[values[0]] << 5) | lut[values[1]]) & 0xFF,
+        ((lut[values[2]] << 3) | (lut[values[3]] >> 2)) & 0xFF,
+        ((lut[values[3]] << 6) | (lut[values[4]] << 1) | (lut[values[5]] >> 4)) & 0xFF,
+        ((lut[values[5]] << 4) | (lut[values[6]] >> 1)) & 0xFF,
+        ((lut[values[6]] << 7) | (lut[values[7]] << 2) | (lut[values[8]] >> 3)) & 0xFF,
+        ((lut[values[8]] << 5) | (lut[values[9]])) & 0xFF,
+    ])
 
 
 def decode_randomness(encoded: str) -> bytes:
@@ -230,17 +224,15 @@ def decode_randomness(encoded: str) -> bytes:
         raise ValueError("ULID randomness has to be exactly 16 characters long.")
     lut = DECODE
     values = bytes(encoded, "ascii")
-    return bytes(
-        [
-            ((lut[values[0]] << 3) | (lut[values[1]] >> 2)) & 0xFF,
-            ((lut[values[1]] << 6) | (lut[values[2]] << 1) | (lut[values[3]] >> 4)) & 0xFF,
-            ((lut[values[3]] << 4) | (lut[values[4]] >> 1)) & 0xFF,
-            ((lut[values[4]] << 7) | (lut[values[5]] << 2) | (lut[values[6]] >> 3)) & 0xFF,
-            ((lut[values[6]] << 5) | (lut[values[7]])) & 0xFF,
-            ((lut[values[8]] << 3) | (lut[values[9]] >> 2)) & 0xFF,
-            ((lut[values[9]] << 6) | (lut[values[10]] << 1) | (lut[values[11]] >> 4)) & 0xFF,
-            ((lut[values[11]] << 4) | (lut[values[12]] >> 1)) & 0xFF,
-            ((lut[values[12]] << 7) | (lut[values[13]] << 2) | (lut[values[14]] >> 3)) & 0xFF,
-            ((lut[values[14]] << 5) | (lut[values[15]])) & 0xFF,
-        ]
-    )
+    return bytes([
+        ((lut[values[0]] << 3) | (lut[values[1]] >> 2)) & 0xFF,
+        ((lut[values[1]] << 6) | (lut[values[2]] << 1) | (lut[values[3]] >> 4)) & 0xFF,
+        ((lut[values[3]] << 4) | (lut[values[4]] >> 1)) & 0xFF,
+        ((lut[values[4]] << 7) | (lut[values[5]] << 2) | (lut[values[6]] >> 3)) & 0xFF,
+        ((lut[values[6]] << 5) | (lut[values[7]])) & 0xFF,
+        ((lut[values[8]] << 3) | (lut[values[9]] >> 2)) & 0xFF,
+        ((lut[values[9]] << 6) | (lut[values[10]] << 1) | (lut[values[11]] >> 4)) & 0xFF,
+        ((lut[values[11]] << 4) | (lut[values[12]] >> 1)) & 0xFF,
+        ((lut[values[12]] << 7) | (lut[values[13]] << 2) | (lut[values[14]] >> 3)) & 0xFF,
+        ((lut[values[14]] << 5) | (lut[values[15]])) & 0xFF,
+    ])

ulid/constants.py

@@ -1,6 +1,12 @@
 MILLISECS_IN_SECS = 1000
 NANOSECS_IN_MILLISECS = 1000000
 
+MIN_RANDOMNESS = b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+MAX_RANDOMNESS = b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
+
+MIN_TIMESTAMP = 0
+MAX_TIMESTAMP = 2**48 - 1
+
 TIMESTAMP_LEN = 6
 RANDOMNESS_LEN = 10
 BYTES_LEN = TIMESTAMP_LEN + RANDOMNESS_LEN
@@ -8,3 +14,8 @@ BYTES_LEN = TIMESTAMP_LEN + RANDOMNESS_LEN
 TIMESTAMP_REPR_LEN = 10
 RANDOMNESS_REPR_LEN = 16
 REPR_LEN = TIMESTAMP_REPR_LEN + RANDOMNESS_REPR_LEN
+
+INT_REPR_LEN = 37
+
+HEX_REPR_LEN = 32
+UUID_REPR_LEN = 36  # UUID with dash-separated segments

python_ulid-2.7.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-ulid/__init__.py,sha256=tPyxks3cQzUiqkRdLgoDuunqiz090RiFkUfCMGxw7fU,9588
-ulid/__main__.py,sha256=Cmg0NEz3GUZ2WhsZVpY3-Kq-JOkxJFaLsRNgj3Aosyw,5341
-ulid/base32.py,sha256=cMj7Ye9qRdWn3n3hwaEXGMi2OkqmleAAxE20y7qmBqI,6184
-ulid/constants.py,sha256=N_nw4W2ciXO8C1IeuO3YK3j4_x9QW-0KyvrSQUuM-G4,241
-ulid/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_ulid-2.7.0.dist-info/METADATA,sha256=zJASFWDrkYVNYfnjjA70QGCC_kyzfyufEog6Ig4emH8,5782
-python_ulid-2.7.0.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
-python_ulid-2.7.0.dist-info/entry_points.txt,sha256=9214ghzfSgS8a-TjjlWDF7bI7KSaeewOCBKn5uz7bdU,50
-python_ulid-2.7.0.dist-info/licenses/LICENSE,sha256=DiDPNhW5yUHIqaKowvX0c1c9xWiI0xW4ji8R9N2NJbw,1056
-python_ulid-2.7.0.dist-info/RECORD,,