Add builtin 'time' format validation

This is similar to the `date-time` case, and is tested in a similar
manner.

Author: sirosen

CHANGELOG.rst

@@ -11,9 +11,9 @@ Unreleased
 .. vendor-insert-here
 
 - Update vendored schemas (2024-02-05)
-- Include a built-in, efficient implementation of `date-time` format validation
-  (RFC 3339). This makes the `date-time` format always available for
-  validation. (:issue:`378`)
+- Include built-in, efficient implementations of `date-time` format validation
+  (RFC 3339) and `time` format validation (ISO 8601). This makes the `date-time`
+  and `time` formats always available for validation. (:issue:`378`)
 - Support the use of `orjson` for faster JSON parsing when it is installed.
   This makes it an optional parser which is preferred over the default
   `json` module when it is available.

src/check_jsonschema/formats/__init__.py

@@ -9,7 +9,7 @@
 import jsonschema.validators
 import regress
 
-from .implementations import validate_rfc3339
+from .implementations import validate_rfc3339, validate_time
 
 # all known format strings except for a selection from draft3 which have either
 # been renamed or removed:
@@ -104,6 +104,7 @@ def make_format_checker(
     regex_impl = RegexImplementation(opts.regex_variant)
     checker.checks("regex")(regex_impl.check_format)
     checker.checks("date-time")(validate_rfc3339)
+    checker.checks("time")(validate_time)
 
     # remove the disabled checks, which may include the regex check
     for checkname in opts.disabled_formats:

src/check_jsonschema/formats/implementations/__init__.py

@@ -1,3 +1,4 @@
+from .iso8601_time import validate as validate_time
 from .rfc3339 import validate as validate_rfc3339
 
-__all__ = ("validate_rfc3339",)
+__all__ = ("validate_rfc3339", "validate_time")

src/check_jsonschema/formats/implementations/iso8601_time.py

@@ -0,0 +1,45 @@
+import re
+
+TIME_REGEX = re.compile(
+    r"""
+    ^
+    (?:[01]\d|2[0123])
+    :
+    (?:[0-5]\d)
+    :
+    (?:[0-5]\d)
+    # (optional) fractional seconds
+    (?:(\.|,)\d+)?
+    # UTC or offset
+    (?:
+        Z
+        | z
+        | [+-](?:[01]\d|2[0123]):[0-5]\d
+    )
+    $
+""",
+    re.VERBOSE | re.ASCII,
+)
+
+
+def validate(time_str: object) -> bool:
+    if not isinstance(time_str, str):
+        return False
+    return bool(TIME_REGEX.match(time_str))
+
+
+if __name__ == "__main__":
+    import timeit
+
+    N = 100_000
+    tests = (
+        ("basic", "23:59:59Z"),
+        ("long_fracsec", "23:59:59.8446519776713Z"),
+    )
+
+    print("benchmarking")
+    for name, val in tests:
+        all_times = timeit.repeat(
+            f"validate({val!r})", globals=globals(), repeat=3, number=N
+        )
+        print(f"{name} (valid={validate(val)}): {int(min(all_times) / N * 10**9)}ns")

src/check_jsonschema/formats/implementations/rfc3339.py

@@ -1,5 +1,4 @@
 import re
-import typing as t
 
 # this regex is based on the one from the rfc3339-validator package
 # credit to the original author
@@ -56,7 +55,7 @@
 )
 
 
-def validate(date_str: t.Any) -> bool:
+def validate(date_str: object) -> bool:
     """Validate a string as a RFC3339 date-time."""
     if not isinstance(date_str, str):
         return False
@@ -80,18 +79,15 @@ def validate(date_str: t.Any) -> bool:
     import timeit
 
     N = 100_000
-    long_fracsec = "2018-12-31T23:59:59.8446519776713Z"
-    basic = "2018-12-31T23:59:59Z"
-    in_february = "2018-02-12T23:59:59Z"
-    in_february_invalid = "2018-02-29T23:59:59Z"
+    tests = (
+        ("long_fracsec", "2018-12-31T23:59:59.8446519776713Z"),
+        ("basic", "2018-12-31T23:59:59Z"),
+        ("in_february", "2018-02-12T23:59:59Z"),
+        ("in_february_invalid", "2018-02-29T23:59:59Z"),
+    )
 
     print("benchmarking")
-    for name, val in (
-        ("long_fracsec", long_fracsec),
-        ("basic", basic),
-        ("february", in_february),
-        ("february_invalid", in_february_invalid),
-    ):
+    for name, val in tests:
         all_times = timeit.repeat(
             f"validate({val!r})", globals=globals(), repeat=3, number=N
         )

tests/unit/formats/test_time.py

@@ -0,0 +1,47 @@
+import random
+
+import pytest
+
+from check_jsonschema.formats.implementations.iso8601_time import validate
+
+
+@pytest.mark.parametrize(
+    "timestr",
+    (
+        "12:34:56Z",
+        "23:59:59z",
+        "23:59:59+00:00",
+        "01:59:59-00:00",
+    ),
+)
+def test_simple_positive_cases(timestr):
+    assert validate(timestr)
+
+
+@pytest.mark.parametrize(
+    "timestr",
+    (
+        "12:34:56",
+        "23:59:60Z",
+        "23:59:59+24:00",
+        "01:59:59-00:60",
+        "01:01:00:00:60",
+    ),
+)
+def test_simple_negative_cases(timestr):
+    assert not validate(timestr)
+
+
+@pytest.mark.parametrize("precision", list(range(20)))
+@pytest.mark.parametrize(
+    "offsetstr",
+    (
+        "Z",
+        "+00:00",
+        "-00:00",
+        "+23:59",
+    ),
+)
+def test_allows_fracsec(precision, offsetstr):
+    fracsec = random.randint(0, 10**precision)
+    assert validate(f"23:59:59.{fracsec}{offsetstr}")