regex format checker crashes with ValueError on conflicting inline flags #1558

Activity

1. SamyakJ05 commented on Sep 7, 2026

   

   SamyakJ05

   on Sep 7, 2026

   More actions

   I put together a fix for this (this repo restricts PRs to collaborators, so I can't open one directly — happy to if invited, otherwise a maintainer is welcome to cherry-pick this).

   Branch: https://github.com/SamyakJ05/jsonschema/tree/fix-regex-format-exception-handling

   Widens the regex checker's declared raises to cover all the non-re.error exceptions re.compile can throw, per the "worth widening what is_regex catches" note above:

   --- a/jsonschema/_format.py
   +++ b/jsonschema/_format.py
   @@ -413,7 +413,10 @@ with suppress(ImportError):
            return is_datetime("1970-01-01T" + instance)
    
    
   -@_checks_drafts(name="regex", raises=re.error)
   +@_checks_drafts(
   +    name="regex",
   +    raises=(re.error, ValueError, RecursionError, OverflowError),
   +)
    def is_regex(instance: object) -> bool:
        if not isinstance(instance, str):
            return True

   Plus a regression test class covering the reported cases (conflicting inline flags, deep nesting, oversized repeat count) and a sanity check that valid patterns still conform:

   --- a/jsonschema/tests/test_format.py
   +++ b/jsonschema/tests/test_format.py
   @@ -89,3 +89,33 @@ class TestFormatChecker(TestCase):
                repr(checker),
                "<FormatChecker checkers=['bar', 'baz', 'foo']>",
            )
   +
   +
   +class TestRegexFormat(TestCase):
   +    """
   +    ``re.compile`` can raise more than just ``re.error``; the ``regex``
   +    checker should report all of them as invalid instances rather than
   +    letting them escape as unhandled exceptions.
   +    """
   +
   +    def test_unterminated_pattern_is_invalid(self):
   +        checker = FormatChecker()
   +        self.assertFalse(checker.conforms("[unterminated", "regex"))
   +
   +    def test_conflicting_inline_flags_is_invalid(self):
   +        checker = FormatChecker()
   +        self.assertFalse(checker.conforms("(?u)(?a)", "regex"))
   +        self.assertFalse(checker.conforms("(?a)(?u)", "regex"))
   +
   +    def test_deeply_nested_pattern_is_invalid(self):
   +        checker = FormatChecker()
   +        pattern = "(" * 100000 + ")" * 100000
   +        self.assertFalse(checker.conforms(pattern, "regex"))
   +
   +    def test_oversized_repeat_count_is_invalid(self):
   +        checker = FormatChecker()
   +        self.assertFalse(checker.conforms("(a{100000000000})", "regex"))
   +
   +    def test_valid_pattern_still_conforms(self):
   +        checker = FormatChecker()
   +        self.assertTrue(checker.conforms(r"^\d+\$", "regex"))

   Full test suite passes: 8288 passed, 232 skipped.
2. Anusha0501

   added a commit that references this issue on Sep 10, 2026

   Report regex compile failures as invalid format, not crashes.

   ...

   This issue will close once commit 4792e3e is merged into the 'main' branch.

   4792e3e
3. GruffElixir commented on Sep 12, 2026

   

   GruffElixir

   on Sep 12, 2026

   More actions

   I pushed a focused fix on https://github.com/GruffElixir/jsonschema/tree/fix/regex-format-exceptions. The regex checker now treats the extra exceptions raised by re.compile as invalid patterns, with regression coverage for conflicting flags, deep nesting, oversized repeats, and a valid pattern.

   This repo currently only allows collaborators to open pull requests, so I couldn't create the upstream PR from this account. The branch is ready for a maintainer to pick up or cherry-pick.