Python 3.10+ modernization

Author: p1c2u

.pre-commit-config.yaml

@@ -1,5 +1,5 @@
 ---
-default_stages: [commit, push]
+default_stages: [pre-commit, pre-push]
 default_language_version:
   # force all unspecified python hooks to run python3
   python: python3

openapi_schema_validator/_format.py

@@ -2,13 +2,11 @@
 from base64 import b64decode
 from base64 import b64encode
 from numbers import Number
-from typing import Any
-from typing import Union
 
 from jsonschema._format import FormatChecker
 
 
-def is_int32(instance: Any) -> bool:
+def is_int32(instance: object) -> bool:
     # bool inherits from int, so ensure bools aren't reported as ints
     if isinstance(instance, bool):
         return True
@@ -17,7 +15,7 @@ def is_int32(instance: Any) -> bool:
     return ~(1 << 31) < instance < 1 << 31
 
 
-def is_int64(instance: Any) -> bool:
+def is_int64(instance: object) -> bool:
     # bool inherits from int, so ensure bools aren't reported as ints
     if isinstance(instance, bool):
         return True
@@ -26,7 +24,7 @@ def is_int64(instance: Any) -> bool:
     return ~(1 << 63) < instance < 1 << 63
 
 
-def is_float(instance: Any) -> bool:
+def is_float(instance: object) -> bool:
     # bool inherits from int
     if isinstance(instance, int):
         return True
@@ -35,7 +33,7 @@ def is_float(instance: Any) -> bool:
     return isinstance(instance, float)
 
 
-def is_double(instance: Any) -> bool:
+def is_double(instance: object) -> bool:
     # bool inherits from int
     if isinstance(instance, int):
         return True
@@ -46,15 +44,15 @@ def is_double(instance: Any) -> bool:
     return isinstance(instance, float)
 
 
-def is_binary(instance: Any) -> bool:
+def is_binary(instance: object) -> bool:
     if not isinstance(instance, (str, bytes)):
         return True
     if isinstance(instance, str):
         return False
     return True
 
 
-def is_byte(instance: Union[str, bytes]) -> bool:
+def is_byte(instance: object) -> bool:
     if not isinstance(instance, (str, bytes)):
         return True
     if isinstance(instance, str):
@@ -64,7 +62,7 @@ def is_byte(instance: Union[str, bytes]) -> bool:
     return encoded == instance
 
 
-def is_password(instance: Any) -> bool:
+def is_password(instance: object) -> bool:
     # A hint to UIs to obscure input
     return True
 

openapi_schema_validator/_keywords.py

@@ -1,12 +1,7 @@
-from copy import deepcopy
 from typing import Any
-from typing import Dict
-from typing import Hashable
-from typing import ItemsView
 from typing import Iterator
-from typing import List
 from typing import Mapping
-from typing import Union
+from typing import cast
 
 from jsonschema._keywords import allOf as _allOf
 from jsonschema._keywords import anyOf as _anyOf
@@ -15,11 +10,10 @@
 from jsonschema._utils import find_additional_properties
 from jsonschema.exceptions import FormatError
 from jsonschema.exceptions import ValidationError
-from jsonschema.protocols import Validator
 
 
 def handle_discriminator(
-    validator: Validator, _: Any, instance: Any, schema: Mapping[Hashable, Any]
+    validator: Any, _: Any, instance: Any, schema: Mapping[str, Any]
 ) -> Iterator[ValidationError]:
     """
     Handle presence of discriminator in anyOf, oneOf and allOf.
@@ -45,16 +39,14 @@ def handle_discriminator(
     if not isinstance(ref, str):
         # this is a schema error
         yield ValidationError(
-            "{!r} mapped value for {!r} should be a string, was {!r}".format(
-                instance, prop_value, ref
-            ),
+            f"{instance!r} mapped value for {prop_value!r} should be a string, was {ref!r}",
             context=[],
         )
         return
 
     try:
         validator._validate_reference(ref=ref, instance=instance)
-    except:
+    except Exception:
         yield ValidationError(
             f"{instance!r} reference {ref!r} could not be resolved",
             context=[],
@@ -65,54 +57,63 @@ def handle_discriminator(
 
 
 def anyOf(
-    validator: Validator,
-    anyOf: List[Mapping[Hashable, Any]],
+    validator: Any,
+    anyOf: list[Mapping[str, Any]],
     instance: Any,
-    schema: Mapping[Hashable, Any],
+    schema: Mapping[str, Any],
 ) -> Iterator[ValidationError]:
     if "discriminator" not in schema:
-        yield from _anyOf(validator, anyOf, instance, schema)
+        yield from cast(
+            Iterator[ValidationError],
+            _anyOf(validator, anyOf, instance, schema),
+        )
     else:
         yield from handle_discriminator(validator, anyOf, instance, schema)
 
 
 def oneOf(
-    validator: Validator,
-    oneOf: List[Mapping[Hashable, Any]],
+    validator: Any,
+    oneOf: list[Mapping[str, Any]],
     instance: Any,
-    schema: Mapping[Hashable, Any],
+    schema: Mapping[str, Any],
 ) -> Iterator[ValidationError]:
     if "discriminator" not in schema:
-        yield from _oneOf(validator, oneOf, instance, schema)
+        yield from cast(
+            Iterator[ValidationError],
+            _oneOf(validator, oneOf, instance, schema),
+        )
     else:
         yield from handle_discriminator(validator, oneOf, instance, schema)
 
 
 def allOf(
-    validator: Validator,
-    allOf: List[Mapping[Hashable, Any]],
+    validator: Any,
+    allOf: list[Mapping[str, Any]],
     instance: Any,
-    schema: Mapping[Hashable, Any],
+    schema: Mapping[str, Any],
 ) -> Iterator[ValidationError]:
     if "discriminator" not in schema:
-        yield from _allOf(validator, allOf, instance, schema)
+        yield from cast(
+            Iterator[ValidationError],
+            _allOf(validator, allOf, instance, schema),
+        )
     else:
         yield from handle_discriminator(validator, allOf, instance, schema)
 
 
 def type(
-    validator: Validator,
+    validator: Any,
     data_type: str,
     instance: Any,
-    schema: Mapping[Hashable, Any],
+    schema: Mapping[str, Any],
 ) -> Iterator[ValidationError]:
     if instance is None:
         # nullable implementation based on OAS 3.0.3
         # * nullable is only meaningful if its value is true
         # * nullable: true is only meaningful in combination with a type
         #   assertion specified in the same Schema Object.
         # * nullable: true operates within a single Schema Object
-        if "nullable" in schema and schema["nullable"] == True:
+        if schema.get("nullable") is True:
             return
         yield ValidationError("None for not nullable")
 
@@ -122,10 +123,10 @@ def type(
 
 
 def format(
-    validator: Validator,
+    validator: Any,
     format: str,
     instance: Any,
-    schema: Mapping[Hashable, Any],
+    schema: Mapping[str, Any],
 ) -> Iterator[ValidationError]:
     if instance is None:
         return
@@ -138,10 +139,10 @@ def format(
 
 
 def items(
-    validator: Validator,
-    items: Mapping[Hashable, Any],
+    validator: Any,
+    items: Mapping[str, Any],
     instance: Any,
-    schema: Mapping[Hashable, Any],
+    schema: Mapping[str, Any],
 ) -> Iterator[ValidationError]:
     if not validator.is_type(instance, "array"):
         return
@@ -151,10 +152,10 @@ def items(
 
 
 def required(
-    validator: Validator,
-    required: List[str],
+    validator: Any,
+    required: list[str],
     instance: Any,
-    schema: Mapping[Hashable, Any],
+    schema: Mapping[str, Any],
 ) -> Iterator[ValidationError]:
     if not validator.is_type(instance, "object"):
         return
@@ -175,10 +176,10 @@ def required(
 
 
 def read_required(
-    validator: Validator,
-    required: List[str],
+    validator: Any,
+    required: list[str],
     instance: Any,
-    schema: Mapping[Hashable, Any],
+    schema: Mapping[str, Any],
 ) -> Iterator[ValidationError]:
     if not validator.is_type(instance, "object"):
         return
@@ -193,10 +194,10 @@ def read_required(
 
 
 def write_required(
-    validator: Validator,
-    required: List[str],
+    validator: Any,
+    required: list[str],
     instance: Any,
-    schema: Mapping[Hashable, Any],
+    schema: Mapping[str, Any],
 ) -> Iterator[ValidationError]:
     if not validator.is_type(instance, "object"):
         return
@@ -211,10 +212,10 @@ def write_required(
 
 
 def additionalProperties(
-    validator: Validator,
-    aP: Union[Mapping[Hashable, Any], bool],
+    validator: Any,
+    aP: Any,
     instance: Any,
-    schema: Mapping[Hashable, Any],
+    schema: Mapping[str, Any],
 ) -> Iterator[ValidationError]:
     if not validator.is_type(instance, "object"):
         return
@@ -235,28 +236,27 @@ def additionalProperties(
 
 
 def write_readOnly(
-    validator: Validator,
+    validator: Any,
     ro: bool,
     instance: Any,
-    schema: Mapping[Hashable, Any],
+    schema: Mapping[str, Any],
 ) -> Iterator[ValidationError]:
     yield ValidationError(f"Tried to write read-only property with {instance}")
 
 
 def read_writeOnly(
-    validator: Validator,
+    validator: Any,
     wo: bool,
     instance: Any,
-    schema: Mapping[Hashable, Any],
+    schema: Mapping[str, Any],
 ) -> Iterator[ValidationError]:
     yield ValidationError(f"Tried to read write-only property with {instance}")
 
 
 def not_implemented(
-    validator: Validator,
+    validator: Any,
     value: Any,
     instance: Any,
-    schema: Mapping[Hashable, Any],
+    schema: Mapping[str, Any],
 ) -> Iterator[ValidationError]:
-    return
-    yield
+    yield from ()

openapi_schema_validator/_types.py

@@ -1,4 +1,5 @@
 from typing import Any
+from typing import cast
 
 from jsonschema._types import TypeChecker
 from jsonschema._types import draft202012_type_checker
@@ -9,18 +10,21 @@
 from jsonschema._types import is_object
 
 
-def is_string(checker: TypeChecker, instance: Any) -> bool:
+def is_string(checker: Any, instance: Any) -> bool:
     return isinstance(instance, (str, bytes))
 
 
 oas30_type_checker = TypeChecker(
-    {
-        "string": is_string,
-        "number": is_number,
-        "integer": is_integer,
-        "boolean": is_bool,
-        "array": is_array,
-        "object": is_object,
-    },
+    cast(
+        Any,
+        {
+            "string": is_string,
+            "number": is_number,
+            "integer": is_integer,
+            "boolean": is_bool,
+            "array": is_array,
+            "object": is_object,
+        },
+    ),
 )
 oas31_type_checker = draft202012_type_checker

openapi_schema_validator/shortcuts.py

@@ -1,7 +1,6 @@
 from typing import Any
-from typing import Hashable
 from typing import Mapping
-from typing import Type
+from typing import cast
 
 from jsonschema.exceptions import best_match
 from jsonschema.protocols import Validator
@@ -11,13 +10,16 @@
 
 def validate(
     instance: Any,
-    schema: Mapping[Hashable, Any],
-    cls: Type[Validator] = OAS31Validator,
+    schema: Mapping[str, Any],
+    cls: type[Validator] = OAS31Validator,
     *args: Any,
     **kwargs: Any
 ) -> None:
-    cls.check_schema(schema)
-    validator = cls(schema, *args, **kwargs)
-    error = best_match(validator.evolve(schema=schema).iter_errors(instance))
+    schema_dict = cast(dict[str, Any], schema)
+    cls.check_schema(schema_dict)
+    validator = cls(schema_dict, *args, **kwargs)
+    error = best_match(
+        validator.evolve(schema=schema_dict).iter_errors(instance)
+    )
     if error is not None:
         raise error