Merge pull request #395 from python-jsonschema/rfc3339-validator

Built-in RFC3339 validator

Author: sirosen

CHANGELOG.rst

@@ -11,6 +11,9 @@ Unreleased
 .. vendor-insert-here
 
 - Update vendored schemas (2024-02-05)
+- 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/cli/main_command.py

@@ -71,7 +71,7 @@ def pretty_helptext_list(values: list[str] | tuple[str, ...]) -> str:
 
 'check-jsonschema' supports format checks with appropriate libraries installed,
 including the following formats by default:
-    date, email, ipv4, ipv6, regex, uuid
+    date, date-time, email, ipv4, ipv6, regex, uuid
 
 \b
 For the "regex" format, there are multiple modes which can be specified with

src/check_jsonschema/formats.py renamed to src/check_jsonschema/formats/__init__.py

@@ -9,6 +9,8 @@
 import jsonschema.validators
 import regress
 
+from .implementations import validate_rfc3339, validate_time
+
 # all known format strings except for a selection from draft3 which have either
 # been renamed or removed:
 # - color
@@ -101,6 +103,8 @@ def make_format_checker(
     del checker.checkers["regex"]
     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

@@ -0,0 +1,4 @@
+from .iso8601_time import validate as validate_time
+from .rfc3339 import validate as 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

@@ -0,0 +1,94 @@
+import re
+
+# this regex is based on the one from the rfc3339-validator package
+# credit to the original author
+# original license:
+#
+#    MIT License
+#
+#    Copyright (c) 2019, Nicolas Aimetti
+#
+#    Permission is hereby granted, free of charge, to any person obtaining a copy
+#    of this software and associated documentation files (the "Software"), to deal
+#    in the Software without restriction, including without limitation the rights
+#    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#    copies of the Software, and to permit persons to whom the Software is
+#    furnished to do so, subject to the following conditions:
+#
+#    The above copyright notice and this permission notice shall be included in all
+#    copies or substantial portions of the Software.
+#
+#    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+#    SOFTWARE.
+#
+# modifications have been made for additional corner cases and speed
+RFC3339_REGEX = re.compile(
+    r"""
+    ^
+    (?:\d{4})
+    -
+    (?:0[1-9]|1[0-2])
+    -
+    (?:\d{2})
+    (?:T|t)
+    (?:[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(date_str: object) -> bool:
+    """Validate a string as a RFC3339 date-time."""
+    if not isinstance(date_str, str):
+        return False
+    if not RFC3339_REGEX.match(date_str):
+        return False
+
+    year, month, day = int(date_str[:4]), int(date_str[5:7]), int(date_str[8:10])
+
+    if month in {4, 6, 9, 11}:
+        max_day = 30
+    elif month == 2:
+        max_day = 29 if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0) else 28
+    else:
+        max_day = 31
+    if not 1 <= day <= max_day:
+        return False
+    return True
+
+
+if __name__ == "__main__":
+    import timeit
+
+    N = 100_000
+    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 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")

tests/unit/formats/test_rfc3339.py

@@ -0,0 +1,99 @@
+import random
+
+import pytest
+
+from check_jsonschema.formats.implementations.rfc3339 import validate
+
+
+@pytest.mark.parametrize(
+    "datestr",
+    (
+        "2018-12-31T23:59:59Z",
+        "2018-12-31t23:59:59Z",
+        "2018-12-31t23:59:59z",
+        "2018-12-31T23:59:59+00:00",
+        "2018-12-31T23:59:59-00:00",
+    ),
+)
+def test_simple_positive_cases(datestr):
+    assert validate(datestr)
+
+
+@pytest.mark.parametrize(
+    "datestr",
+    (
+        "2018-12-31T23:59:59",
+        "2018-12-31T23:59:59+00:00Z",
+        "2018-12-31 23:59:59",
+    ),
+)
+def test_simple_negative_case(datestr):
+    assert not validate(datestr)
+
+
+@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"2018-12-31T23:59:59.{fracsec}{offsetstr}")
+
+
+@pytest.mark.parametrize(
+    "datestr",
+    (
+        # no such month
+        "2020-13-01T00:00:00Z",
+        "2020-00-01T00:00:00Z",
+        # no such day
+        "2020-01-00T00:00:00Z",
+        "2020-01-32T00:00:00Z",
+    ),
+)
+def test_basic_bounds_validated(datestr):
+    assert not validate(datestr)
+
+
+@pytest.mark.parametrize(
+    "month, maxday",
+    (
+        (1, 31),
+        (3, 31),
+        (4, 30),
+        (5, 31),
+        (6, 30),
+        (7, 31),
+        (8, 31),
+        (9, 30),
+        (10, 31),
+        (11, 30),
+    ),
+)
+def test_day_bounds_by_month(month, maxday):
+    good_date = f"2020-{month:02}-{maxday:02}T00:00:00Z"
+    bad_date = f"2020-{month:02}-{maxday+1:02}T00:00:00Z"
+    assert validate(good_date)
+    assert not validate(bad_date)
+
+
+@pytest.mark.parametrize(
+    "year, maxday",
+    (
+        (2018, 28),
+        (2016, 29),
+        (2400, 29),
+        (2500, 28),
+    ),
+)
+def test_day_bounds_for_february(year, maxday):
+    good_date = f"{year}-02-{maxday:02}T00:00:00Z"
+    bad_date = f"{year}-02-{maxday+1:02}T00:00:00Z"
+    assert validate(good_date)
+    assert not validate(bad_date)

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}")