schemathesis 3.21.2__py3-none-any.whl → 3.22.1__py3-none-any.whl

schemathesis/specs/openapi/schemas.py

@@ -14,17 +14,11 @@ from typing import (
     Any,
     Callable,
     ClassVar,
-    Dict,
     Generator,
     Iterable,
-    List,
     NoReturn,
-    Optional,
     Sequence,
-    Tuple,
-    Type,
     TypeVar,
-    Union,
 )
 from urllib.parse import urlsplit
 
@@ -37,7 +31,7 @@ from requests.structures import CaseInsensitiveDict
 from ... import experimental, failures
 from ..._compat import MultipleFailures
 from ...auths import AuthStorage
-from ...generation import DataGenerationMethod
+from ...generation import DataGenerationMethod, GenerationConfig
 from ...constants import HTTP_METHODS, NOT_SET
 from ...exceptions import (
     OperationSchemaError,
@@ -93,19 +87,19 @@ class BaseOpenAPISchema(BaseSchema):
     links_field: ClassVar[str] = ""
     header_required_field: ClassVar[str] = ""
     security: ClassVar[BaseSecurityProcessor] = None  # type: ignore
-    _operations_by_id: Dict[str, APIOperation] = field(init=False)
-    _inline_reference_cache: Dict[str, Any] = field(default_factory=dict)
+    _operations_by_id: dict[str, APIOperation] = field(init=False)
+    _inline_reference_cache: dict[str, Any] = field(default_factory=dict)
     # Inline references cache can be populated from multiple threads, therefore we need some synchronisation to avoid
     # excessive resolving
     _inline_reference_cache_lock: RLock = field(default_factory=RLock)
-    component_locations: ClassVar[Tuple[Tuple[str, ...], ...]] = ()
+    component_locations: ClassVar[tuple[tuple[str, ...], ...]] = ()
 
     @property
     def spec_version(self) -> str:
         raise NotImplementedError
 
     def get_stateful_tests(
-        self, response: GenericResponse, operation: APIOperation, stateful: Optional[Stateful]
+        self, response: GenericResponse, operation: APIOperation, stateful: Stateful | None
     ) -> Sequence[StatefulTest]:
         if stateful == Stateful.links:
             return links.get_links(response, operation, field=self.links_field)
@@ -115,7 +109,7 @@ class BaseOpenAPISchema(BaseSchema):
         info = self.raw_schema["info"]
         return f"{self.__class__.__name__} for {info['title']} ({info['version']})"
 
-    def _should_skip(self, method: str, definition: Dict[str, Any]) -> bool:
+    def _should_skip(self, method: str, definition: dict[str, Any]) -> bool:
         return (
             method not in HTTP_METHODS
             or should_skip_method(method, self.method)
@@ -124,13 +118,11 @@ class BaseOpenAPISchema(BaseSchema):
             or should_skip_by_operation_id(definition.get("operationId"), self.operation_id)
         )
 
-    @property
-    def operations_count(self) -> int:
+    def _operation_iter(self) -> Generator[dict[str, Any], None, None]:
         try:
             paths = self.raw_schema["paths"]
         except KeyError:
-            return 0
-        total = 0
+            return
         resolve = self.resolver.resolve
         for path, methods in paths.items():
             full_path = self.get_full_path(path)
@@ -145,14 +137,33 @@ class BaseOpenAPISchema(BaseSchema):
                 for method, definition in resolved_methods.items():
                     if self._should_skip(method, definition):
                         continue
-                    total += 1
+                    yield definition
             except SCHEMA_PARSING_ERRORS:
                 # Ignore errors
                 continue
+
+    @property
+    def operations_count(self) -> int:
+        total = 0
+        # Do not build a list from it
+        for _ in self._operation_iter():
+            total += 1
+        return total
+
+    @property
+    def links_count(self) -> int:
+        total = 0
+        for definition in self._operation_iter():
+            for response in definition.get("responses", {}).values():
+                if "$ref" in response:
+                    _, response = self.resolver.resolve(response["$ref"])
+                defined_links = response.get(self.links_field)
+                if defined_links is not None:
+                    total += len(defined_links)
         return total
 
     def get_all_operations(
-        self, hooks: Optional[HookDispatcher] = None
+        self, hooks: HookDispatcher | None = None
     ) -> Generator[Result[APIOperation, OperationSchemaError], None, None]:
         """Iterate over all operations defined in the API.
 
@@ -221,7 +232,7 @@ class BaseOpenAPISchema(BaseSchema):
             except SCHEMA_PARSING_ERRORS as exc:
                 yield self._into_err(exc, path, method)
 
-    def _into_err(self, error: Exception, path: Optional[str], method: Optional[str]) -> Err[OperationSchemaError]:
+    def _into_err(self, error: Exception, path: str | None, method: str | None) -> Err[OperationSchemaError]:
         __tracebackhide__ = True
         try:
             full_path = self.get_full_path(path) if isinstance(path, str) else None
@@ -232,9 +243,9 @@ class BaseOpenAPISchema(BaseSchema):
     def _raise_invalid_schema(
         self,
         error: Exception,
-        full_path: Optional[str] = None,
-        path: Optional[str] = None,
-        method: Optional[str] = None,
+        full_path: str | None = None,
+        path: str | None = None,
+        method: str | None = None,
     ) -> NoReturn:
         __tracebackhide__ = True
         if isinstance(error, jsonschema.exceptions.RefResolutionError):
@@ -257,8 +268,8 @@ class BaseOpenAPISchema(BaseSchema):
         raise NotImplementedError
 
     def collect_parameters(
-        self, parameters: Iterable[Dict[str, Any]], definition: Dict[str, Any]
-    ) -> List[OpenAPIParameter]:
+        self, parameters: Iterable[dict[str, Any]], definition: dict[str, Any]
+    ) -> list[OpenAPIParameter]:
         """Collect Open API parameters.
 
         They should be used uniformly during the generation step; therefore, we need to convert them into
@@ -266,7 +277,7 @@ class BaseOpenAPISchema(BaseSchema):
         """
         raise NotImplementedError
 
-    def _resolve_methods(self, methods: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
+    def _resolve_methods(self, methods: dict[str, Any]) -> tuple[str, dict[str, Any]]:
         # We need to know a proper scope in what methods are.
         # It will allow us to provide a proper reference resolving in `response_schema_conformance` and avoid
         # recursion errors
@@ -278,7 +289,7 @@ class BaseOpenAPISchema(BaseSchema):
         self,
         path: str,
         method: str,
-        parameters: List[OpenAPIParameter],
+        parameters: list[OpenAPIParameter],
         raw_definition: OperationDefinition,
     ) -> APIOperation:
         """Create JSON schemas for the query, body, etc from Swagger parameters definitions."""
@@ -304,19 +315,19 @@ class BaseOpenAPISchema(BaseSchema):
             self._resolver = InliningResolver(self.location or "", self.raw_schema)
         return self._resolver
 
-    def get_content_types(self, operation: APIOperation, response: GenericResponse) -> List[str]:
+    def get_content_types(self, operation: APIOperation, response: GenericResponse) -> list[str]:
         """Content types available for this API operation."""
         raise NotImplementedError
 
-    def get_strategies_from_examples(self, operation: APIOperation) -> List[SearchStrategy[Case]]:
+    def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
         raise NotImplementedError
 
-    def get_security_requirements(self, operation: APIOperation) -> List[str]:
+    def get_security_requirements(self, operation: APIOperation) -> list[str]:
         """Get applied security requirements for the given API operation."""
         return self.security.get_security_requirements(self.raw_schema, operation)
 
-    def get_response_schema(self, definition: Dict[str, Any], scope: str) -> Tuple[List[str], Optional[Dict[str, Any]]]:
+    def get_response_schema(self, definition: dict[str, Any], scope: str) -> tuple[list[str], dict[str, Any] | None]:
         """Extract response schema from `responses`."""
         raise NotImplementedError
 
@@ -326,7 +337,7 @@ class BaseOpenAPISchema(BaseSchema):
             self._operations_by_id = dict(self._group_operations_by_id())
         return self._operations_by_id[operation_id]
 
-    def _group_operations_by_id(self) -> Generator[Tuple[str, APIOperation], None, None]:
+    def _group_operations_by_id(self) -> Generator[tuple[str, APIOperation], None, None]:
         for path, methods in self.raw_schema["paths"].items():
             scope, raw_methods = self._resolve_methods(methods)
             common_parameters = self.resolver.resolve_all(methods.get("parameters", []), RECURSION_DEPTH_LIMIT - 8)
@@ -365,9 +376,10 @@ class BaseOpenAPISchema(BaseSchema):
     def get_case_strategy(
         self,
         operation: APIOperation,
-        hooks: Optional[HookDispatcher] = None,
-        auth_storage: Optional[AuthStorage] = None,
+        hooks: HookDispatcher | None = None,
+        auth_storage: AuthStorage | None = None,
         data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),
+        generation_config: GenerationConfig | None = None,
         **kwargs: Any,
     ) -> SearchStrategy:
         return get_case_strategy(
@@ -375,10 +387,11 @@ class BaseOpenAPISchema(BaseSchema):
             auth_storage=auth_storage,
             hooks=hooks,
             generator=data_generation_method,
+            generation_config=generation_config,
             **kwargs,
         )
 
-    def get_parameter_serializer(self, operation: APIOperation, location: str) -> Optional[Callable]:
+    def get_parameter_serializer(self, operation: APIOperation, location: str) -> Callable | None:
         definitions = [item for item in operation.definition.resolved.get("parameters", []) if item["in"] == location]
         security_parameters = self.security.get_security_definitions_as_parameters(
             self.raw_schema, operation, self.resolver, location
@@ -390,10 +403,10 @@ class BaseOpenAPISchema(BaseSchema):
             return self._get_parameter_serializer(definitions)
         return None
 
-    def _get_parameter_serializer(self, definitions: List[Dict[str, Any]]) -> Optional[Callable]:
+    def _get_parameter_serializer(self, definitions: list[dict[str, Any]]) -> Callable | None:
         raise NotImplementedError
 
-    def _get_response_definitions(self, operation: APIOperation, response: GenericResponse) -> Optional[Dict[str, Any]]:
+    def _get_response_definitions(self, operation: APIOperation, response: GenericResponse) -> dict[str, Any] | None:
         try:
             responses = operation.definition.resolved["responses"]
         except KeyError as exc:
@@ -408,23 +421,23 @@ class BaseOpenAPISchema(BaseSchema):
             return responses["default"]
         return None
 
-    def get_headers(self, operation: APIOperation, response: GenericResponse) -> Optional[Dict[str, Dict[str, Any]]]:
+    def get_headers(self, operation: APIOperation, response: GenericResponse) -> dict[str, dict[str, Any]] | None:
         definitions = self._get_response_definitions(operation, response)
         if not definitions:
             return None
         return definitions.get("headers")
 
-    def as_state_machine(self) -> Type[APIStateMachine]:
+    def as_state_machine(self) -> type[APIStateMachine]:
         return create_state_machine(self)
 
     def add_link(
         self,
         source: APIOperation,
-        target: Union[str, APIOperation],
-        status_code: Union[str, int],
-        parameters: Optional[Dict[str, str]] = None,
+        target: str | APIOperation,
+        status_code: str | int,
+        parameters: dict[str, str] | None = None,
         request_body: Any = None,
-        name: Optional[str] = None,
+        name: str | None = None,
     ) -> None:
         """Add a new Open API link to the schema definition.
 
@@ -493,13 +506,13 @@ class BaseOpenAPISchema(BaseSchema):
         message += " Check if the requested API operation passes the filters in the schema."
         raise ValueError(message)
 
-    def get_links(self, operation: APIOperation) -> Dict[str, Dict[str, Any]]:
-        result: Dict[str, Dict[str, Any]] = defaultdict(dict)
+    def get_links(self, operation: APIOperation) -> dict[str, dict[str, Any]]:
+        result: dict[str, dict[str, Any]] = defaultdict(dict)
         for status_code, link in links.get_all_links(operation):
             result[status_code][link.name] = link
         return result
 
-    def validate_response(self, operation: APIOperation, response: GenericResponse) -> None:
+    def validate_response(self, operation: APIOperation, response: GenericResponse) -> bool | None:
         responses = {str(key): value for key, value in operation.definition.raw.get("responses", {}).items()}
         status_code = str(response.status_code)
         if status_code in responses:
@@ -508,11 +521,11 @@ class BaseOpenAPISchema(BaseSchema):
             definition = responses["default"]
         else:
             # No response defined for the received response status code
-            return
+            return None
         scopes, schema = self.get_response_schema(definition, operation.definition.scope)
         if not schema:
             # No schema to check against
-            return
+            return None
         content_type = response.headers.get("Content-Type")
         errors = []
         if content_type is None:
@@ -528,7 +541,7 @@ class BaseOpenAPISchema(BaseSchema):
                 errors.append(exc)
         if content_type and not is_json_media_type(content_type):
             _maybe_raise_one_or_more(errors)
-            return
+            return None
         try:
             if isinstance(response, (requests.Response, httpx.Response)):
                 data = json.loads(response.text)
@@ -563,15 +576,15 @@ class BaseOpenAPISchema(BaseSchema):
         return None  # explicitly return None for mypy
 
     @property
-    def rewritten_components(self) -> Dict[str, Any]:
+    def rewritten_components(self) -> dict[str, Any]:
         if not hasattr(self, "_rewritten_components"):
 
-            def callback(_schema: Dict[str, Any], nullable_name: str) -> Dict[str, Any]:
+            def callback(_schema: dict[str, Any], nullable_name: str) -> dict[str, Any]:
                 _schema = to_json_schema(_schema, nullable_name=nullable_name, copy=False)
                 return self._rewrite_references(_schema, self.resolver)
 
             # Different spec versions allow different keywords to store possible reference targets
-            components: Dict[str, Any] = {}
+            components: dict[str, Any] = {}
             for path in self.component_locations:
                 schema = self.raw_schema
                 target = components
@@ -624,7 +637,7 @@ class BaseOpenAPISchema(BaseSchema):
                         stack.append(sub_item)
         return schema
 
-    def _rewrite_references(self, schema: Dict[str, Any], resolver: InliningResolver) -> Dict[str, Any]:
+    def _rewrite_references(self, schema: dict[str, Any], resolver: InliningResolver) -> dict[str, Any]:
         """Rewrite references present in the schema.
 
         The idea is to resolve references, cache the result and replace these references with new ones
@@ -646,7 +659,7 @@ class BaseOpenAPISchema(BaseSchema):
         return schema
 
 
-def _maybe_raise_one_or_more(errors: List[Exception]) -> None:
+def _maybe_raise_one_or_more(errors: list[Exception]) -> None:
     if not errors:
         return
     elif len(errors) == 1:
@@ -655,7 +668,7 @@ def _maybe_raise_one_or_more(errors: List[Exception]) -> None:
         raise MultipleFailures("\n\n".join(str(error) for error in errors), errors)
 
 
-def _make_reference_key(scopes: List[str], reference: str) -> str:
+def _make_reference_key(scopes: list[str], reference: str) -> str:
     """A name under which the resolved reference data will be stored."""
     # Using a hexdigest is the simplest way to associate practically unique keys with each reference
     digest = sha1()
@@ -681,7 +694,7 @@ def in_scope(resolver: jsonschema.RefResolver, scope: str) -> Generator[None, No
 
 
 @contextmanager
-def in_scopes(resolver: jsonschema.RefResolver, scopes: List[str]) -> Generator[None, None, None]:
+def in_scopes(resolver: jsonschema.RefResolver, scopes: list[str]) -> Generator[None, None, None]:
     """Push all available scopes into the resolver.
 
     There could be an additional scope change during a schema resolving in `get_response_schema`, so in total there
@@ -705,7 +718,7 @@ class SwaggerV20(BaseOpenAPISchema):
     examples_field = "x-examples"
     header_required_field = "x-required"
     security = SwaggerSecurityProcessor()
-    component_locations: ClassVar[Tuple[Tuple[str, ...], ...]] = (("definitions",),)
+    component_locations: ClassVar[tuple[tuple[str, ...], ...]] = (("definitions",),)
     links_field = "x-links"
 
     @property
@@ -723,11 +736,11 @@ class SwaggerV20(BaseOpenAPISchema):
         return self.raw_schema.get("basePath", "/")
 
     def collect_parameters(
-        self, parameters: Iterable[Dict[str, Any]], definition: Dict[str, Any]
-    ) -> List[OpenAPIParameter]:
+        self, parameters: Iterable[dict[str, Any]], definition: dict[str, Any]
+    ) -> list[OpenAPIParameter]:
         # The main difference with Open API 3.0 is that it has `body` and `form` parameters that we need to handle
         # differently.
-        collected: List[OpenAPIParameter] = []
+        collected: list[OpenAPIParameter] = []
         # NOTE. The Open API 2.0 spec doesn't strictly imply having media types in the "consumes" keyword.
         # It is not enforced by the meta schema and has no "MUST" verb in the spec text.
         # Also, not every API has operations with payload (they might have only GET operations without payloads).
@@ -760,11 +773,11 @@ class SwaggerV20(BaseOpenAPISchema):
                 )
         return collected
 
-    def get_strategies_from_examples(self, operation: APIOperation) -> List[SearchStrategy[Case]]:
+    def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
         return get_strategies_from_examples(operation, self.examples_field)
 
-    def get_response_schema(self, definition: Dict[str, Any], scope: str) -> Tuple[List[str], Optional[Dict[str, Any]]]:
+    def get_response_schema(self, definition: dict[str, Any], scope: str) -> tuple[list[str], dict[str, Any] | None]:
         scopes, definition = self.resolver.resolve_in_scope(fast_deepcopy(definition), scope)
         schema = definition.get("schema")
         if not schema:
@@ -773,18 +786,18 @@ class SwaggerV20(BaseOpenAPISchema):
         # because it is not converted
         return scopes, to_json_schema_recursive(schema, self.nullable_name, is_response_schema=True)
 
-    def get_content_types(self, operation: APIOperation, response: GenericResponse) -> List[str]:
+    def get_content_types(self, operation: APIOperation, response: GenericResponse) -> list[str]:
         produces = operation.definition.raw.get("produces", None)
         if produces:
             return produces
         return self.raw_schema.get("produces", [])
 
-    def _get_parameter_serializer(self, definitions: List[Dict[str, Any]]) -> Optional[Callable]:
+    def _get_parameter_serializer(self, definitions: list[dict[str, Any]]) -> Callable | None:
         return serialization.serialize_swagger2_parameters(definitions)
 
     def prepare_multipart(
         self, form_data: FormData, operation: APIOperation
-    ) -> Tuple[Optional[List], Optional[Dict[str, Any]]]:
+    ) -> tuple[list | None, dict[str, Any] | None]:
         """Prepare form data for sending with `requests`.
 
         :param form_data: Raw generated data as a dictionary.
@@ -818,20 +831,20 @@ class SwaggerV20(BaseOpenAPISchema):
         # `None` is the default value for `files` and `data` arguments in `requests.request`
         return files or None, data or None
 
-    def get_request_payload_content_types(self, operation: APIOperation) -> List[str]:
+    def get_request_payload_content_types(self, operation: APIOperation) -> list[str]:
         return self._get_consumes_for_operation(operation.definition.resolved)
 
     def make_case(
         self,
         *,
-        case_cls: Type[C],
+        case_cls: type[C],
         operation: APIOperation,
-        path_parameters: Optional[PathParameters] = None,
-        headers: Optional[Headers] = None,
-        cookies: Optional[Cookies] = None,
-        query: Optional[Query] = None,
-        body: Union[Body, NotSet] = NOT_SET,
-        media_type: Optional[str] = None,
+        path_parameters: PathParameters | None = None,
+        headers: Headers | None = None,
+        cookies: Cookies | None = None,
+        query: Query | None = None,
+        body: Body | NotSet = NOT_SET,
+        media_type: str | None = None,
     ) -> C:
         if body is not NOT_SET and media_type is None:
             # If the user wants to send payload, then there should be a media type, otherwise the payload is ignored
@@ -856,7 +869,7 @@ class SwaggerV20(BaseOpenAPISchema):
             media_type=media_type,
         )
 
-    def _get_consumes_for_operation(self, definition: Dict[str, Any]) -> List[str]:
+    def _get_consumes_for_operation(self, definition: dict[str, Any]) -> list[str]:
         """Get the `consumes` value for the given API operation.
 
         :param definition: Raw API operation definition.
@@ -869,7 +882,7 @@ class SwaggerV20(BaseOpenAPISchema):
             consumes = global_consumes
         return consumes
 
-    def _get_payload_schema(self, definition: Dict[str, Any], media_type: str) -> Optional[Dict[str, Any]]:
+    def _get_payload_schema(self, definition: dict[str, Any], media_type: str) -> dict[str, Any] | None:
         for parameter in definition.get("parameters", []):
             if parameter["in"] == "body":
                 return parameter["schema"]
@@ -910,10 +923,10 @@ class OpenApi30(SwaggerV20):
         return "/"
 
     def collect_parameters(
-        self, parameters: Iterable[Dict[str, Any]], definition: Dict[str, Any]
-    ) -> List[OpenAPIParameter]:
+        self, parameters: Iterable[dict[str, Any]], definition: dict[str, Any]
+    ) -> list[OpenAPIParameter]:
         # Open API 3.0 has the `requestBody` keyword, which may contain multiple different payload variants.
-        collected: List[OpenAPIParameter] = [OpenAPI30Parameter(definition=parameter) for parameter in parameters]
+        collected: list[OpenAPIParameter] = [OpenAPI30Parameter(definition=parameter) for parameter in parameters]
         if "requestBody" in definition:
             required = definition["requestBody"].get("required", False)
             description = definition["requestBody"].get("description")
@@ -923,7 +936,7 @@ class OpenApi30(SwaggerV20):
                 )
         return collected
 
-    def get_response_schema(self, definition: Dict[str, Any], scope: str) -> Tuple[List[str], Optional[Dict[str, Any]]]:
+    def get_response_schema(self, definition: dict[str, Any], scope: str) -> tuple[list[str], dict[str, Any] | None]:
         scopes, definition = self.resolver.resolve_in_scope(fast_deepcopy(definition), scope)
         options = iter(definition.get("content", {}).values())
         option = next(options, None)
@@ -934,25 +947,25 @@ class OpenApi30(SwaggerV20):
             return scopes, to_json_schema_recursive(option["schema"], self.nullable_name, is_response_schema=True)
         return scopes, None
 
-    def get_strategies_from_examples(self, operation: APIOperation) -> List[SearchStrategy[Case]]:
+    def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
         return get_strategies_from_examples(operation, self.examples_field)
 
-    def get_content_types(self, operation: APIOperation, response: GenericResponse) -> List[str]:
+    def get_content_types(self, operation: APIOperation, response: GenericResponse) -> list[str]:
         definitions = self._get_response_definitions(operation, response)
         if not definitions:
             return []
         return list(definitions.get("content", {}).keys())
 
-    def _get_parameter_serializer(self, definitions: List[Dict[str, Any]]) -> Optional[Callable]:
+    def _get_parameter_serializer(self, definitions: list[dict[str, Any]]) -> Callable | None:
         return serialization.serialize_openapi3_parameters(definitions)
 
-    def get_request_payload_content_types(self, operation: APIOperation) -> List[str]:
+    def get_request_payload_content_types(self, operation: APIOperation) -> list[str]:
         return list(operation.definition.resolved["requestBody"]["content"].keys())
 
     def prepare_multipart(
         self, form_data: FormData, operation: APIOperation
-    ) -> Tuple[Optional[List], Optional[Dict[str, Any]]]:
+    ) -> tuple[list | None, dict[str, Any] | None]:
         """Prepare form data for sending with `requests`.
 
         :param form_data: Raw generated data as a dictionary.
@@ -975,7 +988,7 @@ class OpenApi30(SwaggerV20):
         # `None` is the default value for `files` and `data` arguments in `requests.request`
         return files or None, None
 
-    def _get_payload_schema(self, definition: Dict[str, Any], media_type: str) -> Optional[Dict[str, Any]]:
+    def _get_payload_schema(self, definition: dict[str, Any], media_type: str) -> dict[str, Any] | None:
         if "requestBody" in definition:
             if "$ref" in definition["requestBody"]:
                 body = self.resolver.resolve_all(definition["requestBody"], RECURSION_DEPTH_LIMIT)

schemathesis/specs/openapi/security.py

@@ -1,6 +1,7 @@
 """Processing of ``securityDefinitions`` or ``securitySchemes`` keywords."""
+from __future__ import annotations
 from dataclasses import dataclass
-from typing import Any, ClassVar, Dict, Generator, List, Tuple, Type
+from typing import Any, ClassVar, Generator
 
 from jsonschema import RefResolver
 
@@ -10,11 +11,11 @@ from .parameters import OpenAPI20Parameter, OpenAPI30Parameter, OpenAPIParameter
 
 @dataclass
 class BaseSecurityProcessor:
-    api_key_locations: ClassVar[Tuple[str, ...]] = ("header", "query")
+    api_key_locations: ClassVar[tuple[str, ...]] = ("header", "query")
     http_security_name: ClassVar[str] = "basic"
-    parameter_cls: ClassVar[Type[OpenAPIParameter]] = OpenAPI20Parameter
+    parameter_cls: ClassVar[type[OpenAPIParameter]] = OpenAPI20Parameter
 
-    def process_definitions(self, schema: Dict[str, Any], operation: APIOperation, resolver: RefResolver) -> None:
+    def process_definitions(self, schema: dict[str, Any], operation: APIOperation, resolver: RefResolver) -> None:
         """Add relevant security parameters to data generation."""
         __tracebackhide__ = True
         for definition in self._get_active_definitions(schema, operation, resolver):
@@ -28,7 +29,7 @@ class BaseSecurityProcessor:
             self.process_http_security_definition(definition, operation)
 
     @staticmethod
-    def get_security_requirements(schema: Dict[str, Any], operation: APIOperation) -> List[str]:
+    def get_security_requirements(schema: dict[str, Any], operation: APIOperation) -> list[str]:
         """Get applied security requirements for the given API operation."""
         # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#operation-object
         # > This definition overrides any declared top-level security.
@@ -42,8 +43,8 @@ class BaseSecurityProcessor:
         return [key for requirement in requirements for key in requirement]
 
     def _get_active_definitions(
-        self, schema: Dict[str, Any], operation: APIOperation, resolver: RefResolver
-    ) -> Generator[Dict[str, Any], None, None]:
+        self, schema: dict[str, Any], operation: APIOperation, resolver: RefResolver
+    ) -> Generator[dict[str, Any], None, None]:
         """Get only security definitions active for the given API operation."""
         definitions = self.get_security_definitions(schema, resolver)
         requirements = self.get_security_requirements(schema, operation)
@@ -51,12 +52,12 @@ class BaseSecurityProcessor:
             if name in requirements:
                 yield definition
 
-    def get_security_definitions(self, schema: Dict[str, Any], resolver: RefResolver) -> Dict[str, Any]:
+    def get_security_definitions(self, schema: dict[str, Any], resolver: RefResolver) -> dict[str, Any]:
         return schema.get("securityDefinitions", {})
 
     def get_security_definitions_as_parameters(
-        self, schema: Dict[str, Any], operation: APIOperation, resolver: RefResolver, location: str
-    ) -> List[Dict[str, Any]]:
+        self, schema: dict[str, Any], operation: APIOperation, resolver: RefResolver, location: str
+    ) -> list[dict[str, Any]]:
         """Security definitions converted to OAS parameters.
 
         We need it to get proper serialization that will be applied on generated values. For this case it is only
@@ -68,45 +69,45 @@ class BaseSecurityProcessor:
             if self._is_match(definition, location)
         ]
 
-    def process_api_key_security_definition(self, definition: Dict[str, Any], operation: APIOperation) -> None:
+    def process_api_key_security_definition(self, definition: dict[str, Any], operation: APIOperation) -> None:
         parameter = self.parameter_cls(self._make_api_key_parameter(definition))
         operation.add_parameter(parameter)
 
-    def process_http_security_definition(self, definition: Dict[str, Any], operation: APIOperation) -> None:
+    def process_http_security_definition(self, definition: dict[str, Any], operation: APIOperation) -> None:
         if definition["type"] == self.http_security_name:
             parameter = self.parameter_cls(self._make_http_auth_parameter(definition))
             operation.add_parameter(parameter)
 
-    def _is_match(self, definition: Dict[str, Any], location: str) -> bool:
+    def _is_match(self, definition: dict[str, Any], location: str) -> bool:
         return (definition["type"] == "apiKey" and location in self.api_key_locations) or (
             definition["type"] == self.http_security_name and location == "header"
         )
 
-    def _to_parameter(self, definition: Dict[str, Any]) -> Dict[str, Any]:
+    def _to_parameter(self, definition: dict[str, Any]) -> dict[str, Any]:
         func = {
             "apiKey": self._make_api_key_parameter,
             self.http_security_name: self._make_http_auth_parameter,
         }[definition["type"]]
         return func(definition)
 
-    def _make_http_auth_parameter(self, definition: Dict[str, Any]) -> Dict[str, Any]:
+    def _make_http_auth_parameter(self, definition: dict[str, Any]) -> dict[str, Any]:
         schema = make_auth_header_schema(definition)
         return make_auth_header(**schema)
 
-    def _make_api_key_parameter(self, definition: Dict[str, Any]) -> Dict[str, Any]:
+    def _make_api_key_parameter(self, definition: dict[str, Any]) -> dict[str, Any]:
         return make_api_key_schema(definition, type="string")
 
 
-def make_auth_header_schema(definition: Dict[str, Any]) -> Dict[str, str]:
+def make_auth_header_schema(definition: dict[str, Any]) -> dict[str, str]:
     schema = definition.get("scheme", "basic").lower()
     return {"type": "string", "format": f"_{schema}_auth"}
 
 
-def make_auth_header(**kwargs: Any) -> Dict[str, Any]:
+def make_auth_header(**kwargs: Any) -> dict[str, Any]:
     return {"name": "Authorization", "in": "header", "required": True, **kwargs}
 
 
-def make_api_key_schema(definition: Dict[str, Any], **kwargs: Any) -> Dict[str, Any]:
+def make_api_key_schema(definition: dict[str, Any], **kwargs: Any) -> dict[str, Any]:
     return {"name": definition["name"], "required": True, "in": definition["in"], **kwargs}
 
 
@@ -115,11 +116,11 @@ SwaggerSecurityProcessor = BaseSecurityProcessor
 
 @dataclass
 class OpenAPISecurityProcessor(BaseSecurityProcessor):
-    api_key_locations: ClassVar[Tuple[str, ...]] = ("header", "cookie", "query")
+    api_key_locations: ClassVar[tuple[str, ...]] = ("header", "cookie", "query")
     http_security_name: ClassVar[str] = "http"
-    parameter_cls: ClassVar[Type[OpenAPIParameter]] = OpenAPI30Parameter
+    parameter_cls: ClassVar[type[OpenAPIParameter]] = OpenAPI30Parameter
 
-    def get_security_definitions(self, schema: Dict[str, Any], resolver: RefResolver) -> Dict[str, Any]:
+    def get_security_definitions(self, schema: dict[str, Any], resolver: RefResolver) -> dict[str, Any]:
         """In Open API 3 security definitions are located in ``components`` and may have references inside."""
         components = schema.get("components", {})
         security_schemes = components.get("securitySchemes", {})
@@ -127,9 +128,9 @@ class OpenAPISecurityProcessor(BaseSecurityProcessor):
             return resolver.resolve(security_schemes["$ref"])[1]
         return security_schemes
 
-    def _make_http_auth_parameter(self, definition: Dict[str, Any]) -> Dict[str, Any]:
+    def _make_http_auth_parameter(self, definition: dict[str, Any]) -> dict[str, Any]:
         schema = make_auth_header_schema(definition)
         return make_auth_header(schema=schema)
 
-    def _make_api_key_parameter(self, definition: Dict[str, Any]) -> Dict[str, Any]:
+    def _make_api_key_parameter(self, definition: dict[str, Any]) -> dict[str, Any]:
         return make_api_key_schema(definition, schema={"type": "string"})