reimplement datetime parsing logic

Signed-off-by: Kunz, Immanuel <immanuel.kunz@aisec.fraunhofer.de>

Author: immqu

src/univers/datetime.py

@@ -4,9 +4,7 @@
 # Visit https://aboutcode.org and https://github.com/aboutcode-org/univers for support and download.
 
 import re
-from datetime import datetime
-from datetime import timezone
-
+from datetime import datetime, timedelta, timezone
 
 class DatetimeVersion:
     """
@@ -18,18 +16,73 @@ class DatetimeVersion:
     VERSION_PATTERN = re.compile(
         r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$"
     )
+    _TIME_TZ_RE = re.compile(
+        r"^(?P<h>\d{2}):(?P<M>\d{2}):(?P<s>\d{2})(?:\.(?P<f>\d+))?(?P<tz>Z|[+-]\d{2}:\d{2})$"
+    )
 
     def __init__(self, version):
         version = str(version).strip()
         if not self.is_valid(version):
             raise InvalidVersionError(version)
 
-        # fromisoformat doesn't accept the "Z" suffix prior to 3.11, so we normalize it:
+        # save the original
+        self.original = version
+
+        # normalize Z to +00:00 to make tz parsing uniform
         if version.endswith("Z"):
             version = version[:-1] + "+00:00"
 
-        self.original = version
-        self.parsed_stamp = datetime.fromisoformat(version).astimezone(timezone.utc)
+        # split into date and time+tz parts
+        date_part, time_tz_part = version.split("T", 1)
+
+        # parse the date-only portion first using fromisoformat
+        # (datetime.fromisoformat accepts date-only strings)
+        try:
+            dt = datetime.fromisoformat(date_part)
+        except ValueError:
+            raise InvalidVersionError(version)
+
+        # parse time and timezone with regex
+        m = self._TIME_TZ_RE.fullmatch(time_tz_part)
+        if not m:
+            raise InvalidVersionError(version)
+
+        hour = int(m.group("h"))
+        minute = int(m.group("M"))
+        second = int(m.group("s"))
+        frac = m.group("f") or ""
+        # ensure microseconds length is exactly 6 (truncate or pad), because datetime requires that
+        if frac:
+            micro = int((frac[:6]).ljust(6, "0"))
+        else:
+            micro = 0
+
+        tz_text = m.group("tz")
+        if tz_text == "Z":
+            tzinfo = timezone.utc
+        else:
+            # tz_text is in form +HH:MM or -HH:MM
+            sign = 1 if tz_text[0] == "+" else -1
+            tzh = int(tz_text[1:3])
+            tzm = int(tz_text[4:6])
+            offset = sign * (tzh * 3600 + tzm * 60)
+            tzinfo = timezone(timedelta(seconds=offset))
+
+        # construct aware datetime for the exact instant
+        dt = datetime(
+            year=dt.year,
+            month=dt.month,
+            day=dt.day,
+            hour=hour,
+            minute=minute,
+            second=second,
+            microsecond=micro,
+            tzinfo=tzinfo,
+        )
+
+        # canonicalize to UTC for comparisons/hashing
+        self.parsed_stamp = dt.astimezone(timezone.utc)
+
 
     def __eq__(self, other):
         return self.parsed_stamp == other.parsed_stamp

tests/test_version_range.py

@@ -371,6 +371,9 @@ def test_version_range_intdot():
 
 
 def test_version_range_datetime():
+    assert DatetimeVersion("2021-05-05T01:02:03.1234+00:00") == DatetimeVersion(
+        "2021-05-05T01:02:03.1234+00:00"
+    )
     assert DatetimeVersion("2021-05-05T01:02:03.1234Z") == DatetimeVersion(
         "2021-05-05T01:02:03.1234Z"
     )

tests/test_versions.py

@@ -240,3 +240,5 @@ def test_datetime_version():
     assert DatetimeVersion("2022-10-28T18:30:00Z") <= DatetimeVersion("2023-10-28T18:30:00Z")
     assert DatetimeVersion("2024-10-28T18:30:00Z") > DatetimeVersion("2023-10-28T18:30:00Z")
     assert DatetimeVersion("2023-10-28T19:30:00+01:00") == DatetimeVersion("2023-10-28T18:30:00Z")
+    assert not DatetimeVersion.is_valid("2023-10-28Z19:30:00+01:00")
+    assert not DatetimeVersion.is_valid("10-10-2023T19:30:00+01:00")