schemathesis 4.0.24__py3-none-any.whl → 4.0.26__py3-none-any.whl

schemathesis/config/_error.py

@@ -140,6 +140,13 @@ def _format_anyof_error(error: ValidationError) -> str:
             f"Error in {section} section:\n  At least one filter is required when defining [[operations]].\n\n"
             "Please specify at least one include or exclude filter property (e.g., include-path, exclude-tag, etc.)."
         )
+    elif list(error.schema_path) == ["properties", "workers", "anyOf"]:
+        return (
+            f"Invalid value for 'workers': {repr(error.instance)}\n\n"
+            f"Expected either:\n"
+            f"  - A positive integer (e.g., workers = 4)\n"
+            f'  - The string "auto" for automatic detection (workers = "auto")'
+        )
     return error.message
 
 

schemathesis/config/schema.json

@@ -94,7 +94,14 @@
       "type": "string"
     },
     "workers": {
-      "type": "integer"
+      "anyOf": [
+        {
+          "type": "integer"
+        },
+        {
+          "const": "auto"
+        }
+      ]
     },
     "wait-for-schema": {
       "type": "number",
@@ -491,7 +498,14 @@
           "type": "string"
         },
         "workers": {
-          "type": "integer"
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "const": "auto"
+            }
+          ]
         },
         "wait-for-schema": {
           "type": "number",

schemathesis/engine/phases/unit/_executor.py

@@ -263,12 +263,7 @@ def setup_hypothesis_database_key(test: Callable, operation: APIOperation) -> No
 
     It increases the effectiveness of the Hypothesis database in the CLI.
     """
-    # Hypothesis's function digest depends on the test function signature. To reflect it for the web API case,
-    # we use all API operation parameters in the digest.
-    extra = operation.label.encode("utf8")
-    for parameter in operation.iter_parameters():
-        extra += parameter.serialize(operation).encode("utf8")
-    test.hypothesis.inner_test._hypothesis_internal_add_digest = extra  # type: ignore
+    test.hypothesis.inner_test._hypothesis_internal_add_digest = operation.label.encode("utf8")  # type: ignore
 
 
 def get_invalid_regular_expression_message(warnings: list[WarningMessage]) -> str | None:

schemathesis/generation/coverage.py

@@ -321,7 +321,7 @@ class HashSet:
 
 
 def _cover_positive_for_type(
-    ctx: CoverageContext, schema: dict, ty: str | None
+    ctx: CoverageContext, schema: dict, ty: str | None, seen: HashSet | None = None
 ) -> Generator[GeneratedValue, None, None]:
     if ty == "object" or ty == "array":
         template_schema = _get_template_schema(schema, ty)
@@ -369,6 +369,9 @@ def _cover_positive_for_type(
                 yield from _positive_object(ctx, schema, cast(dict, template))
         elif "properties" in schema or "required" in schema:
             yield from _positive_object(ctx, schema, cast(dict, template))
+        elif "not" in schema and isinstance(schema["not"], (dict, bool)):
+            nctx = ctx.with_negative()
+            yield from cover_schema_iter(nctx, schema["not"], seen)
 
 
 @contextmanager
@@ -397,9 +400,12 @@ def cover_schema_iter(
 ) -> Generator[GeneratedValue, None, None]:
     if seen is None:
         seen = HashSet()
-    if isinstance(schema, bool):
+    if schema == {} or schema is True:
         types = ["null", "boolean", "string", "number", "array", "object"]
         schema = {}
+    elif schema is False:
+        types = []
+        schema = {"not": {}}
     else:
         types = schema.get("type", [])
     push_examples_to_properties(schema)
@@ -615,6 +621,9 @@ def cover_schema_iter(
                             for value in cover_schema_iter(nctx, sub_schema, seen):
                                 if is_invalid_for_oneOf(value.value, idx, validators):
                                     yield value
+                elif key == "not" and isinstance(value, (dict, bool)):
+                    pctx = ctx.with_positive()
+                    yield from cover_schema_iter(pctx, value, seen)
 
 
 def is_valid_for_others(value: Any, idx: int, validators: list[jsonschema.Validator]) -> bool:
@@ -690,6 +699,7 @@ def _ensure_valid_headers_schema(schema: dict[str, Any]) -> dict[str, Any]:
 def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedValue, None, None]:
     """Generate positive string values."""
     # Boundary and near boundary values
+    schema = {"type": "string", **schema}
     min_length = schema.get("minLength")
     if min_length == 0:
         min_length = None
@@ -791,6 +801,7 @@ def closest_multiple_greater_than(y: int, x: int) -> int:
 def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedValue, None, None]:
     """Generate positive integer values."""
     # Boundary and near boundary values
+    schema = {"type": "number", **schema}
     minimum = schema.get("minimum")
     maximum = schema.get("maximum")
     exclusive_minimum = schema.get("exclusiveMinimum")

schemathesis/generation/hypothesis/__init__.py

@@ -7,6 +7,7 @@ def setup() -> None:
     from hypothesis.internal.entropy import deterministic_PRNG
     from hypothesis.internal.reflection import is_first_param_referenced_in_function
     from hypothesis.strategies._internal import collections, core
+    from hypothesis.vendor import pretty
     from hypothesis_jsonschema import _from_schema, _resolve
 
     from schemathesis.core import INTERNAL_BUFFER_SIZE
@@ -26,6 +27,14 @@ def setup() -> None:
         return is_first_param_referenced_in_function(f)
 
     core.is_first_param_referenced_in_function = _is_first_param_referenced_in_function  # type: ignore
+
+    class RepresentationPrinter(pretty.RepresentationPrinter):
+        def pretty(self, obj: object) -> None:
+            # This one takes way too much - in the coverage phase it may give >2 orders of magnitude improvement
+            # depending on the schema size (~300 seconds -> 4.5 seconds in one of the benchmarks)
+            return None
+
+    root_core.RepresentationPrinter = RepresentationPrinter  # type: ignore
     _resolve.deepcopy = deepclone  # type: ignore
     _from_schema.deepcopy = deepclone  # type: ignore
     root_core.BUFFER_SIZE = INTERNAL_BUFFER_SIZE  # type: ignore

schemathesis/generation/hypothesis/builder.py

@@ -234,6 +234,22 @@ def add_examples(
     hook_dispatcher: HookDispatcher | None = None,
     **kwargs: Any,
 ) -> Callable:
+    for example in generate_example_cases(
+        test=test, operation=operation, fill_missing=fill_missing, hook_dispatcher=hook_dispatcher, **kwargs
+    ):
+        test = hypothesis.example(case=example)(test)
+
+    return test
+
+
+def generate_example_cases(
+    *,
+    test: Callable,
+    operation: APIOperation,
+    fill_missing: bool,
+    hook_dispatcher: HookDispatcher | None = None,
+    **kwargs: Any,
+) -> Generator[Case]:
     """Add examples to the Hypothesis test, if they are specified in the schema."""
     from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
 
@@ -273,9 +289,7 @@ def add_examples(
                 InvalidHeadersExampleMark.set(original_test, invalid_headers)
                 continue
         adjust_urlencoded_payload(example)
-        test = hypothesis.example(case=example)(test)
-
-    return test
+        yield example
 
 
 def adjust_urlencoded_payload(case: Case) -> None:
@@ -298,6 +312,29 @@ def add_coverage(
     unexpected_methods: set[str],
     generation_config: GenerationConfig,
 ) -> Callable:
+    for case in generate_coverage_cases(
+        operation=operation,
+        generation_modes=generation_modes,
+        auth_storage=auth_storage,
+        as_strategy_kwargs=as_strategy_kwargs,
+        generate_duplicate_query_parameters=generate_duplicate_query_parameters,
+        unexpected_methods=unexpected_methods,
+        generation_config=generation_config,
+    ):
+        test = hypothesis.example(case=case)(test)
+    return test
+
+
+def generate_coverage_cases(
+    *,
+    operation: APIOperation,
+    generation_modes: list[GenerationMode],
+    auth_storage: AuthStorage | None,
+    as_strategy_kwargs: dict[str, Any],
+    generate_duplicate_query_parameters: bool,
+    unexpected_methods: set[str],
+    generation_config: GenerationConfig,
+) -> Generator[Case]:
     from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
 
     auth_context = auths.AuthContext(
@@ -309,7 +346,6 @@ def add_coverage(
         for container in LOCATION_TO_CONTAINER.values()
         if container in as_strategy_kwargs
     }
-
     with warnings.catch_warnings():
         warnings.filterwarnings(
             "ignore", message=".*but this is not valid syntax for a Python regular expression.*", category=UserWarning
@@ -331,9 +367,7 @@ def add_coverage(
                     setattr(case, container_name, value)
                 else:
                     container.update(value)
-
-            test = hypothesis.example(case=case)(test)
-    return test
+            yield case
 
 
 class Instant:

schemathesis/generation/meta.py

@@ -12,6 +12,7 @@ class TestPhase(str, Enum):
     EXAMPLES = "examples"
     COVERAGE = "coverage"
     FUZZING = "fuzzing"
+    STATEFUL = "stateful"
 
 
 class ComponentKind(str, Enum):
@@ -34,15 +35,22 @@ class ComponentInfo:
 
 
 @dataclass
-class GeneratePhaseData:
+class FuzzingPhaseData:
     """Metadata specific to generate phase."""
 
     __slots__ = ()
 
 
 @dataclass
-class ExplicitPhaseData:
-    """Metadata specific to explicit phase."""
+class StatefulPhaseData:
+    """Metadata specific to stateful phase."""
+
+    __slots__ = ()
+
+
+@dataclass
+class ExamplesPhaseData:
+    """Metadata specific to examples phase."""
 
     __slots__ = ()
 
@@ -64,7 +72,7 @@ class PhaseInfo:
     """Phase-specific information."""
 
     name: TestPhase
-    data: CoveragePhaseData | ExplicitPhaseData | GeneratePhaseData
+    data: CoveragePhaseData | ExamplesPhaseData | FuzzingPhaseData | StatefulPhaseData
 
     __slots__ = ("name", "data")
 
@@ -84,8 +92,8 @@ class PhaseInfo:
         )
 
     @classmethod
-    def generate(cls) -> PhaseInfo:
-        return cls(name=TestPhase.FUZZING, data=GeneratePhaseData())
+    def fuzzing(cls) -> PhaseInfo:
+        return cls(name=TestPhase.FUZZING, data=FuzzingPhaseData())
 
 
 @dataclass

schemathesis/schemas.py

@@ -545,10 +545,6 @@ class Parameter:
         """Whether the parameter is required for a successful API call."""
         raise NotImplementedError
 
-    def serialize(self, operation: APIOperation) -> str:
-        """Get parameter's string representation."""
-        raise NotImplementedError
-
 
 P = TypeVar("P", bound=Parameter)
 
@@ -620,7 +616,7 @@ class OperationDefinition(Generic[D]):
     def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
 
 
-@dataclass(eq=False)
+@dataclass()
 class APIOperation(Generic[P]):
     """An API operation (e.g., `GET /users`)."""
 
@@ -647,6 +643,14 @@ class APIOperation(Generic[P]):
     def __deepcopy__(self, memo: dict) -> APIOperation[P]:
         return self
 
+    def __hash__(self) -> int:
+        return hash(self.label)
+
+    def __eq__(self, value: object, /) -> bool:
+        if not isinstance(value, APIOperation):
+            return NotImplemented
+        return self.label == value.label
+
     @property
     def full_path(self) -> str:
         return self.schema.get_full_path(self.path)
@@ -700,6 +704,9 @@ class APIOperation(Generic[P]):
             **kwargs: Extra arguments to the underlying strategy function.
 
         """
+        if self.schema.config.headers:
+            headers = kwargs.setdefault("headers", {})
+            headers.update(self.schema.config.headers)
         strategy = self.schema.get_case_strategy(self, generation_mode=generation_mode, **kwargs)
 
         def _apply_hooks(dispatcher: HookDispatcher, _strategy: SearchStrategy[Case]) -> SearchStrategy[Case]:

schemathesis/specs/graphql/schemas.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import enum
 import time
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from difflib import get_close_matches
 from enum import unique
 from types import SimpleNamespace
@@ -34,8 +34,8 @@ from schemathesis.generation.meta import (
     CaseMetadata,
     ComponentInfo,
     ComponentKind,
-    ExplicitPhaseData,
-    GeneratePhaseData,
+    ExamplesPhaseData,
+    FuzzingPhaseData,
     GenerationInfo,
     PhaseInfo,
     TestPhase,
@@ -50,7 +50,6 @@ from schemathesis.schemas import (
 )
 from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
 
-from ._cache import OperationCache
 from .scalars import CUSTOM_SCALARS, get_extra_scalar_strategies
 
 if TYPE_CHECKING:
@@ -86,8 +85,6 @@ class GraphQLOperationDefinition(OperationDefinition):
 
 @dataclass
 class GraphQLSchema(BaseSchema):
-    _operation_cache: OperationCache = field(default_factory=OperationCache)
-
     def __repr__(self) -> str:
         return f"<{self.__class__.__name__}>"
 
@@ -101,10 +98,6 @@ class GraphQLSchema(BaseSchema):
                 yield operation_type.name
 
     def _get_operation_map(self, key: str) -> APIOperationMap:
-        cache = self._operation_cache
-        map = cache.get_map(key)
-        if map is not None:
-            return map
         schema = self.client_schema
         for root_type, operation_type in (
             (RootType.QUERY, schema.query_type),
@@ -113,7 +106,6 @@ class GraphQLSchema(BaseSchema):
             if operation_type and operation_type.name == key:
                 map = APIOperationMap(self, {})
                 map._data = FieldMap(map, root_type, operation_type)
-                cache.insert_map(key, map)
                 return map
         raise KeyError(key)
 
@@ -303,15 +295,9 @@ class FieldMap(Mapping):
 
     def _init_operation(self, field_name: str) -> APIOperation:
         schema = cast(GraphQLSchema, self._parent._schema)
-        cache = schema._operation_cache
-        operation = cache.get_operation(field_name)
-        if operation is not None:
-            return operation
         operation_type = self._operation_type
         field_ = operation_type.fields[field_name]
-        operation = schema._build_operation(self._root_type, operation_type, field_name, field_)
-        cache.insert_operation(field_name, operation)
-        return operation
+        return schema._build_operation(self._root_type, operation_type, field_name, field_)
 
     def __getitem__(self, item: str) -> APIOperation:
         try:
@@ -368,10 +354,10 @@ def graphql_cases(
     query_ = _generate_parameter("query", query, draw, operation, hook_context, hooks)
 
     _phase_data = {
-        TestPhase.EXAMPLES: ExplicitPhaseData(),
-        TestPhase.FUZZING: GeneratePhaseData(),
+        TestPhase.EXAMPLES: ExamplesPhaseData(),
+        TestPhase.FUZZING: FuzzingPhaseData(),
     }[phase]
-    phase_data = cast(Union[ExplicitPhaseData, GeneratePhaseData], _phase_data)
+    phase_data = cast(Union[ExamplesPhaseData, FuzzingPhaseData], _phase_data)
     instance = operation.Case(
         path_parameters=path_parameters_,
         headers=headers_,

schemathesis/specs/openapi/_hypothesis.py

@@ -5,7 +5,6 @@ from contextlib import suppress
 from dataclasses import dataclass
 from typing import Any, Callable, Dict, Iterable, Optional, Union, cast
 from urllib.parse import quote_plus
-from weakref import WeakKeyDictionary
 
 import jsonschema.protocols
 from hypothesis import event, note, reject
@@ -23,10 +22,11 @@ from schemathesis.generation.meta import (
     CaseMetadata,
     ComponentInfo,
     ComponentKind,
-    ExplicitPhaseData,
-    GeneratePhaseData,
+    ExamplesPhaseData,
+    FuzzingPhaseData,
     GenerationInfo,
     PhaseInfo,
+    StatefulPhaseData,
     TestPhase,
 )
 from schemathesis.openapi.generation.filters import is_valid_header, is_valid_path, is_valid_query, is_valid_urlencoded
@@ -64,7 +64,6 @@ def openapi_cases(
     body: Any = NOT_SET,
     media_type: str | None = None,
     phase: TestPhase = TestPhase.FUZZING,
-    __is_stateful_phase: bool = False,
 ) -> Any:
     """A strategy that creates `Case` instances.
 
@@ -81,8 +80,7 @@ def openapi_cases(
     start = time.monotonic()
     strategy_factory = GENERATOR_MODE_TO_STRATEGY_FACTORY[generation_mode]
 
-    phase_name = "stateful" if __is_stateful_phase else phase.value
-    generation_config = operation.schema.config.generation_for(operation=operation, phase=phase_name)
+    generation_config = operation.schema.config.generation_for(operation=operation, phase=phase.value)
 
     ctx = HookContext(operation=operation)
 
@@ -151,10 +149,11 @@ def openapi_cases(
             reject()
 
     _phase_data = {
-        TestPhase.EXAMPLES: ExplicitPhaseData(),
-        TestPhase.FUZZING: GeneratePhaseData(),
+        TestPhase.EXAMPLES: ExamplesPhaseData(),
+        TestPhase.FUZZING: FuzzingPhaseData(),
+        TestPhase.STATEFUL: StatefulPhaseData(),
     }[phase]
-    phase_data = cast(Union[ExplicitPhaseData, GeneratePhaseData], _phase_data)
+    phase_data = cast(Union[ExamplesPhaseData, FuzzingPhaseData, StatefulPhaseData], _phase_data)
 
     instance = operation.Case(
         media_type=media_type,
@@ -190,9 +189,6 @@ def openapi_cases(
     return instance
 
 
-_BODY_STRATEGIES_CACHE: WeakKeyDictionary = WeakKeyDictionary()
-
-
 def _get_body_strategy(
     parameter: OpenAPIBody,
     strategy_factory: StrategyFactory,
@@ -203,10 +199,6 @@ def _get_body_strategy(
 
     if parameter.media_type in MEDIA_TYPES:
         return MEDIA_TYPES[parameter.media_type]
-    # The cache key relies on object ids, which means that the parameter should not be mutated
-    # Note, the parent schema is not included as each parameter belong only to one schema
-    if parameter in _BODY_STRATEGIES_CACHE and strategy_factory in _BODY_STRATEGIES_CACHE[parameter]:
-        return _BODY_STRATEGIES_CACHE[parameter][strategy_factory]
     schema = parameter.as_json_schema(operation)
     schema = operation.schema.prepare_schema(schema)
     assert isinstance(operation.schema, BaseOpenAPISchema)
@@ -215,7 +207,6 @@ def _get_body_strategy(
     )
     if not parameter.is_required:
         strategy |= st.just(NOT_SET)
-    _BODY_STRATEGIES_CACHE.setdefault(parameter, {})[strategy_factory] = strategy
     return strategy
 
 
@@ -248,9 +239,6 @@ def get_parameters_value(
     return value
 
 
-_PARAMETER_STRATEGIES_CACHE: WeakKeyDictionary = WeakKeyDictionary()
-
-
 @dataclass
 class ValueContainer:
     """Container for a value generated by a data generator or explicitly provided."""
@@ -352,10 +340,6 @@ def get_parameters_strategy(
 
     parameters = getattr(operation, LOCATION_TO_CONTAINER[location])
     if parameters:
-        # The cache key relies on object ids, which means that the parameter should not be mutated
-        nested_cache_key = (strategy_factory, location, tuple(sorted(exclude)))
-        if operation in _PARAMETER_STRATEGIES_CACHE and nested_cache_key in _PARAMETER_STRATEGIES_CACHE[operation]:
-            return _PARAMETER_STRATEGIES_CACHE[operation][nested_cache_key]
         schema = get_schema_for_location(operation, location, parameters)
         if location == "header" and exclude:
             # Remove excluded headers case-insensitively
@@ -399,7 +383,6 @@ def get_parameters_strategy(
                 strategy = strategy.map(quote_all).map(jsonify_python_specific_types)
             elif location == "query":
                 strategy = strategy.map(jsonify_python_specific_types)
-        _PARAMETER_STRATEGIES_CACHE.setdefault(operation, {})[nested_cache_key] = strategy
         return strategy
     # No parameters defined for this location
     return st.none()

schemathesis/specs/openapi/parameters.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import json
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, ClassVar, Iterable
 
@@ -95,11 +94,6 @@ class OpenAPIParameter(Parameter):
             if key in self.supported_jsonschema_keywords or key.startswith("x-") or key == self.nullable_field
         }
 
-    def serialize(self, operation: APIOperation) -> str:
-        # For simplicity, JSON Schema semantics is not taken into account (e.g. 1 == 1.0)
-        # I.e. two semantically equal schemas may have different representation
-        return json.dumps(self.as_json_schema(operation), sort_keys=True)
-
 
 @dataclass(eq=False)
 class OpenAPI20Parameter(OpenAPIParameter):
@@ -170,6 +164,7 @@ class OpenAPI30Parameter(OpenAPIParameter):
         "minProperties",
         "required",
         "enum",
+        "const",
         "type",
         "allOf",
         "oneOf",
@@ -178,6 +173,14 @@ class OpenAPI30Parameter(OpenAPIParameter):
         "items",
         "properties",
         "additionalProperties",
+        "additionalItems",
+        "dependencies",
+        "if",
+        "then",
+        "else",
+        "patternProperties",
+        "propertyNames",
+        "contains",
         "format",
         "example",
         "examples",

schemathesis/specs/openapi/schemas.py

@@ -47,7 +47,6 @@ from ...generation import GenerationMode
 from ...hooks import HookContext, HookDispatcher
 from ...schemas import APIOperation, APIOperationMap, ApiStatistic, BaseSchema, OperationDefinition
 from . import serialization
-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
@@ -96,7 +95,6 @@ class BaseOpenAPISchema(BaseSchema):
     links_field: ClassVar[str] = ""
     header_required_field: ClassVar[str] = ""
     security: ClassVar[BaseSecurityProcessor] = None  # type: ignore
-    _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
@@ -115,17 +113,12 @@ class BaseOpenAPISchema(BaseSchema):
         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]
         with in_scope(self.resolver, self.location or ""):
             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 find_operation_by_label(self, label: str) -> APIOperation | None:
@@ -136,7 +129,7 @@ class BaseOpenAPISchema(BaseSchema):
         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:
+    def _on_missing_operation(self, item: str, exc: KeyError | None, matches: list[str]) -> NoReturn:
         message = f"`{item}` not found"
         if matches:
             message += f". Did you mean `{matches[0]}`?"
@@ -443,31 +436,6 @@ class BaseOpenAPISchema(BaseSchema):
 
     def get_operation_by_id(self, operation_id: str) -> APIOperation:
         """Get an `APIOperation` instance by its `operationId`."""
-        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:
-            entry = cache.get_definition_by_id(operation_id)
-        except KeyError as exc:
-            matches = get_close_matches(operation_id, cache.known_operation_ids)
-            self._on_missing_operation(operation_id, exc, matches)
-        # 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():
@@ -477,44 +445,29 @@ class BaseOpenAPISchema(BaseSchema):
                 scope, path_item = resolve(path_item["$ref"])
             else:
                 scope = default_scope
-            for key, entry in path_item.items():
-                if key not in HTTP_METHODS:
+            for method, operation in path_item.items():
+                if method not in HTTP_METHODS:
                     continue
-                if "operationId" in entry:
-                    cache.insert_definition_by_id(
-                        entry["operationId"],
-                        path=path,
-                        method=key,
-                        scope=scope,
-                        path_item=path_item,
-                        operation=entry,
-                    )
+                if "operationId" in operation and operation["operationId"] == operation_id:
+                    resolved = self._resolve_operation(operation)
+                    parameters = self._collect_operation_parameters(path_item, resolved)
+                    return self.make_operation(path, method, parameters, operation, resolved, scope)
+        self._on_missing_operation(operation_id, None, [])
 
     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
         """
-        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", "~")
-        # 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)
         _, 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
+        return self.make_operation(path, method, parameters, operation, resolved, scope)
 
     def get_case_strategy(
         self,
@@ -851,22 +804,15 @@ class MethodMap(Mapping):
         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
+        return schema.make_operation(path, method, parameters, operation, resolved, scope)
 
     def __getitem__(self, item: str) -> APIOperation:
         try:

schemathesis/specs/openapi/stateful/__init__.py

@@ -15,7 +15,7 @@ from schemathesis.engine.recorder import ScenarioRecorder
 from schemathesis.generation import GenerationMode
 from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis import strategies
-from schemathesis.generation.meta import ComponentInfo, ComponentKind
+from schemathesis.generation.meta import ComponentInfo, ComponentKind, TestPhase
 from schemathesis.generation.stateful import STATEFUL_TESTS_LABEL
 from schemathesis.generation.stateful.state_machine import APIStateMachine, StepInput, StepOutput, _normalize_name
 from schemathesis.schemas import APIOperation
@@ -179,10 +179,10 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
                 name = _normalize_name(f"RANDOM -> {target.label}")
                 config = schema.config.generation_for(operation=target, phase="stateful")
                 if len(config.modes) == 1:
-                    case_strategy = target.as_strategy(generation_mode=config.modes[0], __is_stateful_phase=True)
+                    case_strategy = target.as_strategy(generation_mode=config.modes[0], phase=TestPhase.STATEFUL)
                 else:
                     _strategies = {
-                        method: target.as_strategy(generation_mode=method, __is_stateful_phase=True)
+                        method: target.as_strategy(generation_mode=method, phase=TestPhase.STATEFUL)
                         for method in config.modes
                     }
 
@@ -269,7 +269,7 @@ def into_step_input(
             ):
                 kwargs["body"] = transition.request_body.value.ok()
             cases = strategies.combine(
-                [target.as_strategy(generation_mode=mode, __is_stateful_phase=True, **kwargs) for mode in modes]
+                [target.as_strategy(generation_mode=mode, phase=TestPhase.STATEFUL, **kwargs) for mode in modes]
             )
             case = draw(cases)
             if (

{schemathesis-4.0.24.dist-info → schemathesis-4.0.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.0.24
+Version: 4.0.26
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://github.com/schemathesis/schemathesis/blob/master/CHANGELOG.md

{schemathesis-4.0.24.dist-info → schemathesis-4.0.26.dist-info}/RECORD

@@ -5,7 +5,7 @@ schemathesis/errors.py,sha256=T8nobEi5tQX_SkwaYb8JFoIlF9F_vOQVprZ8EVPAhjA,931
 schemathesis/filters.py,sha256=OEub50Ob5sf0Tn3iTeuIaxSMtepF7KVoiEM9wtt5GGA,13433
 schemathesis/hooks.py,sha256=OEnZw5lKSweNdycBRIOsn085rTB-L-iJAjj4ClldkU4,13932
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schemathesis/schemas.py,sha256=glaIjN7JO1mdOCs5_HUFjLWQ-89z8NFBUIuc5p8cLAU,28386
+schemathesis/schemas.py,sha256=thyBKI50sJsj7PE52GvLy9_ktPMDP-fbLM8ZwvdHuD0,28618
 schemathesis/cli/__init__.py,sha256=U9gjzWWpiFhaqevPjZbwyTNjABdpvXETI4HgwdGKnvs,877
 schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
 schemathesis/cli/constants.py,sha256=CVcQNHEiX-joAQmyuEVKWPOSxDHsOw_EXXZsEclzLuY,341
@@ -33,7 +33,7 @@ schemathesis/config/_auth.py,sha256=83RLVPm97W2thbn-yi01Rt94YwOxLG_a5VoxhEfjUjs,
 schemathesis/config/_checks.py,sha256=F0r16eSSiICvoiTUkNNOE2PH73EGd8bikoeZdME_3Yw,10763
 schemathesis/config/_diff_base.py,sha256=-XqS6cTzZC5fplz8_2RSZHDMSAPJhBBIEP6H8wcgHmo,4221
 schemathesis/config/_env.py,sha256=8XfIyrnGNQuCDnfG0lwmKRFbasRUjgeQGBAMupsmtOU,613
-schemathesis/config/_error.py,sha256=TxuuqQ1olwJc7P7ssfxXb1dB_Xn5uVsoazjvYvRxrxA,5437
+schemathesis/config/_error.py,sha256=jfv9chQ4NGoDYypszNGymr0zxXVo65yP0AWK1WVEPIM,5781
 schemathesis/config/_generation.py,sha256=giWs4z17z9nRe_9Z3mAZ3LEoyh4hkcJnlAA6LSy6iEo,5210
 schemathesis/config/_health_check.py,sha256=zC9inla5ibMBlEy5WyM4_TME7ju_KH3Bwfo21RI3Gks,561
 schemathesis/config/_operations.py,sha256=2M36b4MMoFtaaFpe9yG-aWRqh0Qm1dpdk5M0V23X2yA,12129
@@ -45,7 +45,7 @@ schemathesis/config/_rate_limit.py,sha256=ekEW-jP_Ichk_O6hYpj-h2TTTKfp7Fm0nyFUbv
 schemathesis/config/_report.py,sha256=ZECDpaCY4WWHD5UbjvgZoSjLz-rlTvfd5Ivzdgzqf2I,3891
 schemathesis/config/_validator.py,sha256=IcE8geFZ0ZwR18rkIRs25i7pTl7Z84XbjYGUB-mqReU,258
 schemathesis/config/_warnings.py,sha256=sI0VZcTj3dOnphhBwYwU_KTagxr89HGWTtQ99HcY84k,772
-schemathesis/config/schema.json,sha256=wC1qe9M_fXotfmlBOmW_FCTRw9K5YC814-PipMGKllE,18907
+schemathesis/config/schema.json,sha256=AzWZmZaAuAk4g7-EL_-LwGux3VScg81epWdPfz-kqG0,19127
 schemathesis/core/__init__.py,sha256=j862XBH5dXhxsrDg9mE7n4cSSfol0EHdY0ru1d27tCc,1917
 schemathesis/core/compat.py,sha256=9BWCrFoqN2sJIaiht_anxe8kLjYMR7t0iiOkXqLRUZ8,1058
 schemathesis/core/control.py,sha256=IzwIc8HIAEMtZWW0Q0iXI7T1niBpjvcLlbuwOSmy5O8,130
@@ -81,17 +81,17 @@ schemathesis/engine/phases/stateful/__init__.py,sha256=Lz1rgNqCfUSIz173XqCGsiMuU
 schemathesis/engine/phases/stateful/_executor.py,sha256=_303Yqflx1iFNTQI2EfjSp_2T21YvzJJgMSazhpv5JQ,15200
 schemathesis/engine/phases/stateful/context.py,sha256=A7X1SLDOWFpCvFN9IiIeNVZM0emjqatmJL_k9UsO7vM,2946
 schemathesis/engine/phases/unit/__init__.py,sha256=BvZh39LZmXg90Cy_Tn0cQY5y7eWzYvAEmJ43fGKFAt8,8715
-schemathesis/engine/phases/unit/_executor.py,sha256=9MmZoKSBVSPk0LWwN3PZ3iaO9nzpT1Z70yzdEE48YYw,16489
+schemathesis/engine/phases/unit/_executor.py,sha256=tRv_QjwtXOuSZCl_j-S_EnhcrKScr9gyGGZItzg16XI,16190
 schemathesis/engine/phases/unit/_pool.py,sha256=iU0hdHDmohPnEv7_S1emcabuzbTf-Cznqwn0pGQ5wNQ,2480
 schemathesis/generation/__init__.py,sha256=tvNO2FLiY8z3fZ_kL_QJhSgzXfnT4UqwSXMHCwfLI0g,645
 schemathesis/generation/case.py,sha256=zwAwFQ-Fp7SOxCXYOQyAdwAtNwVJe63PdLpvqackFQY,12296
-schemathesis/generation/coverage.py,sha256=2GZIyVfaZ8wAcF1GQohm9pftwNIVeeu5uWhYp8qHKlA,55606
-schemathesis/generation/meta.py,sha256=adkoMuCfzSjHJ9ZDocQn0GnVldSCkLL3eVR5A_jafwM,2552
+schemathesis/generation/coverage.py,sha256=UUtY9OfL8TnSslWCrh17njN6Ik99u_qKxfUqcNNdHKw,56166
+schemathesis/generation/meta.py,sha256=yYR7EB1f5n7RrzWHZ6YATepurnnc_hEe7HnztRbaaA0,2699
 schemathesis/generation/metrics.py,sha256=cZU5HdeAMcLFEDnTbNE56NuNq4P0N4ew-g1NEz5-kt4,2836
 schemathesis/generation/modes.py,sha256=Q1fhjWr3zxabU5qdtLvKfpMFZJAwlW9pnxgenjeXTyU,481
 schemathesis/generation/overrides.py,sha256=OBWqDQPreiliaf2M-oyXppVKHoJkCRzxtwSJx1b6AFw,3759
-schemathesis/generation/hypothesis/__init__.py,sha256=76QYchbfeA-A_G_bP6_BkG5JO9SxIIP1yNRBZa06RvE,1495
-schemathesis/generation/hypothesis/builder.py,sha256=f_5VsqeHKP-07pJZ0CPpW6YSxs9qUEseanAaxwOwdm4,34970
+schemathesis/generation/hypothesis/__init__.py,sha256=jK3G4i0SdcyhqwPQg91RH_yg437lSY-smeIQ-wZLWPc,1959
+schemathesis/generation/hypothesis/builder.py,sha256=zOUIp1n6kKkh_M7HiwtCNzDk3wtepwBEjmT2qt6PenM,36078
 schemathesis/generation/hypothesis/examples.py,sha256=6eGaKUEC3elmKsaqfKj1sLvM8EHc-PWT4NRBq4NI0Rs,1409
 schemathesis/generation/hypothesis/given.py,sha256=sTZR1of6XaHAPWtHx2_WLlZ50M8D5Rjux0GmWkWjDq4,2337
 schemathesis/generation/hypothesis/reporting.py,sha256=uDVow6Ya8YFkqQuOqRsjbzsbyP4KKfr3jA7ZaY4FuKY,279
@@ -116,14 +116,12 @@ schemathesis/python/asgi.py,sha256=5PyvuTBaivvyPUEi3pwJni91K1kX5Zc0u9c6c1D8a1Q,2
 schemathesis/python/wsgi.py,sha256=uShAgo_NChbfYaV1117e6UHp0MTg7jaR0Sy_to3Jmf8,219
 schemathesis/specs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/specs/graphql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schemathesis/specs/graphql/_cache.py,sha256=mlOtzEvdE9gZ1posP7OqHUYlaZyiygL5U_Xda7wphFc,988
 schemathesis/specs/graphql/nodes.py,sha256=bE3G1kNmqJ8OV4igBvIK-UORrkQA6Nofduf87O3TD9I,541
 schemathesis/specs/graphql/scalars.py,sha256=6lew8mnwhrtg23leiEbG43mLGPLlRln8mClCY94XpDA,2680
-schemathesis/specs/graphql/schemas.py,sha256=ezkqgMwx37tMWlhy_I0ahDF1Q44emDSJkyjduq1QGjE,14624
+schemathesis/specs/graphql/schemas.py,sha256=B6FULWIIWoN_gx9OeQOd-6qWsz9yVg5h1XlxFe06XPM,14097
 schemathesis/specs/graphql/validation.py,sha256=-W1Noc1MQmTb4RX-gNXMeU2qkgso4mzVfHxtdLkCPKM,1422
 schemathesis/specs/openapi/__init__.py,sha256=C5HOsfuDJGq_3mv8CRBvRvb0Diy1p0BFdqyEXMS-loE,238
-schemathesis/specs/openapi/_cache.py,sha256=HpglmETmZU0RCHxp3DO_sg5_B_nzi54Zuw9vGzzYCxY,4295
-schemathesis/specs/openapi/_hypothesis.py,sha256=shKwQPWupBSZgZ1m35HjSJi0HX0Yv5wqjdkYWA_EE7U,22399
+schemathesis/specs/openapi/_hypothesis.py,sha256=-DE9jxLcEYn5S5wYTQmIC8Lr8UgyXZ8zIhPaB7qRakc,21308
 schemathesis/specs/openapi/checks.py,sha256=1_YIcGqZ2xSN_1Ob_CIt_HfARSodMCCYNX4SQXx03-c,30150
 schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnKDwCwPLhID4,783
 schemathesis/specs/openapi/converter.py,sha256=LkpCCAxZzET4Qa_3YStSNuhGlsm5G6TVwpxYu6lPO4g,4169
@@ -131,10 +129,10 @@ schemathesis/specs/openapi/definitions.py,sha256=8htclglV3fW6JPBqs59lgM4LnA25Mm9
 schemathesis/specs/openapi/examples.py,sha256=JsAy8Dexw36SUAO5MBB44ji3zEK9Y_JU5d2LRshjEI4,22023
 schemathesis/specs/openapi/formats.py,sha256=8AIS7Uey-Z1wm1WYRqnsVqHwG9d316PdqfKLqwUs7us,3516
 schemathesis/specs/openapi/media_types.py,sha256=F5M6TKl0s6Z5X8mZpPsWDEdPBvxclKRcUOc41eEwKbo,2472
-schemathesis/specs/openapi/parameters.py,sha256=ifu_QQCMUzsUHQAkvsOvLuokns6CzesssmQ3Nd3zxII,14594
+schemathesis/specs/openapi/parameters.py,sha256=XpuZ2sex2aYUzKDK17GXVNWFBmvamuyVtloQ1oGQhLk,14468
 schemathesis/specs/openapi/patterns.py,sha256=GqPZEXMRdWENQxanWjBOalIZ2MQUjuxk21kmdiI703E,18027
 schemathesis/specs/openapi/references.py,sha256=40YcDExPLR2B8EOwt-Csw-5MYFi2xj_DXf91J0Pc9d4,8855
-schemathesis/specs/openapi/schemas.py,sha256=ZhFYxYzm0u9VpPMD5f_tt15l29OMa4-lrofOWf4Q6yM,52790
+schemathesis/specs/openapi/schemas.py,sha256=71fdSVpC3_EDjIMMuQdZV7T32IzhdEHPEVTCZkyE3Co,50301
 schemathesis/specs/openapi/security.py,sha256=6UWYMhL-dPtkTineqqBFNKca1i4EuoTduw-EOLeE0aQ,7149
 schemathesis/specs/openapi/serialization.py,sha256=VdDLmeHqxlWM4cxQQcCkvrU6XurivolwEEaT13ohelA,11972
 schemathesis/specs/openapi/utils.py,sha256=ER4vJkdFVDIE7aKyxyYatuuHVRNutytezgE52pqZNE8,900
@@ -148,7 +146,7 @@ schemathesis/specs/openapi/negative/__init__.py,sha256=1sajF22SrE4pUK7-C6PiseZ9P
 schemathesis/specs/openapi/negative/mutations.py,sha256=xDSUVnGWjuuIcvmW_mJGChf-G-nXst-JBX1okQAzon4,19865
 schemathesis/specs/openapi/negative/types.py,sha256=a7buCcVxNBG6ILBM3A7oNTAX0lyDseEtZndBuej8MbI,174
 schemathesis/specs/openapi/negative/utils.py,sha256=ozcOIuASufLqZSgnKUACjX-EOZrrkuNdXX0SDnLoGYA,168
-schemathesis/specs/openapi/stateful/__init__.py,sha256=t5O84nKXIk_NhFihuSip3EWMLBo4_AG95W_YVbTKPl4,15985
+schemathesis/specs/openapi/stateful/__init__.py,sha256=DaV7Uuo1GTgZF1JjjoQzbzZw5HQhL6pTByiWqIlWwy4,15996
 schemathesis/specs/openapi/stateful/control.py,sha256=QaXLSbwQWtai5lxvvVtQV3BLJ8n5ePqSKB00XFxp-MA,3695
 schemathesis/specs/openapi/stateful/links.py,sha256=h5q40jUbcIk5DS_Tih1cvFJxS_QxxG0_9ZQnTs1A_zo,8806
 schemathesis/transport/__init__.py,sha256=6yg_RfV_9L0cpA6qpbH-SL9_3ggtHQji9CZrpIkbA6s,5321
@@ -157,8 +155,8 @@ schemathesis/transport/prepare.py,sha256=erYXRaxpQokIDzaIuvt_csHcw72iHfCyNq8VNEz
 schemathesis/transport/requests.py,sha256=46aplzhSmBupegPNMawma-iJWCegWkEd6mzdWLTpgM4,10742
 schemathesis/transport/serialization.py,sha256=igUXKZ_VJ9gV7P0TUc5PDQBJXl_s0kK9T3ljGWWvo6E,10339
 schemathesis/transport/wsgi.py,sha256=KoAfvu6RJtzyj24VGB8e-Iaa9smpgXJ3VsM8EgAz2tc,6152
-schemathesis-4.0.24.dist-info/METADATA,sha256=QwSbcsUU-AKUCztu8bJ672YiCaXN7VMvx8sVkbKsuIo,8472
-schemathesis-4.0.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.0.24.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.0.24.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.0.24.dist-info/RECORD,,
+schemathesis-4.0.26.dist-info/METADATA,sha256=-G-Cvrj712t6wjZhCS-FOzJ_57yoPpQMM2scYjSAnI0,8472
+schemathesis-4.0.26.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.0.26.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.0.26.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.0.26.dist-info/RECORD,,

schemathesis/specs/graphql/_cache.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ...schemas import APIOperation, APIOperationMap
-
-
-@dataclass
-class OperationCache:
-    _maps: dict[str, APIOperationMap]
-    _operations: dict[str, APIOperation]
-
-    __slots__ = ("_maps", "_operations")
-
-    def __init__(
-        self,
-        _maps: dict[str, APIOperationMap] | None = None,
-        _operations: dict[str, APIOperation] | None = None,
-    ) -> None:
-        self._maps = _maps or {}
-        self._operations = _operations or {}
-
-    def get_map(self, key: str) -> APIOperationMap | None:
-        return self._maps.get(key)
-
-    def insert_map(self, key: str, value: APIOperationMap) -> None:
-        self._maps[key] = value
-
-    def get_operation(self, key: str) -> APIOperation | None:
-        return self._operations.get(key)
-
-    def insert_operation(self, key: str, value: APIOperation) -> None:
-        self._operations[key] = value

schemathesis/specs/openapi/_cache.py

@@ -1,122 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Tuple
-
-if TYPE_CHECKING:
-    from ...schemas import APIOperation, APIOperationMap
-
-
-@dataclass
-class OperationCacheEntry:
-    path: str
-    method: str
-    # The resolution scope of the operation
-    scope: str
-    # Parent path item
-    path_item: dict[str, Any]
-    # Unresolved operation definition
-    operation: dict[str, Any]
-    __slots__ = ("path", "method", "scope", "path_item", "operation")
-
-
-# During traversal, we need to keep track of the scope, path, and method
-TraversalKey = Tuple[str, str, str]
-OperationId = str
-Reference = str
-
-
-@dataclass
-class OperationCache:
-    """Cache for Open API operations.
-
-    This cache contains multiple levels to avoid unnecessary parsing of the schema.
-    """
-
-    # Cache to avoid schema traversal on every access
-    _id_to_definition: dict[OperationId, OperationCacheEntry] = field(default_factory=dict)
-    # Map map between 1st & 2nd level cache keys
-    # Even though 1st level keys could be directly mapped to Python objects in memory, we need to keep them separate
-    # to ensure a single owner of the operation instance.
-    _id_to_operation: dict[OperationId, int] = field(default_factory=dict)
-    _traversal_key_to_operation: dict[TraversalKey, int] = field(default_factory=dict)
-    _reference_to_operation: dict[Reference, int] = field(default_factory=dict)
-    # The actual operations
-    _operations: list[APIOperation] = field(default_factory=list)
-    # Cache for operation maps
-    _maps: dict[str, APIOperationMap] = field(default_factory=dict)
-
-    @property
-    def known_operation_ids(self) -> list[str]:
-        return list(self._id_to_definition)
-
-    @property
-    def has_ids_to_definitions(self) -> bool:
-        return bool(self._id_to_definition)
-
-    def _append_operation(self, operation: APIOperation) -> int:
-        idx = len(self._operations)
-        self._operations.append(operation)
-        return idx
-
-    def insert_definition_by_id(
-        self,
-        operation_id: str,
-        path: str,
-        method: str,
-        scope: str,
-        path_item: dict[str, Any],
-        operation: dict[str, Any],
-    ) -> None:
-        """Insert a new operation definition into cache."""
-        self._id_to_definition[operation_id] = OperationCacheEntry(
-            path=path, method=method, scope=scope, path_item=path_item, operation=operation
-        )
-
-    def get_definition_by_id(self, operation_id: str) -> OperationCacheEntry:
-        """Get an operation definition by its ID."""
-        # TODO: Avoid KeyError in the future
-        return self._id_to_definition[operation_id]
-
-    def insert_operation(
-        self,
-        operation: APIOperation,
-        *,
-        traversal_key: TraversalKey,
-        operation_id: str | None = None,
-        reference: str | None = None,
-    ) -> None:
-        """Insert a new operation into cache by one or multiple keys."""
-        idx = self._append_operation(operation)
-        self._traversal_key_to_operation[traversal_key] = idx
-        if operation_id is not None:
-            self._id_to_operation[operation_id] = idx
-        if reference is not None:
-            self._reference_to_operation[reference] = idx
-
-    def get_operation_by_id(self, operation_id: str) -> APIOperation | None:
-        """Get an operation by its ID."""
-        idx = self._id_to_operation.get(operation_id)
-        if idx is not None:
-            return self._operations[idx]
-        return None
-
-    def get_operation_by_reference(self, reference: str) -> APIOperation | None:
-        """Get an operation by its reference."""
-        idx = self._reference_to_operation.get(reference)
-        if idx is not None:
-            return self._operations[idx]
-        return None
-
-    def get_operation_by_traversal_key(self, key: TraversalKey) -> APIOperation | None:
-        """Get an operation by its traverse key."""
-        idx = self._traversal_key_to_operation.get(key)
-        if idx is not None:
-            return self._operations[idx]
-        return None
-
-    def get_map(self, key: str) -> APIOperationMap | None:
-        return self._maps.get(key)
-
-    def insert_map(self, key: str, value: APIOperationMap) -> None:
-        self._maps[key] = value