Decide which keywords need processing once, rather than each validation.

On pathological examples (like the benchmark here) this avoids lots of
iterating over useless keywords.

In particular on aforementioned benchamrk, this takes us (on my laptop)
from:

    beginning of schema: Mean +- std dev: 3.91 us +- 0.03 us
    middle of schema: Mean +- std dev: 3.95 ms +- 0.04 ms
    end of schema: Mean +- std dev: 4.03 ms +- 0.24 ms
    valid: Mean +- std dev: 3.92 ms +- 0.05 ms

to:

    beginning of schema: Mean +- std dev: 3.94 us +- 0.02 us
    middle of schema: Mean +- std dev: 6.59 us +- 0.06 us
    end of schema: Mean +- std dev: 7.31 us +- 0.06 us
    valid: Mean +- std dev: 5.18 us +- 0.03 us

where clearly we now do essentially equivalent work no matter how many
useless keywords are interspersed in the schema.

Author: Julian

jsonschema/benchmarks/useless_keywords.py

@@ -0,0 +1,32 @@
+"""
+A benchmark for validation of schemas containing lots of useless keywords.
+
+Checks we filter them out once, ahead of time.
+"""
+
+from pyperf import Runner
+
+from jsonschema import Draft202012Validator
+
+NUM_USELESS = 100000
+schema = dict(
+    [
+        ("not", {"const": 42}),
+        *((str(i), i) for i in range(NUM_USELESS)),
+        ("type", "integer"),
+        *((str(i), i) for i in range(NUM_USELESS, NUM_USELESS)),
+        ("minimum", 37),
+    ],
+)
+validator = Draft202012Validator(schema)
+
+valid = 3737
+invalid = 12
+
+
+if __name__ == "__main__":
+    runner = Runner()
+    runner.bench_func("beginning of schema", lambda: validator.is_valid(42))
+    runner.bench_func("middle of schema", lambda: validator.is_valid("foo"))
+    runner.bench_func("end of schema", lambda: validator.is_valid(12))
+    runner.bench_func("valid", lambda: validator.is_valid(3737))

jsonschema/validators.py

@@ -230,6 +230,7 @@ class Validator:
         ID_OF = staticmethod(id_of)
 
         _APPLICABLE_VALIDATORS = applicable_validators
+        _validators = field(init=False, repr=False, eq=False)
 
         schema: referencing.jsonschema.Schema = field(repr=reprlib.repr)
         _ref_resolver = field(default=None, repr=False, alias="resolver")
@@ -287,6 +288,15 @@ def __attrs_post_init__(self):
                 resource = specification.create_resource(self.schema)
                 self._resolver = registry.resolver_with_root(resource)
 
+            if self.schema is True or self.schema is False:
+                self._validators = []
+            else:
+                self._validators = [
+                    (self.VALIDATORS[k], k, v)
+                    for k, v in applicable_validators(self.schema)
+                    if k in self.VALIDATORS
+                ]
+
             # REMOVEME: Legacy ref resolution state management.
             push_scope = getattr(self._ref_resolver, "push_scope", None)
             if push_scope is not None:
@@ -349,8 +359,13 @@ def iter_errors(self, instance, _schema=None):
                     DeprecationWarning,
                     stacklevel=2,
                 )
+                validators = [
+                    (self.VALIDATORS[k], k, v)
+                    for k, v in applicable_validators(_schema)
+                    if k in self.VALIDATORS
+                ]
             else:
-                _schema = self.schema
+                _schema, validators = self.schema, self._validators
 
             if _schema is True:
                 return
@@ -364,11 +379,7 @@ def iter_errors(self, instance, _schema=None):
                 )
                 return
 
-            for k, v in applicable_validators(_schema):
-                validator = self.VALIDATORS.get(k)
-                if validator is None:
-                    continue
-
+            for validator, k, v in validators:
                 errors = validator(self, v, instance, _schema) or ()
                 for error in errors:
                     # set details if not already set by the called fn