Report regexes with oversized repeat counts as invalid, not an OverflowError

re.compile raises OverflowError (not an re.error subclass) when a
repetition count is too large, e.g. 'a{99999999999999}'. The regex
format checker declared raises=re.error only, so the exception escaped
FormatChecker.check and propagated out of iter_errors/validate instead
of reporting the string as an invalid regex (#1526).

Declare OverflowError alongside re.error so it converts to a
FormatError whose cause is the original exception.

Author: yzxcj797

jsonschema/_format.py

@@ -413,7 +413,7 @@ def is_time(instance: object) -> bool:
         return is_datetime("1970-01-01T" + instance)
 
 
-@_checks_drafts(name="regex", raises=re.error)
+@_checks_drafts(name="regex", raises=(re.error, OverflowError))
 def is_regex(instance: object) -> bool:
     if not isinstance(instance, str):
         return True

jsonschema/tests/test_format.py

@@ -6,7 +6,7 @@
 
 from jsonschema import FormatChecker, ValidationError
 from jsonschema.exceptions import FormatError
-from jsonschema.validators import Draft4Validator
+from jsonschema.validators import Draft202012Validator, Draft4Validator
 
 BOOM = ValueError("Boom!")
 BANG = ZeroDivisionError("Bang!")
@@ -71,6 +71,27 @@ def test_format_error_causes_become_validation_error_causes(self):
         self.assertIs(cm.exception.cause, BOOM)
         self.assertIs(cm.exception.__cause__, BOOM)
 
+    def test_oversized_repeat_regex_reports_invalid_not_overflow(self):
+        # re.compile raises OverflowError (not an re.error subclass) when a
+        # repetition count is too large, which must surface as a FormatError
+        # rather than escape the checker (#1526).
+        checker = FormatChecker(formats=["regex"])
+        validator = Draft202012Validator(
+            {"format": "regex"}, format_checker=checker,
+        )
+        pattern = "a{99999999999999}"
+
+        with self.assertRaises(FormatError):
+            checker.check(pattern, "regex")
+
+        self.assertFalse(checker.conforms(pattern, "regex"))
+        errors = list(validator.iter_errors(pattern))
+        self.assertEqual(len(errors), 1)
+        self.assertIsInstance(errors[0].cause, OverflowError)
+
+        # A sane bounded repeat still compiles and conforms.
+        self.assertTrue(checker.conforms("a{2,4}", "regex"))
+
     def test_format_checkers_come_with_defaults(self):
         # This is bad :/ but relied upon.
         # The docs for quite awhile recommended people do things like