python-ulid 4.0.0__tar.gz → 4.0.1__tar.gz

{python_ulid-4.0.0 → python_ulid-4.0.1}/CHANGELOG.rst

@@ -5,6 +5,13 @@ Changelog
 
 Versions follow `Semantic Versioning <http://www.semver.org>`_
 
+`4.0.1`_ - 2026-07-20
+---------------------
+Changed
+~~~~~~~
+* Renamed ``ULID.from_uuidv7`` to :meth:`.ULID.from_uuid7` for naming symmetry with
+  :meth:`.ULID.to_uuid7`, correcting an inconsistency introduced in 3.2.0.
+
 `4.0.0`_ - 2026-07-20
 ---------------------
 
@@ -258,6 +265,7 @@ Changed
 * The package now has no external dependencies.
 * The test-coverage has been raised to 100%.
 
+.. _4.0.1: https://github.com/mdomke/python-ulid/compare/4.0.0...4.0.1
 .. _4.0.0: https://github.com/mdomke/python-ulid/compare/3.2.1...4.0.0
 .. _3.2.1: https://github.com/mdomke/python-ulid/compare/3.2.0...3.2.1
 .. _3.2.0: https://github.com/mdomke/python-ulid/compare/3.1.0...3.2.0

{python_ulid-4.0.0 → python_ulid-4.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-ulid
-Version: 4.0.0
+Version: 4.0.1
 Summary: Universally unique lexicographically sortable identifier
 Project-URL: Homepage, https://github.com/mdomke/python-ulid
 Project-URL: Documentation, https://python-ulid.readthedocs.io

{python_ulid-4.0.0 → python_ulid-4.0.1}/tests/test_ulid.py

@@ -161,7 +161,7 @@ def test_idempotency() -> None:
     assert ULID.from_bytes(ulid.bytes) == ulid
     assert ULID.from_str(str(ulid)) == ulid
     assert ULID.from_uuid(ulid.to_uuid()) == ulid
-    assert ULID.from_uuidv7(ulid.to_uuid7(compliant=False)) == ulid
+    assert ULID.from_uuid7(ulid.to_uuid7(compliant=False)) == ulid
     assert ULID.from_int(int(ulid)) == ulid
     assert ULID.from_hex(ulid.hex) == ulid
     assert ULID.parse(ulid) == ulid
@@ -209,7 +209,7 @@ def test_uuid7_perfect_roundtrip() -> None:
     """Test perfect round-trip conversion with compliant=False."""
     ulid = ULID()
     uuid7 = ulid.to_uuid7(compliant=False)
-    ulid_restored = ULID.from_uuidv7(uuid7)
+    ulid_restored = ULID.from_uuid7(uuid7)
     # Perfect round-trip: all 128 bits should be identical
     assert ulid_restored == ulid
     assert ulid_restored.bytes == ulid.bytes
@@ -220,7 +220,7 @@ def test_uuid7_compliant_roundtrip() -> None:
     """Test round-trip with compliant=True preserves timestamp but loses some randomness."""
     ulid = ULID()
     uuid7 = ulid.to_uuid7(compliant=True)
-    ulid_restored = ULID.from_uuidv7(uuid7)
+    ulid_restored = ULID.from_uuid7(uuid7)
     # Timestamp should be perfectly preserved
     assert ulid_restored.milliseconds == ulid.milliseconds
     # Full ULID won't match due to lost randomness in version/variant bits (6 bits lost)
@@ -236,7 +236,7 @@ def test_uuid7_timestamp_preservation() -> None:
     # Test both compliant and non-compliant modes
     for compliant in [False, True]:
         uuid7 = ulid.to_uuid7(compliant=compliant)
-        ulid_from_uuid7 = ULID.from_uuidv7(uuid7)
+        ulid_from_uuid7 = ULID.from_uuid7(uuid7)
 
         # Check timestamp is perfectly preserved (exact millisecond match)
         assert ulid_from_uuid7.milliseconds == ulid.milliseconds
@@ -271,7 +271,7 @@ def test_uuid7_same_millisecond() -> None:
 
     # Perfect round-trip for all
     for ulid, uuid7 in zip(ulids, uuids, strict=True):
-        assert ULID.from_uuidv7(uuid7) == ulid
+        assert ULID.from_uuid7(uuid7) == ulid
 
 
 def test_from_uuid7_with_external_uuid() -> None:
@@ -289,7 +289,7 @@ def test_from_uuid7_with_external_uuid() -> None:
     uuid_int = (timestamp_ms << 80) | (0x7 << 76) | (rand_a << 64) | (0x2 << 62) | rand_b
     uuid7 = uuid.UUID(bytes=uuid_int.to_bytes(16, byteorder="big"))
 
-    ulid = ULID.from_uuidv7(uuid7)
+    ulid = ULID.from_uuid7(uuid7)
 
     # Check timestamp is correctly extracted (should be exact since it's in milliseconds)
     assert ulid.milliseconds == timestamp_ms

{python_ulid-4.0.0 → python_ulid-4.0.1}/ulid/__init__.py

@@ -456,9 +456,9 @@ class ULID:
         Examples:
 
             >>> ulid = ULID()
-            >>> uuid7 = ulid.to_uuidv7()  # Perfect round-trip
-            >>> assert ULID.from_uuidv7(uuid7) == ulid
-            >>> uuid7_compliant = ulid.to_uuidv7(compliant=True)  # RFC 4122 compliant
+            >>> uuid7 = ulid.to_uuid7()  # Perfect round-trip
+            >>> assert ULID.from_uuid7(uuid7) == ulid
+            >>> uuid7_compliant = ulid.to_uuid7(compliant=True)  # RFC 4122 compliant
             >>> uuid7_compliant.version
             7
         """
@@ -487,17 +487,17 @@ class ULID:
         return uuid.UUID(bytes=uuid_bytes)
 
     @classmethod
-    def from_uuidv7(cls, value: uuid.UUID) -> Self:
+    def from_uuid7(cls, value: uuid.UUID) -> Self:
         """Create a new :class:`ULID` from a UUIDv7 (:class:`uuid.UUID` version 7).
 
         Extracts the timestamp from the UUIDv7's first 48 bits (milliseconds since epoch)
         and the remaining 80 bits as randomness. The timestamp is always transparently
-        preserved, providing perfect round-trip conversion with :meth:`to_uuidv7`.
+        preserved, providing perfect round-trip conversion with :meth:`to_uuid7`.
 
         Examples:
 
             >>> uuid7 = uuid.UUID("01936c5e-f4c0-7000-8000-000000000000")
-            >>> ulid = ULID.from_uuidv7(uuid7)
+            >>> ulid = ULID.from_uuid7(uuid7)
             >>> ulid.datetime
             datetime.datetime(2025, 11, 10, ...)
         """