chore: Add flake8-type-checking in favor of type_declarations.py

Author: sondrelg

.pre-commit-config.yaml

@@ -26,6 +26,7 @@ repos:
             'flake8-use-fstring',
             'flake8-simplify',
             'flake8-pytest-style',
+            'flake8-type-checking',
         ]
   - repo: https://github.com/asottile/pyupgrade
     rev: v2.29.1

openapi_tester/case_testers.py

@@ -1,10 +1,15 @@
 """ Case testers - this module includes helper functions to test key casing """
-from typing import Any, Callable
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 from inflection import camelize, dasherize, underscore
 
 from openapi_tester.exceptions import CaseError
 
+if TYPE_CHECKING:
+    from typing import Any, Callable
+
 
 def _create_tester(casing: str, handler: Callable[[Any], str]) -> Callable[[str], None]:
     """factory function for creating testers"""

openapi_tester/loaders.py

@@ -1,24 +1,27 @@
 """ Loaders Module """
+from __future__ import annotations
+
 import difflib
 import json
 import pathlib
 from json import dumps, loads
-from typing import Callable, Dict, List, Optional, Tuple, cast
-from urllib.parse import ParseResult, urlparse
+from typing import TYPE_CHECKING, cast
+from urllib.parse import urlparse
 
 import yaml
-from django.urls import Resolver404, ResolverMatch, resolve
+from django.urls import Resolver404, resolve
 from django.utils.functional import cached_property
 from openapi_spec_validator import openapi_v2_spec_validator, openapi_v3_spec_validator
-
-# noinspection PyProtectedMember
 from prance.util.resolver import RefResolver
-
-# noinspection PyProtectedMember
 from rest_framework.schemas.generators import BaseSchemaGenerator, EndpointEnumerator
 from rest_framework.settings import api_settings
+from rest_framework.views import APIView
+
+if TYPE_CHECKING:
+    from typing import Callable
+    from urllib.parse import ParseResult
 
-import openapi_tester.type_declarations as td
+    from django.urls import ResolverMatch
 
 
 def handle_recursion_limit(schema: dict) -> Callable:
@@ -47,12 +50,12 @@ class BaseSchemaLoader:
     """
 
     base_path = "/"
-    field_key_map: Dict[str, str]
-    schema: Optional[dict] = None
+    field_key_map: dict[str, str]
+    schema: dict | None = None
 
-    def __init__(self, field_key_map: Optional[Dict[str, str]] = None):
+    def __init__(self, field_key_map: dict[str, str] | None = None):
         super().__init__()
-        self.schema: Optional[dict] = None
+        self.schema: dict | None = None
         self.field_key_map = field_key_map or {}
 
     def load_schema(self) -> dict:
@@ -82,8 +85,8 @@ def de_reference_schema(self, schema: dict) -> dict:
         resolver.resolve_references()
         return resolver.specs
 
-    def normalize_schema_paths(self, schema: dict) -> Dict[str, dict]:
-        normalized_paths: Dict[str, dict] = {}
+    def normalize_schema_paths(self, schema: dict) -> dict[str, dict]:
+        normalized_paths: dict[str, dict] = {}
         for key, value in schema["paths"].items():
             try:
                 parameterized_path, _ = self.resolve_path(endpoint_path=key, method=list(value.keys())[0])
@@ -109,13 +112,13 @@ def set_schema(self, schema: dict) -> None:
         self.schema = self.normalize_schema_paths(de_referenced_schema)
 
     @cached_property
-    def endpoints(self) -> List[str]:  # pylint: disable=no-self-use
+    def endpoints(self) -> list[str]:  # pylint: disable=no-self-use
         """
         Returns a list of endpoint paths.
         """
         return list({endpoint[0] for endpoint in EndpointEnumerator().get_api_endpoints()})
 
-    def resolve_path(self, endpoint_path: str, method: str) -> Tuple[str, ResolverMatch]:
+    def resolve_path(self, endpoint_path: str, method: str) -> tuple[str, ResolverMatch]:
         """
         Resolves a Django path.
         """
@@ -147,12 +150,12 @@ def resolve_path(self, endpoint_path: str, method: str) -> Tuple[str, ResolverMa
         raise ValueError(message)
 
     @staticmethod
-    def handle_pk_parameter(resolved_route: ResolverMatch, path: str, method: str) -> Tuple[str, ResolverMatch]:
+    def handle_pk_parameter(resolved_route: ResolverMatch, path: str, method: str) -> tuple[str, ResolverMatch]:
         """
         Handle the DRF conversion of params called {pk} into a named parameter based on Model field
         """
         coerced_path = BaseSchemaGenerator().coerce_path(
-            path=path, method=method, view=cast(td.APIView, resolved_route.func)
+            path=path, method=method, view=cast(APIView, resolved_route.func)
         )
         pk_field_name = "".join(
             entry.replace("+ ", "") for entry in difflib.Differ().compare(path, coerced_path) if "+ " in entry
@@ -167,7 +170,7 @@ class DrfYasgSchemaLoader(BaseSchemaLoader):
     Loads OpenAPI schema generated by drf_yasg.
     """
 
-    def __init__(self, field_key_map: Optional[Dict[str, str]] = None) -> None:
+    def __init__(self, field_key_map: dict[str, str] | None = None) -> None:
         super().__init__(field_key_map=field_key_map)
         from drf_yasg.generators import OpenAPISchemaGenerator
         from drf_yasg.openapi import Info
@@ -181,7 +184,7 @@ def load_schema(self) -> dict:
         odict_schema = self.schema_generator.get_schema(None, True)
         return loads(dumps(odict_schema.as_odict()))
 
-    def resolve_path(self, endpoint_path: str, method: str) -> Tuple[str, ResolverMatch]:
+    def resolve_path(self, endpoint_path: str, method: str) -> tuple[str, ResolverMatch]:
         de_parameterized_path, resolved_path = super().resolve_path(endpoint_path=endpoint_path, method=method)
         path_prefix = self.schema_generator.determine_path_prefix(self.endpoints)
         trim_length = len(path_prefix) if path_prefix != "/" else 0
@@ -193,7 +196,7 @@ class DrfSpectacularSchemaLoader(BaseSchemaLoader):
     Loads OpenAPI schema generated by drf_spectacular.
     """
 
-    def __init__(self, field_key_map: Optional[Dict[str, str]] = None) -> None:
+    def __init__(self, field_key_map: dict[str, str] | None = None) -> None:
         super().__init__(field_key_map=field_key_map)
         from drf_spectacular.generators import SchemaGenerator
 
@@ -205,7 +208,7 @@ def load_schema(self) -> dict:
         """
         return loads(dumps(self.schema_generator.get_schema(public=True)))
 
-    def resolve_path(self, endpoint_path: str, method: str) -> Tuple[str, ResolverMatch]:
+    def resolve_path(self, endpoint_path: str, method: str) -> tuple[str, ResolverMatch]:
         from drf_spectacular.settings import spectacular_settings
 
         de_parameterized_path, resolved_path = super().resolve_path(endpoint_path=endpoint_path, method=method)
@@ -220,7 +223,7 @@ class StaticSchemaLoader(BaseSchemaLoader):
     Loads OpenAPI schema from a static file.
     """
 
-    def __init__(self, path: str, field_key_map: Optional[Dict[str, str]] = None):
+    def __init__(self, path: str, field_key_map: dict[str, str] | None = None):
         super().__init__(field_key_map=field_key_map)
         self.path = path if not isinstance(path, pathlib.PosixPath) else str(path)
 

openapi_tester/schema_tester.py

@@ -1,12 +1,12 @@
 """ Schema Tester """
+from __future__ import annotations
+
 from itertools import chain
-from typing import Any, Callable, Dict, List, Optional, Union, cast
+from typing import TYPE_CHECKING, Callable, List, cast
 
 from django.conf import settings
 from django.core.exceptions import ImproperlyConfigured
-from rest_framework.response import Response
 
-from openapi_tester import type_declarations as td
 from openapi_tester.constants import (
     INIT_ERROR,
     UNDOCUMENTED_SCHEMA_SECTION_ERROR,
@@ -37,20 +37,25 @@
     validate_unique_items,
 )
 
+if TYPE_CHECKING:
+    from typing import Any
+
+    from rest_framework.response import Response
+
 
 class SchemaTester:
     """Schema Tester: this is the base class of the library."""
 
-    loader: Union[StaticSchemaLoader, DrfSpectacularSchemaLoader, DrfYasgSchemaLoader]
-    validators: List[Callable[[dict, Any], Optional[str]]]
+    loader: StaticSchemaLoader | DrfSpectacularSchemaLoader | DrfYasgSchemaLoader
+    validators: list[Callable[[dict, Any], str | None]]
 
     def __init__(
         self,
-        case_tester: Optional[Callable[[str], None]] = None,
-        ignore_case: Optional[List[str]] = None,
-        schema_file_path: Optional[str] = None,
-        validators: Optional[List[Callable[[dict, Any], Optional[str]]]] = None,
-        field_key_map: Optional[Dict[str, str]] = None,
+        case_tester: Callable[[str], None] | None = None,
+        ignore_case: list[str] | None = None,
+        schema_file_path: str | None = None,
+        validators: list[Callable[[dict, Any], str | None]] | None = None,
+        field_key_map: dict[str, str] | None = None,
     ) -> None:
         """
         Iterates through an OpenAPI schema object and API response to check that they match at every level.
@@ -86,7 +91,7 @@ def get_key_value(schema: dict, key: str, error_addon: str = "") -> dict:
             ) from e
 
     @staticmethod
-    def get_status_code(schema: dict, status_code: Union[str, int], error_addon: str = "") -> dict:
+    def get_status_code(schema: dict, status_code: str | int, error_addon: str = "") -> dict:
         """
         Returns the status code section of a schema, handles both str and int status codes
         """
@@ -99,14 +104,14 @@ def get_status_code(schema: dict, status_code: Union[str, int], error_addon: str
         )
 
     @staticmethod
-    def get_schema_type(schema: dict) -> Optional[str]:
+    def get_schema_type(schema: dict) -> str | None:
         if "type" in schema:
             return schema["type"]
         if "properties" in schema or "additionalProperties" in schema:
             return "object"
         return None
 
-    def get_response_schema_section(self, response: td.Response) -> Dict[str, Any]:
+    def get_response_schema_section(self, response: Response) -> dict[str, Any]:
         """
         Fetches the response section of a schema, wrt. the route, method, status code, and schema version.
 
@@ -175,7 +180,7 @@ def handle_one_of(self, schema_section: dict, data: Any, reference: str, **kwarg
             raise DocumentationError(f"{VALIDATE_ONE_OF_ERROR.format(matches=matches)}\n\nReference: {reference}.oneOf")
 
     def handle_any_of(self, schema_section: dict, data: Any, reference: str, **kwargs: Any):
-        any_of: List[Dict[str, Any]] = schema_section.get("anyOf", [])
+        any_of: list[dict[str, Any]] = schema_section.get("anyOf", [])
         for schema in chain(any_of, lazy_combinations(any_of)):
             try:
                 self.test_schema_section(schema_section=schema, data=data, reference=f"{reference}.anyOf", **kwargs)
@@ -205,8 +210,8 @@ def test_is_nullable(schema_item: dict) -> bool:
     def test_key_casing(
         self,
         key: str,
-        case_tester: Optional[Callable[[str], None]] = None,
-        ignore_case: Optional[List[str]] = None,
+        case_tester: Callable[[str], None] | None = None,
+        ignore_case: list[str] | None = None,
     ) -> None:
         tester = case_tester or getattr(self, "case_tester", None)
         ignore_case = [*self.ignore_case, *(ignore_case or [])]
@@ -218,7 +223,7 @@ def test_schema_section(
         schema_section: dict,
         data: Any,
         reference: str = "init",
-        validators: Optional[List[Callable[[dict, dict], Optional[str]]]] = None,
+        validators: list[Callable[[dict, dict], str | None]] | None = None,
         **kwargs: Any,
     ) -> None:
         """
@@ -280,8 +285,8 @@ def test_openapi_object(
         schema_section: dict,
         data: dict,
         reference: str,
-        case_tester: Optional[Callable[[str], None]] = None,
-        ignore_case: Optional[List[str]] = None,
+        case_tester: Callable[[str], None] | None = None,
+        ignore_case: list[str] | None = None,
     ) -> None:
         """
         1. Validate that casing is correct for both response and schema
@@ -294,7 +299,7 @@ def test_openapi_object(
         write_only_properties = [key for key in properties.keys() if properties[key].get("writeOnly")]
         required_keys = [key for key in schema_section.get("required", []) if key not in write_only_properties]
         response_keys = data.keys()
-        additional_properties: Optional[Union[bool, dict]] = schema_section.get("additionalProperties")
+        additional_properties: bool | dict | None = schema_section.get("additionalProperties")
         additional_properties_allowed = additional_properties is not None
         if additional_properties_allowed and not isinstance(additional_properties, (bool, dict)):
             raise OpenAPISchemaError("Invalid additionalProperties type")
@@ -350,9 +355,9 @@ def test_openapi_array(self, schema_section: dict, data: dict, reference: str, *
     def validate_response(
         self,
         response: Response,
-        case_tester: Optional[Callable[[str], None]] = None,
-        ignore_case: Optional[List[str]] = None,
-        validators: Optional[List[Callable[[dict, Any], Optional[str]]]] = None,
+        case_tester: Callable[[str], None] | None = None,
+        ignore_case: list[str] | None = None,
+        validators: list[Callable[[dict, Any], str | None]] | None = None,
     ):
         """
         Verifies that an OpenAPI schema definition matches an API response.

openapi_tester/type_declarations.py

@@ -1,12 +1,17 @@
 """ Utils Module - this file contains utility functions used in multiple places """
+from __future__ import annotations
+
 from copy import deepcopy
 from itertools import chain, combinations
-from typing import Any, Dict, Iterator, Sequence
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any, Iterator, Sequence
 
 
-def merge_objects(dictionaries: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
+def merge_objects(dictionaries: Sequence[dict[str, Any]]) -> dict[str, Any]:
     """helper function to deep merge objects"""
-    output: Dict[str, Any] = {}
+    output: dict[str, Any] = {}
     for dictionary in dictionaries:
         for key, value in dictionary.items():
             if key not in output:
@@ -24,7 +29,7 @@ def merge_objects(dictionaries: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
 
 def normalize_schema_section(schema_section: dict) -> dict:
     """helper method to remove allOf and handle edge uses of oneOf"""
-    output: Dict[str, Any] = deepcopy(schema_section)
+    output: dict[str, Any] = deepcopy(schema_section)
     if output.get("allOf"):
         all_of = output.pop("allOf")
         output = {**output, **merge_objects(all_of)}
@@ -40,7 +45,7 @@ def normalize_schema_section(schema_section: dict) -> dict:
     return output
 
 
-def lazy_combinations(options_list: Sequence[Dict[str, Any]]) -> Iterator[dict]:
+def lazy_combinations(options_list: Sequence[dict[str, Any]]) -> Iterator[dict]:
     """helper to lazy evaluate possible permutations of possible combinations"""
     for i in range(2, len(options_list) + 1):
         for combination in combinations(options_list, i):