schemathesis 3.25.6__py3-none-any.whl → 4.0.0a1__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,41 @@ 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.exceptions import InvalidHeader
 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 ...constants import HTTP_METHODS, NOT_SET
-from ...exceptions import (
-    InternalError,
-    OperationSchemaError,
-    UsageError,
-    get_missing_content_type_error,
-    get_response_parsing_error,
-    get_schema_validation_error,
-    SchemaError,
-    SchemaErrorType,
-    OperationNotFound,
-)
-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 ...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 requests.utils import check_header_validity
+
+from schemathesis.core import NOT_SET, NotSet, Specification, media_types
+from schemathesis.core.compat import RefResolutionError
+from schemathesis.core.errors import InternalError, InvalidSchema, LoaderError, LoaderErrorKind, OperationNotFound
+from schemathesis.core.failures import Failure, FailureGroup, MalformedJson
+from schemathesis.core.result import Err, Ok, Result
+from schemathesis.core.transforms import UNRESOLVABLE, deepclone, resolve_pointer, transform
+from schemathesis.core.transport import Response
+from schemathesis.core.validation import INVALID_HEADER_RE
+from schemathesis.generation.case import Case
+from schemathesis.generation.meta import CaseMetadata
+from schemathesis.generation.overrides import Override, OverrideMark, check_no_override_mark
+from schemathesis.openapi.checks import JsonSchemaError, MissingContentType
+
+from ...generation import GenerationConfig, GenerationMode
+from ...hooks import HookContext, HookDispatcher
+from ...schemas import APIOperation, APIOperationMap, ApiOperationsCount, BaseSchema, OperationDefinition
 from . import links, serialization
-from ._hypothesis import get_case_strategy
+from ._cache import OperationCache
+from ._hypothesis import openapi_cases
 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,15 +59,34 @@ from .parameters import (
     OpenAPI30Parameter,
     OpenAPIParameter,
 )
-from .references import RECURSION_DEPTH_LIMIT, ConvertingResolver, InliningResolver, resolve_pointer, UNRESOLVABLE
+from .references import RECURSION_DEPTH_LIMIT, ConvertingResolver, InliningResolver
 from .security import BaseSecurityProcessor, OpenAPISecurityProcessor, SwaggerSecurityProcessor
 from .stateful import create_state_machine
 
 if TYPE_CHECKING:
-    from ...transports.responses import GenericResponse
+    from hypothesis.strategies import SearchStrategy
 
+    from ...auths import AuthStorage
+    from ...stateful.state_machine import APIStateMachine
+
+HTTP_METHODS = frozenset({"get", "put", "post", "delete", "options", "head", "patch", "trace"})
 SCHEMA_ERROR_MESSAGE = "Ensure that the definition complies with the OpenAPI specification"
-SCHEMA_PARSING_ERRORS = (KeyError, AttributeError, jsonschema.exceptions.RefResolutionError)
+SCHEMA_PARSING_ERRORS = (KeyError, AttributeError, RefResolutionError, InvalidSchema)
+
+
+def check_header(parameter: dict[str, Any]) -> None:
+    name = parameter["name"]
+    if not name:
+        raise InvalidSchema("Header name should not be empty")
+    if not name.isascii():
+        # `urllib3` encodes header names to ASCII
+        raise InvalidSchema(f"Header name should be ASCII: {name}")
+    try:
+        check_header_validity((name, ""))
+    except InvalidHeader as exc:
+        raise InvalidSchema(str(exc)) from None
+    if bool(INVALID_HEADER_RE.search(name)):
+        raise InvalidSchema(f"Invalid header name: {name}")
 
 
 @dataclass(eq=False, repr=False)
@@ -91,36 +95,39 @@ 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
-    def spec_version(self) -> str:
+    def specification(self) -> Specification:
         raise NotImplementedError
 
-    def get_stateful_tests(
-        self, response: GenericResponse, operation: APIOperation, stateful: Stateful | None
-    ) -> Sequence[StatefulTest]:
-        if stateful == Stateful.links:
-            return links.get_links(response, operation, field=self.links_field)
-        return []
-
     def __repr__(self) -> str:
         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 +136,59 @@ 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="",
+                label="",
+                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.label = f"{method.upper()} {path}"
+        operation.definition.raw = definition
+        operation.definition.resolved = definition
+        operation.schema = self
+        return not self.filter_set.match(_ctx_cache)
+
+    def _do_count_operations(self) -> ApiOperationsCount:
+        counter = ApiOperationsCount()
+        try:
+            paths = self.raw_schema["paths"]
+        except KeyError:
+            return counter
+
+        resolve = self.resolver.resolve
+        should_skip = self._should_skip
+
+        for path, path_item in paths.items():
+            try:
+                if "$ref" in path_item:
+                    _, path_item = resolve(path_item["$ref"])
+                for method, definition in path_item.items():
+                    if method not in HTTP_METHODS:
+                        continue
+                    counter.total += 1
+                    if not should_skip(path, method, definition):
+                        counter.selected += 1
+            except SCHEMA_PARSING_ERRORS:
+                continue
+        return counter
 
     def _operation_iter(self) -> Generator[dict[str, Any], None, None]:
         try:
@@ -144,40 +196,30 @@ 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:
                 # 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
+        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
@@ -189,22 +231,40 @@ class BaseOpenAPISchema(BaseSchema):
         headers: dict[str, str] | None = None,
         cookies: dict[str, str] | None = None,
         path_parameters: dict[str, str] | None = None,
-    ) -> Callable[[GenericTest], GenericTest]:
+    ) -> Callable[[Callable], Callable]:
         """Override Open API parameters with fixed values."""
 
-        def _add_override(test: GenericTest) -> GenericTest:
+        def _add_override(test: Callable) -> Callable:
             check_no_override_mark(test)
-            override = CaseOverride(
+            override = Override(
                 query=query or {}, headers=headers or {}, cookies=cookies or {}, path_parameters=path_parameters or {}
             )
-            set_override_mark(test, override)
+            OverrideMark.set(test, override)
             return test
 
         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
-    ) -> Generator[Result[APIOperation, OperationSchemaError], None, None]:
+        self, generation_config: GenerationConfig | None = None
+    ) -> Generator[Result[APIOperation, InvalidSchema], None, None]:
         """Iterate over all operations defined in the API.
 
         Each yielded item is either `Ok` or `Err`, depending on the presence of errors during schema processing.
@@ -225,62 +285,59 @@ class BaseOpenAPISchema(BaseSchema):
             paths = self.raw_schema["paths"]
         except KeyError as exc:
             # This field is optional in Open API 3.1
-            if version.parse(self.spec_version) >= version.parse("3.1"):
+            if version.parse(self.specification.version) >= version.parse("3.1"):
                 return
             # Missing `paths` is not recoverable
             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
+        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,
+                            )
+                            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)
 
-    def _into_err(self, error: Exception, path: str | None, method: str | None) -> Err[OperationSchemaError]:
+    def _into_err(self, error: Exception, path: str | None, method: str | None) -> Err[InvalidSchema]:
         __tracebackhide__ = True
         try:
             full_path = self.get_full_path(path) if isinstance(path, str) else None
             self._raise_invalid_schema(error, full_path, path, method)
-        except OperationSchemaError as exc:
+        except InvalidSchema as exc:
             return Err(exc)
 
     def _raise_invalid_schema(
@@ -291,17 +348,15 @@ class BaseOpenAPISchema(BaseSchema):
         method: str | None = None,
     ) -> NoReturn:
         __tracebackhide__ = True
-        if isinstance(error, jsonschema.exceptions.RefResolutionError):
-            raise OperationSchemaError.from_reference_resolution_error(
+        if isinstance(error, RefResolutionError):
+            raise InvalidSchema.from_reference_resolution_error(
                 error, path=path, method=method, full_path=full_path
             ) from None
         try:
             self.validate()
         except jsonschema.ValidationError as exc:
-            raise OperationSchemaError.from_jsonschema_error(
-                exc, path=path, method=method, full_path=full_path
-            ) from None
-        raise OperationSchemaError(SCHEMA_ERROR_MESSAGE, path=path, method=method, full_path=full_path) from error
+            raise InvalidSchema.from_jsonschema_error(exc, path=path, method=method, full_path=full_path) from None
+        raise InvalidSchema(SCHEMA_ERROR_MESSAGE, path=path, method=method, full_path=full_path) from error
 
     def validate(self) -> None:
         with suppress(TypeError):
@@ -320,35 +375,44 @@ 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
         base_url = self.get_base_url()
-        operation: APIOperation[OpenAPIParameter, Case] = APIOperation(
+        operation: APIOperation[OpenAPIParameter] = 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
 
@@ -358,11 +422,11 @@ 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: Response) -> 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, **kwargs: Any) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
         raise NotImplementedError
 
@@ -376,76 +440,106 @@ 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,
         operation: APIOperation,
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
-        data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),
+        generation_mode: GenerationMode = GenerationMode.default(),
         generation_config: GenerationConfig | None = None,
         **kwargs: Any,
     ) -> SearchStrategy:
-        return get_case_strategy(
+        return openapi_cases(
             operation=operation,
             auth_storage=auth_storage,
             hooks=hooks,
-            generator=data_generation_method,
+            generation_mode=generation_mode,
             generation_config=generation_config or self.generation_config,
             **kwargs,
         )
 
     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,33 +547,37 @@ 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: Response
+    ) -> 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
             full_path = self.get_full_path(path) if isinstance(path, str) else None
             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: Response
+    ) -> 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:
             return create_state_machine(self)
         except OperationNotFound as exc:
-            raise SchemaError(
-                type=SchemaErrorType.OPEN_API_INVALID_SCHEMA,
+            raise LoaderError(
+                kind=LoaderErrorKind.OPEN_API_INVALID_SCHEMA,
                 message=f"Invalid Open API link definition: Operation `{exc.item}` not found",
             ) from exc
 
@@ -507,7 +605,7 @@ class BaseOpenAPISchema(BaseSchema):
 
         .. code-block:: python
 
-            schema = schemathesis.from_uri("http://0.0.0.0/schema.yaml")
+            schema = schemathesis.openapi.from_url("http://0.0.0.0/schema.yaml")
 
             schema.add_link(
                 source=schema["/users/"]["POST"],
@@ -518,46 +616,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,9 +634,15 @@ 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.specification.version.startswith("3.1"):
+            return jsonschema.Draft202012Validator
+        return jsonschema.Draft4Validator
 
-    def validate_response(self, operation: APIOperation, response: GenericResponse) -> bool | None:
+    def validate_response(self, operation: APIOperation, response: Response) -> 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:
@@ -582,51 +656,52 @@ class BaseOpenAPISchema(BaseSchema):
         if not schema:
             # No schema to check against
             return None
-        content_type = response.headers.get("Content-Type")
-        errors = []
-        if content_type is None:
-            media_types = self.get_content_types(operation, response)
-            formatted_content_types = [f"\n- `{content_type}`" for content_type in media_types]
+        content_types = response.headers.get("content-type")
+        failures: list[Failure] = []
+        if content_types is None:
+            all_media_types = self.get_content_types(operation, response)
+            formatted_content_types = [f"\n- `{content_type}`" for content_type in all_media_types]
             message = f"The following media types are documented in the schema:{''.join(formatted_content_types)}"
-            try:
-                raise get_missing_content_type_error()(
-                    failures.MissingContentType.title,
-                    context=failures.MissingContentType(message=message, media_types=media_types),
-                )
-            except Exception as exc:
-                errors.append(exc)
-        if content_type and not is_json_media_type(content_type):
-            _maybe_raise_one_or_more(errors)
+            failures.append(MissingContentType(operation=operation.label, message=message, media_types=all_media_types))
+            content_type = None
+        else:
+            content_type = content_types[0]
+        if content_type and not media_types.is_json(content_type):
+            _maybe_raise_one_or_more(failures)
             return None
         try:
-            data = get_json(response)
+            data = response.json()
         except JSONDecodeError as exc:
-            exc_class = get_response_parsing_error(exc)
-            context = failures.JSONDecodeErrorContext.from_exception(exc)
+            failures.append(MalformedJson.from_exception(operation=operation.label, exc=exc))
+            _maybe_raise_one_or_more(failures)
+        with self._validating_response(scopes) as resolver:
             try:
-                raise exc_class(context.title, context=context) from exc
-            except Exception as exc:
-                errors.append(exc)
-                _maybe_raise_one_or_more(errors)
+                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:
+                failures.append(
+                    JsonSchemaError.from_exception(
+                        operation=operation.label,
+                        exc=exc,
+                        output_config=operation.schema.output_config,
+                    )
+                )
+        _maybe_raise_one_or_more(failures)
+        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
         )
-        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):
-            try:
-                jsonschema.validate(data, schema, cls=cls, resolver=resolver)
-            except jsonschema.ValidationError as exc:
-                exc_class = get_schema_validation_error(exc)
-                ctx = failures.ValidationErrorContext.from_exception(exc)
-                try:
-                    raise exc_class(ctx.title, context=ctx) from exc
-                except Exception as exc:
-                    errors.append(exc)
-        _maybe_raise_one_or_more(errors)
-        return None  # explicitly return None for mypy
+            yield resolver
 
     @property
     def rewritten_components(self) -> dict[str, Any]:
@@ -648,7 +723,7 @@ class BaseOpenAPISchema(BaseSchema):
                     else:
                         break
                 else:
-                    target.update(traverse_schema(fast_deepcopy(schema), callback, self.nullable_name))
+                    target.update(transform(deepclone(schema), callback, self.nullable_name))
             if self._inline_reference_cache:
                 components[INLINED_REFERENCES_KEY] = self._inline_reference_cache
             self._rewritten_components = components
@@ -659,8 +734,8 @@ class BaseOpenAPISchema(BaseSchema):
 
         Inlining components helps `hypothesis-jsonschema` generate data that involves non-resolved references.
         """
-        schema = fast_deepcopy(schema)
-        schema = traverse_schema(schema, self._rewrite_references, self.resolver)
+        schema = deepclone(schema)
+        schema = transform(schema, self._rewrite_references, self.resolver)
         # Only add definitions that are reachable from the schema via references
         stack = [schema]
         seen = set()
@@ -675,8 +750,8 @@ class BaseOpenAPISchema(BaseSchema):
                         pointer = reference[1:]
                         resolved = resolve_pointer(self.rewritten_components, pointer)
                         if resolved is UNRESOLVABLE:
-                            raise SchemaError(
-                                SchemaErrorType.OPEN_API_INVALID_SCHEMA,
+                            raise LoaderError(
+                                LoaderErrorKind.OPEN_API_INVALID_SCHEMA,
                                 message=f"Unresolvable JSON pointer in the schema: {pointer}",
                             )
                         if isinstance(resolved, dict):
@@ -710,7 +785,7 @@ class BaseOpenAPISchema(BaseSchema):
                 if key not in self._inline_reference_cache:
                     with resolver.resolving(reference) as resolved:
                         # Resolved object also may have references
-                        self._inline_reference_cache[key] = traverse_schema(
+                        self._inline_reference_cache[key] = transform(
                             resolved, lambda s: self._rewrite_references(s, resolver)
                         )
             # Rewrite the reference with the new location
@@ -718,13 +793,12 @@ class BaseOpenAPISchema(BaseSchema):
         return schema
 
 
-def _maybe_raise_one_or_more(errors: list[Exception]) -> None:
-    if not errors:
+def _maybe_raise_one_or_more(failures: list[Failure]) -> None:
+    if not failures:
         return
-    elif len(errors) == 1:
-        raise errors[0]
-    else:
-        raise MultipleFailures("\n\n".join(str(error) for error in errors), errors)
+    if len(failures) == 1:
+        raise failures[0] from None
+    raise FailureGroup(failures) from None
 
 
 def _make_reference_key(scopes: list[str], reference: str) -> str:
@@ -766,36 +840,63 @@ 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)
-        except KeyError as exc:
+            return self._init_operation(item)
+        except LookupError as exc:
             available_methods = ", ".join(map(str.upper, self))
-            message = f"Method `{item}` not found. Available methods: {available_methods}"
-            raise KeyError(message) from exc
+            message = f"Method `{item.upper()}` not found."
+            if available_methods:
+                message += f" Available methods: {available_methods}"
+            raise LookupError(message) from exc
 
 
 OPENAPI_20_DEFAULT_BODY_MEDIA_TYPE = "application/json"
 OPENAPI_20_DEFAULT_FORM_MEDIA_TYPE = "multipart/form-data"
-C = TypeVar("C", bound=Case)
 
 
 class SwaggerV20(BaseOpenAPISchema):
@@ -808,12 +909,9 @@ class SwaggerV20(BaseOpenAPISchema):
     links_field = "x-links"
 
     @property
-    def spec_version(self) -> str:
-        return self.raw_schema.get("swagger", "2.0")
-
-    @property
-    def verbose_name(self) -> str:
-        return f"Swagger {self.spec_version}"
+    def specification(self) -> Specification:
+        version = self.raw_schema.get("swagger", "2.0")
+        return Specification.openapi(version=version)
 
     def _validate(self) -> None:
         SWAGGER_20_VALIDATOR.validate(self.raw_schema)
@@ -849,6 +947,8 @@ class SwaggerV20(BaseOpenAPISchema):
                 for media_type in body_media_types:
                     collected.append(OpenAPI20Body(definition=parameter, media_type=media_type))
             else:
+                if parameter["in"] in ("header", "cookie"):
+                    check_header(parameter)
                 collected.append(OpenAPI20Parameter(definition=parameter))
 
         if form_parameters:
@@ -859,20 +959,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, **kwargs: Any) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
-        return get_strategies_from_examples(operation, self.examples_field)
+        return get_strategies_from_examples(operation, **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]:
+    def get_content_types(self, operation: APIOperation, response: Response) -> list[str]:
         produces = operation.definition.raw.get("produces", None)
         if produces:
             return produces
@@ -882,7 +984,7 @@ class SwaggerV20(BaseOpenAPISchema):
         return serialization.serialize_swagger2_parameters(definitions)
 
     def prepare_multipart(
-        self, form_data: FormData, operation: APIOperation
+        self, form_data: dict[str, Any], operation: APIOperation
     ) -> tuple[list | None, dict[str, Any] | None]:
         """Prepare form data for sending with `requests`.
 
@@ -903,7 +1005,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,41 +1020,35 @@ 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,
         *,
-        case_cls: type[C],
         operation: APIOperation,
-        path_parameters: PathParameters | None = None,
-        headers: Headers | None = None,
-        cookies: Cookies | None = None,
-        query: Query | None = None,
-        body: Body | NotSet = NOT_SET,
+        method: str | None = None,
+        path: str | None = None,
+        path_parameters: dict[str, Any] | None = None,
+        headers: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+        query: dict[str, Any] | None = None,
+        body: list | dict[str, Any] | str | int | float | bool | bytes | NotSet = NOT_SET,
         media_type: str | None = None,
-    ) -> C:
+        meta: CaseMetadata | None = None,
+    ) -> Case:
         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}"
-                )
-        return case_cls(
+            media_type = operation._get_default_media_type()
+        return Case(
             operation=operation,
+            method=method or operation.method.upper(),
+            path=path or operation.path,
             path_parameters=path_parameters,
             headers=CaseInsensitiveDict(headers) if headers is not None else headers,
             cookies=cookies,
             query=query,
             body=body,
             media_type=media_type,
+            meta=meta,
         )
 
     def _get_consumes_for_operation(self, definition: dict[str, Any]) -> list[str]:
@@ -970,6 +1066,8 @@ class SwaggerV20(BaseOpenAPISchema):
 
     def _get_payload_schema(self, definition: dict[str, Any], media_type: str) -> dict[str, Any] | None:
         for parameter in definition.get("parameters", []):
+            if "$ref" in parameter:
+                _, parameter = self.resolver.resolve(parameter["$ref"])
             if parameter["in"] == "body":
                 return parameter["schema"]
         return None
@@ -985,15 +1083,12 @@ class OpenApi30(SwaggerV20):
     links_field = "links"
 
     @property
-    def spec_version(self) -> str:
-        return self.raw_schema["openapi"]
-
-    @property
-    def verbose_name(self) -> str:
-        return f"Open API {self.spec_version}"
+    def specification(self) -> Specification:
+        version = self.raw_schema["openapi"]
+        return Specification.openapi(version=version)
 
     def _validate(self) -> None:
-        if self.spec_version.startswith("3.1"):
+        if self.specification.version.startswith("3.1"):
             # Currently we treat Open API 3.1 as 3.0 in some regard
             OPENAPI_31_VALIDATOR.validate(self.raw_schema)
         else:
@@ -1012,7 +1107,12 @@ class OpenApi30(SwaggerV20):
         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] = []
+
+        for parameter in parameters:
+            if parameter["in"] in ("header", "cookie"):
+                check_header(parameter)
+            collected.append(OpenAPI30Parameter(definition=parameter))
         if "requestBody" in definition:
             required = definition["requestBody"].get("required", False)
             description = definition["requestBody"].get("description")
@@ -1023,34 +1123,38 @@ 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, **kwargs: Any) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
-        return get_strategies_from_examples(operation, self.examples_field)
+        return get_strategies_from_examples(operation, **kwargs)
 
-    def get_content_types(self, operation: APIOperation, response: GenericResponse) -> list[str]:
-        definitions = self._get_response_definitions(operation, response)
-        if not definitions:
+    def get_content_types(self, operation: APIOperation, response: Response) -> list[str]:
+        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
+        self, form_data: dict[str, Any], operation: APIOperation
     ) -> tuple[list | None, dict[str, Any] | None]:
         """Prepare form data for sending with `requests`.
 
@@ -1059,17 +1163,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"]
+            main, sub = media_types.parse(media_type)
+            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]])
@@ -1087,8 +1196,8 @@ class OpenApi30(SwaggerV20):
             else:
                 body = definition["requestBody"]
             if "content" in body:
-                main, sub = parse_content_type(media_type)
+                main, sub = media_types.parse(media_type)
                 for defined_media_type, item in body["content"].items():
-                    if parse_content_type(defined_media_type) == (main, sub):
+                    if media_types.parse(defined_media_type) == (main, sub):
                         return item["schema"]
         return None