schemathesis 3.25.6__py3-none-any.whl → 3.39.7__py3-none-any.whl

schemathesis/specs/openapi/schemas.py

@@ -8,6 +8,7 @@ from difflib import get_close_matches
 from hashlib import sha1
 from json import JSONDecodeError
 from threading import RLock
+from types import SimpleNamespace
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -15,57 +16,49 @@ from typing import (
     ClassVar,
     Generator,
     Iterable,
+    Iterator,
+    Mapping,
     NoReturn,
     Sequence,
     TypeVar,
+    cast,
 )
 from urllib.parse import urlsplit
 
 import jsonschema
-from hypothesis.strategies import SearchStrategy
 from packaging import version
 from requests.structures import CaseInsensitiveDict
 
 from ... import experimental, failures
 from ..._compat import MultipleFailures
-from ..._override import CaseOverride, set_override_mark, check_no_override_mark
-from ...auths import AuthStorage
-from ...generation import DataGenerationMethod, GenerationConfig
+from ..._override import CaseOverride, check_no_override_mark, set_override_mark
 from ...constants import HTTP_METHODS, NOT_SET
 from ...exceptions import (
     InternalError,
+    OperationNotFound,
     OperationSchemaError,
-    UsageError,
+    SchemaError,
+    SchemaErrorType,
     get_missing_content_type_error,
     get_response_parsing_error,
     get_schema_validation_error,
-    SchemaError,
-    SchemaErrorType,
-    OperationNotFound,
 )
+from ...generation import DataGenerationMethod, GenerationConfig
 from ...hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, should_skip_operation
 from ...internal.copy import fast_deepcopy
 from ...internal.jsonschema import traverse_schema
 from ...internal.result import Err, Ok, Result
 from ...models import APIOperation, Case, OperationDefinition
-from ...schemas import BaseSchema, APIOperationMap
+from ...schemas import APIOperationMap, BaseSchema
 from ...stateful import Stateful, StatefulTest
-from ...stateful.state_machine import APIStateMachine
 from ...transports.content_types import is_json_media_type, parse_content_type
 from ...transports.responses import get_json
-from ...types import Body, Cookies, FormData, Headers, NotSet, PathParameters, Query, GenericTest
 from . import links, serialization
+from ._cache import OperationCache
 from ._hypothesis import get_case_strategy
 from .converter import to_json_schema, to_json_schema_recursive
 from .definitions import OPENAPI_30_VALIDATOR, OPENAPI_31_VALIDATOR, SWAGGER_20_VALIDATOR
 from .examples import get_strategies_from_examples
-from .filters import (
-    should_skip_by_operation_id,
-    should_skip_by_tag,
-    should_skip_deprecated,
-    should_skip_endpoint,
-    should_skip_method,
-)
 from .parameters import (
     OpenAPI20Body,
     OpenAPI20CompositeBody,
@@ -74,12 +67,23 @@ from .parameters import (
     OpenAPI30Parameter,
     OpenAPIParameter,
 )
-from .references import RECURSION_DEPTH_LIMIT, ConvertingResolver, InliningResolver, resolve_pointer, UNRESOLVABLE
+from .references import (
+    RECURSION_DEPTH_LIMIT,
+    UNRESOLVABLE,
+    ConvertingResolver,
+    InliningResolver,
+    resolve_pointer,
+)
 from .security import BaseSecurityProcessor, OpenAPISecurityProcessor, SwaggerSecurityProcessor
 from .stateful import create_state_machine
 
 if TYPE_CHECKING:
+    from hypothesis.strategies import SearchStrategy
+
+    from ...auths import AuthStorage
+    from ...stateful.state_machine import APIStateMachine
     from ...transports.responses import GenericResponse
+    from ...types import Body, Cookies, FormData, GenericTest, Headers, NotSet, PathParameters, Query
 
 SCHEMA_ERROR_MESSAGE = "Ensure that the definition complies with the OpenAPI specification"
 SCHEMA_PARSING_ERRORS = (KeyError, AttributeError, jsonschema.exceptions.RefResolutionError)
@@ -91,12 +95,11 @@ 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)
+    _operation_cache: OperationCache = field(default_factory=OperationCache)
     _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)
-    _override: CaseOverride | None = field(default=None)
     component_locations: ClassVar[tuple[tuple[str, ...], ...]] = ()
 
     @property
@@ -114,13 +117,24 @@ class BaseOpenAPISchema(BaseSchema):
         info = self.raw_schema["info"]
         return f"<{self.__class__.__name__} for {info['title']} {info['version']}>"
 
-    def _store_operations(
-        self, operations: Generator[Result[APIOperation, OperationSchemaError], None, None]
-    ) -> dict[str, APIOperationMap]:
-        return operations_to_dict(operations)
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.raw_schema.get("paths", {}))
+
+    def _get_operation_map(self, path: str) -> APIOperationMap:
+        cache = self._operation_cache
+        map = cache.get_map(path)
+        if map is not None:
+            return map
+        path_item = self.raw_schema.get("paths", {})[path]
+        scope, path_item = self._resolve_path_item(path_item)
+        self.dispatch_hook("before_process_path", HookContext(), path, path_item)
+        map = APIOperationMap(self, {})
+        map._data = MethodMap(map, scope, path, CaseInsensitiveDict(path_item))
+        cache.insert_map(path, map)
+        return map
 
     def on_missing_operation(self, item: str, exc: KeyError) -> NoReturn:
-        matches = get_close_matches(item, list(self.operations))
+        matches = get_close_matches(item, list(self))
         self._on_missing_operation(item, exc, matches)
 
     def _on_missing_operation(self, item: str, exc: KeyError, matches: list[str]) -> NoReturn:
@@ -129,14 +143,35 @@ class BaseOpenAPISchema(BaseSchema):
             message += f". Did you mean `{matches[0]}`?"
         raise OperationNotFound(message=message, item=item) from exc
 
-    def _should_skip(self, method: str, definition: dict[str, Any]) -> bool:
-        return (
-            method not in HTTP_METHODS
-            or should_skip_method(method, self.method)
-            or should_skip_deprecated(definition.get("deprecated", False), self.skip_deprecated_operations)
-            or should_skip_by_tag(definition.get("tags"), self.tag)
-            or should_skip_by_operation_id(definition.get("operationId"), self.operation_id)
-        )
+    def _should_skip(
+        self,
+        path: str,
+        method: str,
+        definition: dict[str, Any],
+        _ctx_cache: SimpleNamespace = SimpleNamespace(
+            operation=APIOperation(
+                method="",
+                path="",
+                verbose_name="",
+                definition=OperationDefinition(raw=None, resolved=None, scope=""),
+                schema=None,  # type: ignore
+            )
+        ),
+    ) -> bool:
+        if method not in HTTP_METHODS:
+            return True
+        if self.filter_set.is_empty():
+            return False
+        path = self.get_full_path(path)
+        # Attribute assignment is way faster than creating a new namespace every time
+        operation = _ctx_cache.operation
+        operation.method = method
+        operation.path = path
+        operation.verbose_name = f"{method.upper()} {path}"
+        operation.definition.raw = definition
+        operation.definition.resolved = definition
+        operation.schema = self
+        return not self.filter_set.match(_ctx_cache)
 
     def _operation_iter(self) -> Generator[dict[str, Any], None, None]:
         try:
@@ -144,18 +179,14 @@ class BaseOpenAPISchema(BaseSchema):
         except KeyError:
             return
         resolve = self.resolver.resolve
-        for path, methods in paths.items():
-            full_path = self.get_full_path(path)
-            if should_skip_endpoint(full_path, self.endpoint):
-                continue
+        should_skip = self._should_skip
+        for path, path_item in paths.items():
             try:
-                if "$ref" in methods:
-                    _, resolved_methods = resolve(methods["$ref"])
-                else:
-                    resolved_methods = methods
+                if "$ref" in path_item:
+                    _, path_item = resolve(path_item["$ref"])
                 # Straightforward iteration is faster than converting to a set & calculating length.
-                for method, definition in resolved_methods.items():
-                    if self._should_skip(method, definition):
+                for method, definition in path_item.items():
+                    if should_skip(path, method, definition):
                         continue
                     yield definition
             except SCHEMA_PARSING_ERRORS:
@@ -173,11 +204,13 @@ class BaseOpenAPISchema(BaseSchema):
     @property
     def links_count(self) -> int:
         total = 0
+        resolve = self.resolver.resolve
+        links_field = self.links_field
         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)
+                    _, response = resolve(response["$ref"])
+                defined_links = response.get(links_field)
                 if defined_links is not None:
                     total += len(defined_links)
         return total
@@ -202,8 +235,26 @@ class BaseOpenAPISchema(BaseSchema):
 
         return _add_override
 
+    def _resolve_until_no_references(self, value: dict[str, Any]) -> dict[str, Any]:
+        while "$ref" in value:
+            _, value = self.resolver.resolve(value["$ref"])
+        return value
+
+    def _resolve_shared_parameters(self, path_item: Mapping[str, Any]) -> list[dict[str, Any]]:
+        return self.resolver.resolve_all(path_item.get("parameters", []), RECURSION_DEPTH_LIMIT - 8)
+
+    def _resolve_operation(self, operation: dict[str, Any]) -> dict[str, Any]:
+        return self.resolver.resolve_all(operation, RECURSION_DEPTH_LIMIT - 8)
+
+    def _collect_operation_parameters(
+        self, path_item: Mapping[str, Any], operation: dict[str, Any]
+    ) -> list[OpenAPIParameter]:
+        shared_parameters = self._resolve_shared_parameters(path_item)
+        parameters = operation.get("parameters", ())
+        return self.collect_parameters(itertools.chain(parameters, shared_parameters), operation)
+
     def get_all_operations(
-        self, hooks: HookDispatcher | None = None
+        self, hooks: HookDispatcher | None = None, generation_config: GenerationConfig | None = None
     ) -> Generator[Result[APIOperation, OperationSchemaError], None, None]:
         """Iterate over all operations defined in the API.
 
@@ -231,47 +282,52 @@ class BaseOpenAPISchema(BaseSchema):
             self._raise_invalid_schema(exc)
 
         context = HookContext()
-        for path, methods in paths.items():
+        # Optimization: local variables are faster than attribute access
+        dispatch_hook = self.dispatch_hook
+        resolve_path_item = self._resolve_path_item
+        resolve_shared_parameters = self._resolve_shared_parameters
+        resolve_operation = self._resolve_operation
+        should_skip = self._should_skip
+        collect_parameters = self.collect_parameters
+        make_operation = self.make_operation
+        hooks = self.hooks
+        for path, path_item in paths.items():
             method = None
             try:
-                full_path = self.get_full_path(path)  # Should be available for later use
-                if should_skip_endpoint(full_path, self.endpoint):
-                    continue
-                self.dispatch_hook("before_process_path", context, path, methods)
-                scope, raw_methods = self._resolve_methods(methods)
-                common_parameters = self.resolver.resolve_all(methods.get("parameters", []), RECURSION_DEPTH_LIMIT - 8)
-                for method, definition in raw_methods.items():
-                    try:
-                        # Setting a low recursion limit doesn't solve the problem with recursive references & inlining
-                        # too much but decreases the number of cases when Schemathesis stuck on this step.
-                        self.resolver.push_scope(scope)
-                        try:
-                            resolved_definition = self.resolver.resolve_all(definition, RECURSION_DEPTH_LIMIT - 8)
-                        finally:
-                            self.resolver.pop_scope()
-                        # Only method definitions are parsed
-                        if self._should_skip(method, resolved_definition):
+                dispatch_hook("before_process_path", context, path, path_item)
+                scope, path_item = resolve_path_item(path_item)
+                with in_scope(self.resolver, scope):
+                    shared_parameters = resolve_shared_parameters(path_item)
+                    for method, entry in path_item.items():
+                        if method not in HTTP_METHODS:
                             continue
-                        parameters = self.collect_parameters(
-                            itertools.chain(resolved_definition.get("parameters", ()), common_parameters),
-                            resolved_definition,
-                        )
-                        # To prevent recursion errors we need to pass not resolved schema as well
-                        # It could be used for response validation
-                        raw_definition = OperationDefinition(
-                            raw_methods[method], resolved_definition, scope, parameters
-                        )
-                        operation = self.make_operation(path, method, parameters, raw_definition)
-                        context = HookContext(operation=operation)
-                        if (
-                            should_skip_operation(GLOBAL_HOOK_DISPATCHER, context)
-                            or should_skip_operation(self.hooks, context)
-                            or (hooks and should_skip_operation(hooks, context))
-                        ):
-                            continue
-                        yield Ok(operation)
-                    except SCHEMA_PARSING_ERRORS as exc:
-                        yield self._into_err(exc, path, method)
+                        try:
+                            resolved = resolve_operation(entry)
+                            if should_skip(path, method, resolved):
+                                continue
+                            parameters = resolved.get("parameters", ())
+                            parameters = collect_parameters(itertools.chain(parameters, shared_parameters), resolved)
+                            operation = make_operation(
+                                path,
+                                method,
+                                parameters,
+                                entry,
+                                resolved,
+                                scope,
+                                with_security_parameters=generation_config.with_security_parameters
+                                if generation_config
+                                else None,
+                            )
+                            context = HookContext(operation=operation)
+                            if (
+                                should_skip_operation(GLOBAL_HOOK_DISPATCHER, context)
+                                or should_skip_operation(hooks, context)
+                                or (hooks and should_skip_operation(hooks, context))
+                            ):
+                                continue
+                            yield Ok(operation)
+                        except SCHEMA_PARSING_ERRORS as exc:
+                            yield self._into_err(exc, path, method)
             except SCHEMA_PARSING_ERRORS as exc:
                 yield self._into_err(exc, path, method)
 
@@ -320,20 +376,23 @@ class BaseOpenAPISchema(BaseSchema):
         """
         raise NotImplementedError
 
-    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
+    def _resolve_path_item(self, methods: dict[str, Any]) -> tuple[str, dict[str, Any]]:
+        # The path item could be behind a reference
+        # In this case, we need to resolve it to get the proper scope for reference inside the item.
+        # It is mostly for validating responses.
         if "$ref" in methods:
-            return fast_deepcopy(self.resolver.resolve(methods["$ref"]))
-        return self.resolver.resolution_scope, fast_deepcopy(methods)
+            return self.resolver.resolve(methods["$ref"])
+        return self.resolver.resolution_scope, methods
 
     def make_operation(
         self,
         path: str,
         method: str,
         parameters: list[OpenAPIParameter],
-        raw_definition: OperationDefinition,
+        raw: dict[str, Any],
+        resolved: dict[str, Any],
+        scope: str,
+        with_security_parameters: bool | None = None,
     ) -> APIOperation:
         """Create JSON schemas for the query, body, etc from Swagger parameters definitions."""
         __tracebackhide__ = True
@@ -341,14 +400,20 @@ class BaseOpenAPISchema(BaseSchema):
         operation: APIOperation[OpenAPIParameter, Case] = APIOperation(
             path=path,
             method=method,
-            definition=raw_definition,
+            definition=OperationDefinition(raw, resolved, scope),
             base_url=base_url,
             app=self.app,
             schema=self,
         )
         for parameter in parameters:
             operation.add_parameter(parameter)
-        self.security.process_definitions(self.raw_schema, operation, self.resolver)
+        with_security_parameters = (
+            with_security_parameters
+            if with_security_parameters is not None
+            else self.generation_config.with_security_parameters
+        )
+        if with_security_parameters:
+            self.security.process_definitions(self.raw_schema, operation, self.resolver)
         self.dispatch_hook("before_init_operation", HookContext(operation=operation), operation)
         return operation
 
@@ -362,7 +427,9 @@ class BaseOpenAPISchema(BaseSchema):
         """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, as_strategy_kwargs: dict[str, Any] | None = None
+    ) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
         raise NotImplementedError
 
@@ -376,49 +443,78 @@ class BaseOpenAPISchema(BaseSchema):
 
     def get_operation_by_id(self, operation_id: str) -> APIOperation:
         """Get an `APIOperation` instance by its `operationId`."""
-        if not hasattr(self, "_operations_by_id"):
-            self._operations_by_id = dict(self._group_operations_by_id())
+        cache = self._operation_cache
+        cached = cache.get_operation_by_id(operation_id)
+        if cached is not None:
+            return cached
+        # Operation has not been accessed yet, need to populate the cache
+        if not cache.has_ids_to_definitions:
+            self._populate_operation_id_cache(cache)
         try:
-            return self._operations_by_id[operation_id]
+            entry = cache.get_definition_by_id(operation_id)
         except KeyError as exc:
-            matches = get_close_matches(operation_id, list(self._operations_by_id))
+            matches = get_close_matches(operation_id, cache.known_operation_ids)
             self._on_missing_operation(operation_id, exc, matches)
-
-    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)
-            for method, definition in methods.items():
-                if method not in HTTP_METHODS or "operationId" not in definition:
+        # It could've been already accessed in a different place
+        traversal_key = (entry.scope, entry.path, entry.method)
+        instance = cache.get_operation_by_traversal_key(traversal_key)
+        if instance is not None:
+            return instance
+        resolved = self._resolve_operation(entry.operation)
+        parameters = self._collect_operation_parameters(entry.path_item, resolved)
+        initialized = self.make_operation(entry.path, entry.method, parameters, entry.operation, resolved, entry.scope)
+        cache.insert_operation(initialized, traversal_key=traversal_key, operation_id=operation_id)
+        return initialized
+
+    def _populate_operation_id_cache(self, cache: OperationCache) -> None:
+        """Collect all operation IDs from the schema."""
+        resolve = self.resolver.resolve
+        default_scope = self.resolver.resolution_scope
+        for path, path_item in self.raw_schema.get("paths", {}).items():
+            # If the path is behind a reference we have to keep the scope
+            # The scope is used to resolve nested components later on
+            if "$ref" in path_item:
+                scope, path_item = resolve(path_item["$ref"])
+            else:
+                scope = default_scope
+            for key, entry in path_item.items():
+                if key not in HTTP_METHODS:
                     continue
-                self.resolver.push_scope(scope)
-                try:
-                    resolved_definition = self.resolver.resolve_all(definition, RECURSION_DEPTH_LIMIT - 8)
-                finally:
-                    self.resolver.pop_scope()
-                parameters = self.collect_parameters(
-                    itertools.chain(resolved_definition.get("parameters", ()), common_parameters), resolved_definition
-                )
-                raw_definition = OperationDefinition(raw_methods[method], resolved_definition, scope, parameters)
-                yield resolved_definition["operationId"], self.make_operation(path, method, parameters, raw_definition)
+                if "operationId" in entry:
+                    cache.insert_definition_by_id(
+                        entry["operationId"],
+                        path=path,
+                        method=key,
+                        scope=scope,
+                        path_item=path_item,
+                        operation=entry,
+                    )
 
     def get_operation_by_reference(self, reference: str) -> APIOperation:
         """Get local or external `APIOperation` instance by reference.
 
         Reference example: #/paths/~1users~1{user_id}/patch
         """
-        scope, data = self.resolver.resolve(reference)
+        cache = self._operation_cache
+        cached = cache.get_operation_by_reference(reference)
+        if cached is not None:
+            return cached
+        scope, operation = self.resolver.resolve(reference)
         path, method = scope.rsplit("/", maxsplit=2)[-2:]
         path = path.replace("~1", "/").replace("~0", "~")
-        resolved_definition = self.resolver.resolve_all(data)
+        # Check the traversal cache as it could've been populated in other places
+        traversal_key = (self.resolver.resolution_scope, path, method)
+        cached = cache.get_operation_by_traversal_key(traversal_key)
+        if cached is not None:
+            return cached
+        with in_scope(self.resolver, scope):
+            resolved = self._resolve_operation(operation)
         parent_ref, _ = reference.rsplit("/", maxsplit=1)
-        _, methods = self.resolver.resolve(parent_ref)
-        common_parameters = self.resolver.resolve_all(methods.get("parameters", []), RECURSION_DEPTH_LIMIT - 8)
-        parameters = self.collect_parameters(
-            itertools.chain(resolved_definition.get("parameters", ()), common_parameters), resolved_definition
-        )
-        raw_definition = OperationDefinition(data, resolved_definition, scope, parameters)
-        return self.make_operation(path, method, parameters, raw_definition)
+        _, path_item = self.resolver.resolve(parent_ref)
+        parameters = self._collect_operation_parameters(path_item, resolved)
+        initialized = self.make_operation(path, method, parameters, operation, resolved, scope)
+        cache.insert_operation(initialized, traversal_key=traversal_key, reference=reference)
+        return initialized
 
     def get_case_strategy(
         self,
@@ -439,13 +535,14 @@ class BaseOpenAPISchema(BaseSchema):
         )
 
     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
-        )
-        security_parameters = [item for item in security_parameters if item["in"] == location]
-        if security_parameters:
-            definitions.extend(security_parameters)
+        definitions = [item.definition for item in operation.iter_parameters() if item.location == location]
+        if self.generation_config.with_security_parameters:
+            security_parameters = self.security.get_security_definitions_as_parameters(
+                self.raw_schema, operation, self.resolver, location
+            )
+            security_parameters = [item for item in security_parameters if item["in"] == location]
+            if security_parameters:
+                definitions.extend(security_parameters)
         if definitions:
             return self._get_parameter_serializer(definitions)
         return None
@@ -453,9 +550,11 @@ class BaseOpenAPISchema(BaseSchema):
     def _get_parameter_serializer(self, definitions: list[dict[str, Any]]) -> Callable | None:
         raise NotImplementedError
 
-    def _get_response_definitions(self, operation: APIOperation, response: GenericResponse) -> dict[str, Any] | None:
+    def _get_response_definitions(
+        self, operation: APIOperation, response: GenericResponse
+    ) -> tuple[list[str], dict[str, Any]] | None:
         try:
-            responses = operation.definition.resolved["responses"]
+            responses = operation.definition.raw["responses"]
         except KeyError as exc:
             # Possible to get if `validate_schema=False` is passed during schema creation
             path = operation.path
@@ -463,16 +562,19 @@ class BaseOpenAPISchema(BaseSchema):
             self._raise_invalid_schema(exc, full_path, path, operation.method)
         status_code = str(response.status_code)
         if status_code in responses:
-            return responses[status_code]
+            return self.resolver.resolve_in_scope(responses[status_code], operation.definition.scope)
         if "default" in responses:
-            return responses["default"]
+            return self.resolver.resolve_in_scope(responses["default"], operation.definition.scope)
         return None
 
-    def get_headers(self, operation: APIOperation, response: GenericResponse) -> dict[str, dict[str, Any]] | None:
-        definitions = self._get_response_definitions(operation, response)
-        if not definitions:
+    def get_headers(
+        self, operation: APIOperation, response: GenericResponse
+    ) -> tuple[list[str], dict[str, dict[str, Any]] | None] | None:
+        resolved = self._get_response_definitions(operation, response)
+        if not resolved:
             return None
-        return definitions.get("headers")
+        scopes, definitions = resolved
+        return scopes, definitions.get("headers")
 
     def as_state_machine(self) -> type[APIStateMachine]:
         try:
@@ -518,46 +620,16 @@ class BaseOpenAPISchema(BaseSchema):
         """
         if parameters is None and request_body is None:
             raise ValueError("You need to provide `parameters` or `request_body`.")
-        if hasattr(self, "_operations"):
-            delattr(self, "_operations")
-        for operation, methods in self.raw_schema["paths"].items():
-            if operation == source.path:
-                # Methods should be completely resolved now, otherwise they might miss a resolving scope when
-                # they will be fully resolved later
-                methods = self.resolver.resolve_all(methods)
-                found = False
-                for method, definition in methods.items():
-                    if method.upper() == source.method.upper():
-                        found = True
-                        links.add_link(
-                            responses=definition["responses"],
-                            links_field=self.links_field,
-                            parameters=parameters,
-                            request_body=request_body,
-                            status_code=status_code,
-                            target=target,
-                            name=name,
-                        )
-                    # If methods are behind a reference, then on the next resolving they will miss the new link
-                    # Therefore we need to modify it this way
-                    self.raw_schema["paths"][operation][method] = definition
-                # The reference should be removed completely, otherwise new keys in this dictionary will be ignored
-                # due to the `$ref` keyword behavior
-                self.raw_schema["paths"][operation].pop("$ref", None)
-                if found:
-                    return
-        name = f"{source.method.upper()} {source.path}"
-        # Use a name without basePath, as the user doesn't use it.
-        # E.g. `source=schema["/users/"]["POST"]` without a prefix
-        message = f"No such API operation: `{name}`."
-        possibilities = [
-            f"{op.ok().method.upper()} {op.ok().path}" for op in self.get_all_operations() if isinstance(op, Ok)
-        ]
-        matches = get_close_matches(name, possibilities)
-        if matches:
-            message += f" Did you mean `{matches[0]}`?"
-        message += " Check if the requested API operation passes the filters in the schema."
-        raise ValueError(message)
+        links.add_link(
+            resolver=self.resolver,
+            responses=self[source.path][source.method].definition.raw["responses"],
+            links_field=self.links_field,
+            parameters=parameters,
+            request_body=request_body,
+            status_code=status_code,
+            target=target,
+            name=name,
+        )
 
     def get_links(self, operation: APIOperation) -> dict[str, dict[str, Any]]:
         result: dict[str, dict[str, Any]] = defaultdict(dict)
@@ -566,7 +638,13 @@ class BaseOpenAPISchema(BaseSchema):
         return result
 
     def get_tags(self, operation: APIOperation) -> list[str] | None:
-        return operation.definition.resolved.get("tags")
+        return operation.definition.raw.get("tags")
+
+    @property
+    def validator_cls(self) -> type[jsonschema.Validator]:
+        if self.spec_version.startswith("3.1") and experimental.OPEN_API_3_1.is_enabled:
+            return jsonschema.Draft202012Validator
+        return jsonschema.Draft4Validator
 
     def validate_response(self, operation: APIOperation, response: GenericResponse) -> bool | None:
         responses = {str(key): value for key, value in operation.definition.raw.get("responses", {}).items()}
@@ -589,7 +667,7 @@ class BaseOpenAPISchema(BaseSchema):
             formatted_content_types = [f"\n- `{content_type}`" for content_type in media_types]
             message = f"The following media types are documented in the schema:{''.join(formatted_content_types)}"
             try:
-                raise get_missing_content_type_error()(
+                raise get_missing_content_type_error(operation.verbose_name)(
                     failures.MissingContentType.title,
                     context=failures.MissingContentType(message=message, media_types=media_types),
                 )
@@ -601,26 +679,26 @@ class BaseOpenAPISchema(BaseSchema):
         try:
             data = get_json(response)
         except JSONDecodeError as exc:
-            exc_class = get_response_parsing_error(exc)
+            exc_class = get_response_parsing_error(operation.verbose_name, exc)
             context = failures.JSONDecodeErrorContext.from_exception(exc)
             try:
                 raise exc_class(context.title, context=context) from exc
             except Exception as exc:
                 errors.append(exc)
                 _maybe_raise_one_or_more(errors)
-        resolver = ConvertingResolver(
-            self.location or "", self.raw_schema, nullable_name=self.nullable_name, is_response_schema=True
-        )
-        if self.spec_version.startswith("3.1") and experimental.OPEN_API_3_1.is_enabled:
-            cls = jsonschema.Draft202012Validator
-        else:
-            cls = jsonschema.Draft4Validator
-        with in_scopes(resolver, scopes):
+        with self._validating_response(scopes) as resolver:
             try:
-                jsonschema.validate(data, schema, cls=cls, resolver=resolver)
+                jsonschema.validate(
+                    data,
+                    schema,
+                    cls=self.validator_cls,
+                    resolver=resolver,
+                    # Use a recent JSON Schema format checker to get most of formats checked for older drafts as well
+                    format_checker=jsonschema.Draft202012Validator.FORMAT_CHECKER,
+                )
             except jsonschema.ValidationError as exc:
-                exc_class = get_schema_validation_error(exc)
-                ctx = failures.ValidationErrorContext.from_exception(exc)
+                exc_class = get_schema_validation_error(operation.verbose_name, exc)
+                ctx = failures.ValidationErrorContext.from_exception(exc, output_config=operation.schema.output_config)
                 try:
                     raise exc_class(ctx.title, context=ctx) from exc
                 except Exception as exc:
@@ -628,6 +706,14 @@ class BaseOpenAPISchema(BaseSchema):
         _maybe_raise_one_or_more(errors)
         return None  # explicitly return None for mypy
 
+    @contextmanager
+    def _validating_response(self, scopes: list[str]) -> Generator[ConvertingResolver, None, None]:
+        resolver = ConvertingResolver(
+            self.location or "", self.raw_schema, nullable_name=self.nullable_name, is_response_schema=True
+        )
+        with in_scopes(resolver, scopes):
+            yield resolver
+
     @property
     def rewritten_components(self) -> dict[str, Any]:
         if not hasattr(self, "_rewritten_components"):
@@ -721,10 +807,9 @@ class BaseOpenAPISchema(BaseSchema):
 def _maybe_raise_one_or_more(errors: list[Exception]) -> None:
     if not errors:
         return
-    elif len(errors) == 1:
+    if len(errors) == 1:
         raise errors[0]
-    else:
-        raise MultipleFailures("\n\n".join(str(error) for error in errors), errors)
+    raise MultipleFailures("\n\n".join(str(error) for error in errors), errors)
 
 
 def _make_reference_key(scopes: list[str], reference: str) -> str:
@@ -766,30 +851,58 @@ def in_scopes(resolver: jsonschema.RefResolver, scopes: list[str]) -> Generator[
         yield
 
 
-def operations_to_dict(
-    operations: Generator[Result[APIOperation, OperationSchemaError], None, None],
-) -> dict[str, APIOperationMap]:
-    output: dict[str, APIOperationMap] = {}
-    for result in operations:
-        if isinstance(result, Ok):
-            operation = result.ok()
-            output.setdefault(operation.path, APIOperationMap(MethodMap()))
-            output[operation.path][operation.method] = operation
-    return output
-
-
-class MethodMap(CaseInsensitiveDict):
+@dataclass
+class MethodMap(Mapping):
     """Container for accessing API operations.
 
     Provides a more specific error message if API operation is not found.
     """
 
+    _parent: APIOperationMap
+    # Reference resolution scope
+    _scope: str
+    # Methods are stored for this path
+    _path: str
+    # Storage for definitions
+    _path_item: CaseInsensitiveDict
+
+    __slots__ = ("_parent", "_scope", "_path", "_path_item")
+
+    def __len__(self) -> int:
+        return len(self._path_item)
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._path_item)
+
+    def _init_operation(self, method: str) -> APIOperation:
+        method = method.lower()
+        operation = self._path_item[method]
+        schema = cast(BaseOpenAPISchema, self._parent._schema)
+        cache = schema._operation_cache
+        path = self._path
+        scope = self._scope
+        traversal_key = (scope, path, method)
+        cached = cache.get_operation_by_traversal_key(traversal_key)
+        if cached is not None:
+            return cached
+        schema.resolver.push_scope(scope)
+        try:
+            resolved = schema._resolve_operation(operation)
+        finally:
+            schema.resolver.pop_scope()
+        parameters = schema._collect_operation_parameters(self._path_item, resolved)
+        initialized = schema.make_operation(path, method, parameters, operation, resolved, scope)
+        cache.insert_operation(initialized, traversal_key=traversal_key, operation_id=resolved.get("operationId"))
+        return initialized
+
     def __getitem__(self, item: str) -> APIOperation:
         try:
-            return super().__getitem__(item)
+            return self._init_operation(item)
         except KeyError as exc:
             available_methods = ", ".join(map(str.upper, self))
-            message = f"Method `{item}` not found. Available methods: {available_methods}"
+            message = f"Method `{item.upper()}` not found."
+            if available_methods:
+                message += f" Available methods: {available_methods}"
             raise KeyError(message) from exc
 
 
@@ -859,18 +972,22 @@ class SwaggerV20(BaseOpenAPISchema):
                 )
         return collected
 
-    def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
+    def get_strategies_from_examples(
+        self, operation: APIOperation, as_strategy_kwargs: dict[str, Any] | None = None
+    ) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
-        return get_strategies_from_examples(operation, self.examples_field)
+        return get_strategies_from_examples(operation, as_strategy_kwargs=as_strategy_kwargs)
 
     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)
+        scopes, definition = self.resolver.resolve_in_scope(definition, scope)
         schema = definition.get("schema")
         if not schema:
             return scopes, None
         # Extra conversion to JSON Schema is needed here if there was one $ref in the input
         # because it is not converted
-        return scopes, to_json_schema_recursive(schema, self.nullable_name, is_response_schema=True)
+        return scopes, to_json_schema_recursive(
+            schema, self.nullable_name, is_response_schema=True, update_quantifiers=False
+        )
 
     def get_content_types(self, operation: APIOperation, response: GenericResponse) -> list[str]:
         produces = operation.definition.raw.get("produces", None)
@@ -903,7 +1020,7 @@ class SwaggerV20(BaseOpenAPISchema):
             else:
                 files.append((name, file_value))
 
-        for parameter in operation.definition.parameters:
+        for parameter in operation.body:
             if isinstance(parameter, OpenAPI20CompositeBody):
                 for form_parameter in parameter.definition:
                     name = form_parameter.name
@@ -918,7 +1035,7 @@ class SwaggerV20(BaseOpenAPISchema):
         return files or None, data or None
 
     def get_request_payload_content_types(self, operation: APIOperation) -> list[str]:
-        return self._get_consumes_for_operation(operation.definition.resolved)
+        return self._get_consumes_for_operation(operation.definition.raw)
 
     def make_case(
         self,
@@ -931,20 +1048,10 @@ class SwaggerV20(BaseOpenAPISchema):
         query: Query | None = None,
         body: Body | NotSet = NOT_SET,
         media_type: str | None = None,
+        generation_time: float = 0.0,
     ) -> 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
-            media_types = operation.get_request_payload_content_types()
-            if len(media_types) == 1:
-                # The only available option
-                media_type = media_types[0]
-            else:
-                media_types_repr = ", ".join(media_types)
-                raise UsageError(
-                    "Can not detect appropriate media type. "
-                    "You can either specify one of the defined media types "
-                    f"or pass any other media type available for serialization. Defined media types: {media_types_repr}"
-                )
+            media_type = operation._get_default_media_type()
         return case_cls(
             operation=operation,
             path_parameters=path_parameters,
@@ -953,6 +1060,7 @@ class SwaggerV20(BaseOpenAPISchema):
             query=query,
             body=body,
             media_type=media_type,
+            generation_time=generation_time,
         )
 
     def _get_consumes_for_operation(self, definition: dict[str, Any]) -> list[str]:
@@ -1023,31 +1131,37 @@ class OpenApi30(SwaggerV20):
         return collected
 
     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)
+        scopes, definition = self.resolver.resolve_in_scope(definition, scope)
         options = iter(definition.get("content", {}).values())
         option = next(options, None)
         # "schema" is an optional key in the `MediaType` object
         if option and "schema" in option:
             # Extra conversion to JSON Schema is needed here if there was one $ref in the input
             # because it is not converted
-            return scopes, to_json_schema_recursive(option["schema"], self.nullable_name, is_response_schema=True)
+            return scopes, to_json_schema_recursive(
+                option["schema"], self.nullable_name, is_response_schema=True, update_quantifiers=False
+            )
         return scopes, None
 
-    def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
+    def get_strategies_from_examples(
+        self, operation: APIOperation, as_strategy_kwargs: dict[str, Any] | None = None
+    ) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
-        return get_strategies_from_examples(operation, self.examples_field)
+        return get_strategies_from_examples(operation, as_strategy_kwargs=as_strategy_kwargs)
 
     def get_content_types(self, operation: APIOperation, response: GenericResponse) -> list[str]:
-        definitions = self._get_response_definitions(operation, response)
-        if not definitions:
+        resolved = self._get_response_definitions(operation, response)
+        if not resolved:
             return []
+        _, definitions = resolved
         return list(definitions.get("content", {}).keys())
 
     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]:
-        return list(operation.definition.resolved["requestBody"]["content"].keys())
+        request_body = self._resolve_until_no_references(operation.definition.raw["requestBody"])
+        return list(request_body["content"])
 
     def prepare_multipart(
         self, form_data: FormData, operation: APIOperation
@@ -1059,17 +1173,22 @@ class OpenApi30(SwaggerV20):
         :return: `files` and `data` values for `requests.request`.
         """
         files = []
-        content = operation.definition.resolved["requestBody"]["content"]
+        definition = operation.definition.raw
+        if "$ref" in definition["requestBody"]:
+            body = self.resolver.resolve_all(definition["requestBody"], RECURSION_DEPTH_LIMIT)
+        else:
+            body = definition["requestBody"]
+        content = body["content"]
         # Open API 3.0 requires media types to be present. We can get here only if the schema defines
         # the "multipart/form-data" media type, or any other more general media type that matches it (like `*/*`)
         for media_type, entry in content.items():
             main, sub = parse_content_type(media_type)
-            if main in ("*", "multipart") and sub in ("*", "form-data"):
-                schema = entry["schema"]
+            if main in ("*", "multipart") and sub in ("*", "form-data", "mixed"):
+                schema = entry.get("schema")
                 break
         else:
             raise InternalError("No 'multipart/form-data' media type found in the schema")
-        for name, property_schema in schema.get("properties", {}).items():
+        for name, property_schema in (schema or {}).get("properties", {}).items():
             if name in form_data:
                 if isinstance(form_data[name], list):
                     files.extend([(name, item) for item in form_data[name]])