schemathesis 3.25.6__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

schemathesis/schemas.py

@@ -1,65 +1,52 @@
-"""Schema objects provide a convenient interface to raw schemas.
-
-Their responsibilities:
-  - Provide a unified way to work with different types of schemas
-  - Give all paths / methods combinations that are available directly from the schema;
-
-They give only static definitions of paths.
-"""
 from __future__ import annotations
-from collections.abc import Mapping, MutableMapping
-from contextlib import nullcontext
+
+from collections.abc import Mapping
 from dataclasses import dataclass, field
-from functools import lru_cache
+from functools import lru_cache, partial
+from itertools import chain
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
-    ContextManager,
     Generator,
-    Iterable,
+    Generic,
     Iterator,
     NoReturn,
-    Sequence,
     TypeVar,
-    TYPE_CHECKING,
 )
-from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
-
-import hypothesis
-from hypothesis.strategies import SearchStrategy
-from pyrate_limiter import Limiter
+from urllib.parse import quote, unquote, urljoin, urlsplit, urlunsplit
+
+from schemathesis import transport
+from schemathesis.core import NOT_SET, NotSet
+from schemathesis.core.errors import IncorrectUsage, InvalidSchema
+from schemathesis.core.output import OutputConfig
+from schemathesis.core.rate_limit import build_limiter
+from schemathesis.core.result import Ok, Result
+from schemathesis.core.transport import Response
+from schemathesis.generation import GenerationConfig, GenerationMode
+from schemathesis.generation.case import Case
+from schemathesis.generation.hypothesis import strategies
+from schemathesis.generation.hypothesis.given import GivenInput, given_proxy
+from schemathesis.generation.meta import CaseMetadata
+from schemathesis.hooks import HookDispatcherMark
 
-from .constants import NOT_SET
-from ._hypothesis import create_test
 from .auths import AuthStorage
-from .code_samples import CodeSampleStyle
-from .generation import (
-    DEFAULT_DATA_GENERATION_METHODS,
-    DataGenerationMethod,
-    DataGenerationMethodInput,
-    GenerationConfig,
+from .filters import (
+    FilterSet,
+    FilterValue,
+    MatcherFunc,
+    RegexValue,
+    is_deprecated,
 )
-from .exceptions import OperationSchemaError, UsageError
-from .hooks import HookContext, HookDispatcher, HookScope, dispatch
-from .internal.result import Result, Ok
-from .models import APIOperation, Case
-from .stateful.state_machine import APIStateMachine
-from .stateful import Stateful, StatefulTest
-from .types import (
-    Body,
-    Cookies,
-    Filter,
-    FormData,
-    GenericTest,
-    Headers,
-    NotSet,
-    PathParameters,
-    Query,
-)
-from .utils import PARAMETRIZE_MARKER, GivenInput, given_proxy, combine_strategies
+from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, HookScope, dispatch, to_filterable_hook
 
 if TYPE_CHECKING:
-    from .transports.responses import GenericResponse
+    from hypothesis.strategies import SearchStrategy
+    from pyrate_limiter import Limiter
+    from typing_extensions import Self
+
+    from schemathesis.core import Specification
+    from schemathesis.generation.stateful.state_machine import APIStateMachine
 
 
 C = TypeVar("C", bound=Case)
@@ -70,52 +57,140 @@ def get_full_path(base_path: str, path: str) -> str:
     return unquote(urljoin(base_path, quote(path.lstrip("/"))))
 
 
+@dataclass
+class ApiOperationsCount:
+    """Statistics about API operations."""
+
+    total: int
+    selected: int
+
+    __slots__ = ("total", "selected")
+
+    def __init__(self) -> None:
+        self.total = 0
+        self.selected = 0
+
+
 @dataclass(eq=False)
 class BaseSchema(Mapping):
     raw_schema: dict[str, Any]
     location: str | None = None
     base_url: str | None = None
-    method: Filter | None = None
-    endpoint: Filter | None = None
-    tag: Filter | None = None
-    operation_id: Filter | None = None
+    filter_set: FilterSet = field(default_factory=FilterSet)
     app: Any = None
     hooks: HookDispatcher = field(default_factory=lambda: HookDispatcher(scope=HookScope.SCHEMA))
     auth: AuthStorage = field(default_factory=AuthStorage)
-    test_function: GenericTest | None = None
-    validate_schema: bool = True
-    skip_deprecated_operations: bool = False
-    data_generation_methods: list[DataGenerationMethod] = field(
-        default_factory=lambda: list(DEFAULT_DATA_GENERATION_METHODS)
-    )
+    test_function: Callable | None = None
     generation_config: GenerationConfig = field(default_factory=GenerationConfig)
-    code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
+    output_config: OutputConfig = field(default_factory=OutputConfig)
     rate_limiter: Limiter | None = None
-    sanitize_output: bool = True
+    _operations_count: ApiOperationsCount | None = None
+
+    def __post_init__(self) -> None:
+        self.hook = to_filterable_hook(self.hooks)  # type: ignore[method-assign]
+
+    @property
+    def specification(self) -> Specification:
+        raise NotImplementedError
+
+    @property
+    def transport(self) -> transport.BaseTransport:
+        return transport.get(self.app)
+
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
+    def include(
+        self,
+        func: MatcherFunc | None = None,
+        *,
+        name: FilterValue | None = None,
+        name_regex: str | None = None,
+        method: FilterValue | None = None,
+        method_regex: str | None = None,
+        path: FilterValue | None = None,
+        path_regex: str | None = None,
+        tag: FilterValue | None = None,
+        tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
+    ) -> BaseSchema:
+        """Include only operations that match the given filters."""
+        filter_set = self.filter_set.clone()
+        filter_set.include(
+            func,
+            name=name,
+            name_regex=name_regex,
+            method=method,
+            method_regex=method_regex,
+            path=path,
+            path_regex=path_regex,
+            tag=tag,
+            tag_regex=tag_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
+        )
+        return self.clone(filter_set=filter_set)
+
+    def exclude(
+        self,
+        func: MatcherFunc | None = None,
+        *,
+        name: FilterValue | None = None,
+        name_regex: str | None = None,
+        method: FilterValue | None = None,
+        method_regex: str | None = None,
+        path: FilterValue | None = None,
+        path_regex: str | None = None,
+        tag: FilterValue | None = None,
+        tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
+        deprecated: bool = False,
+    ) -> BaseSchema:
+        """Include only operations that match the given filters."""
+        filter_set = self.filter_set.clone()
+        if deprecated:
+            if func is None:
+                func = is_deprecated
+            else:
+                filter_set.exclude(is_deprecated)
+        filter_set.exclude(
+            func,
+            name=name,
+            name_regex=name_regex,
+            method=method,
+            method_regex=method_regex,
+            path=path,
+            path_regex=path_regex,
+            tag=tag,
+            tag_regex=tag_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
+        )
+        return self.clone(filter_set=filter_set)
 
     def __iter__(self) -> Iterator[str]:
-        return iter(self.operations)
+        raise NotImplementedError
 
     def __getitem__(self, item: str) -> APIOperationMap:
         __tracebackhide__ = True
         try:
-            return self.operations[item]
+            return self._get_operation_map(item)
         except KeyError as exc:
             self.on_missing_operation(item, exc)
 
+    def _get_operation_map(self, key: str) -> APIOperationMap:
+        raise NotImplementedError
+
     def on_missing_operation(self, item: str, exc: KeyError) -> NoReturn:
         raise NotImplementedError
 
     def __len__(self) -> int:
-        return len(self.operations)
+        return self.count_operations().total
 
     def hook(self, hook: str | Callable) -> Callable:
         return self.hooks.register(hook)
 
-    @property
-    def verbose_name(self) -> str:
-        raise NotImplementedError
-
     def get_full_path(self, path: str) -> str:
         """Compute full path for the given path."""
         return get_full_path(self.base_path, path)
@@ -150,20 +225,14 @@ class BaseSchema(Mapping):
     def validate(self) -> None:
         raise NotImplementedError
 
-    @property
-    def operations(self) -> dict[str, APIOperationMap]:
-        if not hasattr(self, "_operations"):
-            operations = self.get_all_operations()
-            self._operations = self._store_operations(operations)
-        return self._operations
-
-    def _store_operations(
-        self, operations: Generator[Result[APIOperation, OperationSchemaError], None, None]
-    ) -> dict[str, APIOperationMap]:
-        raise NotImplementedError
+    def count_operations(self) -> ApiOperationsCount:
+        """Count total and selected operations."""
+        if self._operations_count is None:
+            self._operations_count = self._do_count_operations()
+        return self._operations_count
 
-    @property
-    def operations_count(self) -> int:
+    def _do_count_operations(self) -> ApiOperationsCount:
+        """Implementation-specific counting logic."""
         raise NotImplementedError
 
     @property
@@ -171,11 +240,11 @@ class BaseSchema(Mapping):
         raise NotImplementedError
 
     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]:
         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
 
@@ -183,70 +252,20 @@ class BaseSchema(Mapping):
         """Get applied security requirements for the given API operation."""
         raise NotImplementedError
 
-    def get_stateful_tests(
-        self, response: GenericResponse, operation: APIOperation, stateful: Stateful | None
-    ) -> Sequence[StatefulTest]:
-        """Get a list of additional tests, that should be executed after this response from the API operation."""
-        raise NotImplementedError
-
     def get_parameter_serializer(self, operation: APIOperation, location: str) -> Callable | None:
         """Get a function that serializes parameters for the given location."""
         raise NotImplementedError
 
-    def get_all_tests(
-        self,
-        func: Callable,
-        settings: hypothesis.settings | None = None,
-        generation_config: GenerationConfig | None = None,
-        seed: int | None = None,
-        as_strategy_kwargs: dict[str, Any] | Callable[[APIOperation], dict[str, Any]] | None = None,
-        hooks: HookDispatcher | None = None,
-        _given_kwargs: dict[str, GivenInput] | None = None,
-    ) -> Generator[Result[tuple[APIOperation, Callable], OperationSchemaError], None, None]:
-        """Generate all operations and Hypothesis tests for them."""
-        for result in self.get_all_operations(hooks=hooks):
-            if isinstance(result, Ok):
-                operation = result.ok()
-                _as_strategy_kwargs: dict[str, Any] | None
-                if callable(as_strategy_kwargs):
-                    _as_strategy_kwargs = as_strategy_kwargs(operation)
-                else:
-                    _as_strategy_kwargs = as_strategy_kwargs
-                test = create_test(
-                    operation=operation,
-                    test=func,
-                    settings=settings,
-                    seed=seed,
-                    data_generation_methods=self.data_generation_methods,
-                    generation_config=generation_config,
-                    as_strategy_kwargs=_as_strategy_kwargs,
-                    _given_kwargs=_given_kwargs,
-                )
-                yield Ok((operation, test))
-            else:
-                yield result
-
-    def parametrize(
-        self,
-        method: Filter | None = NOT_SET,
-        endpoint: Filter | None = NOT_SET,
-        tag: Filter | None = NOT_SET,
-        operation_id: Filter | None = NOT_SET,
-        validate_schema: bool | NotSet = NOT_SET,
-        skip_deprecated_operations: bool | NotSet = NOT_SET,
-        data_generation_methods: Iterable[DataGenerationMethod] | NotSet = NOT_SET,
-        code_sample_style: str | NotSet = NOT_SET,
-    ) -> Callable:
+    def parametrize(self) -> Callable:
         """Mark a test function as a parametrized one."""
-        _code_sample_style = (
-            CodeSampleStyle.from_str(code_sample_style) if isinstance(code_sample_style, str) else code_sample_style
-        )
 
-        def wrapper(func: GenericTest) -> GenericTest:
-            if hasattr(func, PARAMETRIZE_MARKER):
+        def wrapper(func: Callable) -> Callable:
+            from schemathesis.pytest.plugin import SchemaHandleMark
+
+            if SchemaHandleMark.is_set(func):
 
                 def wrapped_test(*_: Any, **__: Any) -> NoReturn:
-                    raise UsageError(
+                    raise IncorrectUsage(
                         f"You have applied `parametrize` to the `{func.__name__}` test more than once, which "
                         "overrides the previous decorator. "
                         "The `parametrize` decorator could be applied to the same function at most once."
@@ -254,18 +273,8 @@ class BaseSchema(Mapping):
 
                 return wrapped_test
             HookDispatcher.add_dispatcher(func)
-            cloned = self.clone(
-                test_function=func,
-                method=method,
-                endpoint=endpoint,
-                tag=tag,
-                operation_id=operation_id,
-                validate_schema=validate_schema,
-                skip_deprecated_operations=skip_deprecated_operations,
-                data_generation_methods=data_generation_methods,
-                code_sample_style=_code_sample_style,  # type: ignore
-            )
-            setattr(func, PARAMETRIZE_MARKER, cloned)
+            cloned = self.clone(test_function=func)
+            SchemaHandleMark.set(func, cloned)
             return func
 
         return wrapper
@@ -275,75 +284,29 @@ class BaseSchema(Mapping):
         return given_proxy(*args, **kwargs)
 
     def clone(
-        self,
-        *,
-        base_url: str | None | NotSet = NOT_SET,
-        test_function: GenericTest | None = None,
-        method: Filter | None = NOT_SET,
-        endpoint: Filter | None = NOT_SET,
-        tag: Filter | None = NOT_SET,
-        operation_id: Filter | None = NOT_SET,
-        app: Any = NOT_SET,
-        hooks: HookDispatcher | NotSet = NOT_SET,
-        auth: AuthStorage | NotSet = NOT_SET,
-        validate_schema: bool | NotSet = NOT_SET,
-        skip_deprecated_operations: bool | NotSet = NOT_SET,
-        data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
-        generation_config: GenerationConfig | NotSet = NOT_SET,
-        code_sample_style: CodeSampleStyle | NotSet = NOT_SET,
-        rate_limiter: Limiter | None = NOT_SET,
-        sanitize_output: bool | NotSet | None = NOT_SET,
+        self, *, test_function: Callable | NotSet = NOT_SET, filter_set: FilterSet | NotSet = NOT_SET
     ) -> BaseSchema:
-        if base_url is NOT_SET:
-            base_url = self.base_url
-        if method is NOT_SET:
-            method = self.method
-        if endpoint is NOT_SET:
-            endpoint = self.endpoint
-        if tag is NOT_SET:
-            tag = self.tag
-        if operation_id is NOT_SET:
-            operation_id = self.operation_id
-        if app is NOT_SET:
-            app = self.app
-        if validate_schema is NOT_SET:
-            validate_schema = self.validate_schema
-        if skip_deprecated_operations is NOT_SET:
-            skip_deprecated_operations = self.skip_deprecated_operations
-        if hooks is NOT_SET:
-            hooks = self.hooks
-        if auth is NOT_SET:
-            auth = self.auth
-        if data_generation_methods is NOT_SET:
-            data_generation_methods = self.data_generation_methods
-        if generation_config is NOT_SET:
-            generation_config = self.generation_config
-        if code_sample_style is NOT_SET:
-            code_sample_style = self.code_sample_style
-        if rate_limiter is NOT_SET:
-            rate_limiter = self.rate_limiter
-        if sanitize_output is NOT_SET:
-            sanitize_output = self.sanitize_output
+        if isinstance(test_function, NotSet):
+            _test_function = self.test_function
+        else:
+            _test_function = test_function
+        if isinstance(filter_set, NotSet):
+            _filter_set = self.filter_set
+        else:
+            _filter_set = filter_set
 
         return self.__class__(
             self.raw_schema,
             location=self.location,
-            base_url=base_url,  # type: ignore
-            method=method,
-            endpoint=endpoint,
-            tag=tag,
-            operation_id=operation_id,
-            app=app,
-            hooks=hooks,  # type: ignore
-            auth=auth,  # type: ignore
-            test_function=test_function,
-            validate_schema=validate_schema,  # type: ignore
-            skip_deprecated_operations=skip_deprecated_operations,  # type: ignore
-            data_generation_methods=data_generation_methods,  # type: ignore
-            generation_config=generation_config,  # type: ignore
-            code_sample_style=code_sample_style,  # type: ignore
-            rate_limiter=rate_limiter,  # type: ignore
-            sanitize_output=sanitize_output,  # type: ignore
+            base_url=self.base_url,
+            app=self.app,
+            hooks=self.hooks,
+            auth=self.auth,
+            test_function=_test_function,
+            generation_config=self.generation_config,
+            output_config=self.output_config,
+            rate_limiter=self.rate_limiter,
+            filter_set=_filter_set,
         )
 
     def get_local_hook_dispatcher(self) -> HookDispatcher | None:
@@ -351,7 +314,7 @@ class BaseSchema(Mapping):
         # It might be not present when it is used without pytest via `APIOperation.as_strategy()`
         if self.test_function is not None:
             # Might be missing it in case of `LazySchema` usage
-            return getattr(self.test_function, "_schemathesis_hooks", None)  # type: ignore
+            return HookDispatcherMark.get(self.test_function)
         return None
 
     def dispatch_hook(self, name: str, context: HookContext, *args: Any, **kwargs: Any) -> None:
@@ -363,7 +326,7 @@ class BaseSchema(Mapping):
             local_dispatcher.dispatch(name, context, *args, **kwargs)
 
     def prepare_multipart(
-        self, form_data: FormData, operation: APIOperation
+        self, form_data: dict[str, Any], operation: APIOperation
     ) -> tuple[list | None, dict[str, Any] | None]:
         """Split content of `form_data` into files & data.
 
@@ -377,15 +340,17 @@ class BaseSchema(Mapping):
     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:
         raise NotImplementedError
 
     def get_case_strategy(
@@ -393,17 +358,14 @@ class BaseSchema(Mapping):
         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:
         raise NotImplementedError
 
     def as_state_machine(self) -> type[APIStateMachine]:
-        """Create a state machine class.
-
-        Use it for stateful testing.
-        """
+        """Create a state machine class."""
         raise NotImplementedError
 
     def get_links(self, operation: APIOperation) -> dict[str, dict[str, Any]]:
@@ -412,19 +374,12 @@ class BaseSchema(Mapping):
     def get_tags(self, operation: APIOperation) -> list[str] | None:
         raise NotImplementedError
 
-    def validate_response(self, operation: APIOperation, response: GenericResponse) -> bool | None:
+    def validate_response(self, operation: APIOperation, response: Response) -> bool | None:
         raise NotImplementedError
 
     def prepare_schema(self, schema: Any) -> Any:
         raise NotImplementedError
 
-    def ratelimit(self) -> ContextManager:
-        """Limit the rate of sending generated requests."""
-        label = urlparse(self.base_url).netloc
-        if self.rate_limiter is not None:
-            return self.rate_limiter.ratelimit(label, delay=True, max_delay=0)
-        return nullcontext()
-
     def _get_payload_schema(self, definition: dict[str, Any], media_type: str) -> dict[str, Any] | None:
         raise NotImplementedError
 
@@ -432,63 +387,384 @@ class BaseSchema(Mapping):
         self,
         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:
         """Build a strategy for generating test cases for all defined API operations."""
-        assert len(self.operations) > 0, "No API operations found"
-        strategies = [
-            operation.as_strategy(
+        _strategies = [
+            operation.ok().as_strategy(
                 hooks=hooks,
                 auth_storage=auth_storage,
-                data_generation_method=data_generation_method,
+                generation_mode=generation_mode,
                 generation_config=generation_config,
                 **kwargs,
             )
-            for operations in self.operations.values()
-            for operation in operations.values()
+            for operation in self.get_all_operations()
+            if isinstance(operation, Ok)
         ]
-        return combine_strategies(strategies)
+        return strategies.combine(_strategies)
 
+    def configure(
+        self,
+        *,
+        base_url: str | None | NotSet = NOT_SET,
+        location: str | None | NotSet = NOT_SET,
+        rate_limit: str | None | NotSet = NOT_SET,
+        generation: GenerationConfig | NotSet = NOT_SET,
+        output: OutputConfig | NotSet = NOT_SET,
+        app: Any | NotSet = NOT_SET,
+    ) -> Self:
+        if not isinstance(base_url, NotSet):
+            self.base_url = base_url
+        if not isinstance(location, NotSet):
+            self.location = location
+        if not isinstance(rate_limit, NotSet):
+            if isinstance(rate_limit, str):
+                self.rate_limiter = build_limiter(rate_limit)
+            else:
+                self.rate_limiter = None
+        if not isinstance(generation, NotSet):
+            self.generation_config = generation
+        if not isinstance(output, NotSet):
+            self.output_config = output
+        if not isinstance(app, NotSet):
+            self.app = app
+        return self
 
-@dataclass
-class APIOperationMap(MutableMapping):
-    data: MutableMapping
 
-    def __setitem__(self, key: str, value: APIOperation) -> None:
-        self.data[key] = value
+@dataclass
+class APIOperationMap(Mapping):
+    _schema: BaseSchema
+    _data: Mapping
 
     def __getitem__(self, item: str) -> APIOperation:
-        return self.data[item]
-
-    def __delitem__(self, key: str) -> None:
-        del self.data[key]
+        return self._data[item]
 
     def __len__(self) -> int:
-        return len(self.data)
+        return len(self._data)
 
     def __iter__(self) -> Iterator[str]:
-        return iter(self.data)
+        return iter(self._data)
 
     def as_strategy(
         self,
         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:
         """Build a strategy for generating test cases for all API operations defined in this subset."""
-        assert len(self.data) > 0, "No API operations found"
-        strategies = [
+        _strategies = [
             operation.as_strategy(
                 hooks=hooks,
                 auth_storage=auth_storage,
-                data_generation_method=data_generation_method,
+                generation_mode=generation_mode,
                 generation_config=generation_config,
                 **kwargs,
             )
-            for operation in self.data.values()
+            for operation in self._data.values()
         ]
-        return combine_strategies(strategies)
+        return strategies.combine(_strategies)
+
+
+@dataclass(eq=False)
+class Parameter:
+    """A logically separate parameter bound to a location (e.g., to "query string").
+
+    For example, if the API requires multiple headers to be present, each header is presented as a separate
+    `Parameter` instance.
+    """
+
+    # The parameter definition in the language acceptable by the API
+    definition: Any
+
+    @property
+    def location(self) -> str:
+        """Where this parameter is located.
+
+        E.g. "query" or "body"
+        """
+        raise NotImplementedError
+
+    @property
+    def name(self) -> str:
+        """Parameter name."""
+        raise NotImplementedError
+
+    @property
+    def is_required(self) -> bool:
+        """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)
+
+
+@dataclass
+class ParameterSet(Generic[P]):
+    """A set of parameters for the same location."""
+
+    items: list[P] = field(default_factory=list)
+
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
+    def add(self, parameter: P) -> None:
+        """Add a new parameter."""
+        self.items.append(parameter)
+
+    def get(self, name: str) -> P | None:
+        for parameter in self:
+            if parameter.name == name:
+                return parameter
+        return None
+
+    def contains(self, name: str) -> bool:
+        return self.get(name) is not None
+
+    def __contains__(self, item: str) -> bool:
+        return self.contains(item)
+
+    def __bool__(self) -> bool:
+        return bool(self.items)
+
+    def __iter__(self) -> Generator[P, None, None]:
+        yield from iter(self.items)
+
+    def __len__(self) -> int:
+        return len(self.items)
+
+    def __getitem__(self, item: int) -> P:
+        return self.items[item]
+
+
+class PayloadAlternatives(ParameterSet[P]):
+    """A set of alternative payloads."""
+
+
+D = TypeVar("D", bound=dict)
+
+
+@dataclass(repr=False)
+class OperationDefinition(Generic[D]):
+    """A wrapper to store not resolved API operation definitions.
+
+    To prevent recursion errors we need to store definitions without resolving references. But operation definitions
+    itself can be behind a reference (when there is a ``$ref`` in ``paths`` values), therefore we need to store this
+    scope change to have a proper reference resolving later.
+    """
+
+    raw: D
+    resolved: D
+    scope: str
+
+    __slots__ = ("raw", "resolved", "scope")
+
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
+
+@dataclass(eq=False)
+class APIOperation(Generic[P]):
+    """A single operation defined in an API.
+
+    You can get one via a ``schema`` instance.
+
+    .. code-block:: python
+
+        # Get the POST /items operation
+        operation = schema["/items"]["POST"]
+
+    """
+
+    # `path` does not contain `basePath`
+    # Example <scheme>://<host>/<basePath>/users - "/users" is path
+    # https://swagger.io/docs/specification/2-0/api-host-and-base-path/
+    path: str
+    method: str
+    definition: OperationDefinition = field(repr=False)
+    schema: BaseSchema
+    label: str = None  # type: ignore
+    app: Any = None
+    base_url: str | None = None
+    path_parameters: ParameterSet[P] = field(default_factory=ParameterSet)
+    headers: ParameterSet[P] = field(default_factory=ParameterSet)
+    cookies: ParameterSet[P] = field(default_factory=ParameterSet)
+    query: ParameterSet[P] = field(default_factory=ParameterSet)
+    body: PayloadAlternatives[P] = field(default_factory=PayloadAlternatives)
+
+    def __post_init__(self) -> None:
+        if self.label is None:
+            self.label = f"{self.method.upper()} {self.full_path}"  # type: ignore
+
+    @property
+    def full_path(self) -> str:
+        return self.schema.get_full_path(self.path)
+
+    @property
+    def links(self) -> dict[str, dict[str, Any]]:
+        return self.schema.get_links(self)
+
+    @property
+    def tags(self) -> list[str] | None:
+        return self.schema.get_tags(self)
+
+    def iter_parameters(self) -> Iterator[P]:
+        """Iterate over all operation's parameters."""
+        return chain(self.path_parameters, self.headers, self.cookies, self.query)
+
+    def _lookup_container(self, location: str) -> ParameterSet[P] | PayloadAlternatives[P] | None:
+        return {
+            "path": self.path_parameters,
+            "header": self.headers,
+            "cookie": self.cookies,
+            "query": self.query,
+            "body": self.body,
+        }.get(location)
+
+    def add_parameter(self, parameter: P) -> None:
+        """Add a new processed parameter to an API operation.
+
+        :param parameter: A parameter that will be used with this operation.
+        :rtype: None
+        """
+        # If the parameter has a typo, then by default, there will be an error from `jsonschema` earlier.
+        # But if the user wants to skip schema validation, we choose to ignore a malformed parameter.
+        # In this case, we still might generate some tests for an API operation, but without this parameter,
+        # which is better than skip the whole operation from testing.
+        container = self._lookup_container(parameter.location)
+        if container is not None:
+            container.add(parameter)
+
+    def get_parameter(self, name: str, location: str) -> P | None:
+        container = self._lookup_container(location)
+        if container is not None:
+            return container.get(name)
+        return None
+
+    def as_strategy(
+        self,
+        hooks: HookDispatcher | None = None,
+        auth_storage: AuthStorage | None = None,
+        generation_mode: GenerationMode = GenerationMode.default(),
+        generation_config: GenerationConfig | None = None,
+        **kwargs: Any,
+    ) -> SearchStrategy[Case]:
+        """Turn this API operation into a Hypothesis strategy."""
+        strategy = self.schema.get_case_strategy(
+            self, hooks, auth_storage, generation_mode, generation_config=generation_config, **kwargs
+        )
+
+        def _apply_hooks(dispatcher: HookDispatcher, _strategy: SearchStrategy[Case]) -> SearchStrategy[Case]:
+            context = HookContext(self)
+            for hook in dispatcher.get_all_by_name("before_generate_case"):
+                _strategy = hook(context, _strategy)
+            for hook in dispatcher.get_all_by_name("filter_case"):
+                hook = partial(hook, context)
+                _strategy = _strategy.filter(hook)
+            for hook in dispatcher.get_all_by_name("map_case"):
+                hook = partial(hook, context)
+                _strategy = _strategy.map(hook)
+            for hook in dispatcher.get_all_by_name("flatmap_case"):
+                hook = partial(hook, context)
+                _strategy = _strategy.flatmap(hook)
+            return _strategy
+
+        strategy = _apply_hooks(GLOBAL_HOOK_DISPATCHER, strategy)
+        strategy = _apply_hooks(self.schema.hooks, strategy)
+        if hooks is not None:
+            strategy = _apply_hooks(hooks, strategy)
+        return strategy
+
+    def get_security_requirements(self) -> list[str]:
+        return self.schema.get_security_requirements(self)
+
+    def get_strategies_from_examples(self, **kwargs: Any) -> list[SearchStrategy[Case]]:
+        """Get examples from the API operation."""
+        kwargs.setdefault("generation_config", self.schema.generation_config)
+        return self.schema.get_strategies_from_examples(self, **kwargs)
+
+    def get_parameter_serializer(self, location: str) -> Callable | None:
+        """Get a function that serializes parameters for the given location.
+
+        It handles serializing data into various `collectionFormat` options and similar.
+        Note that payload is handled by this function - it is handled by serializers.
+        """
+        return self.schema.get_parameter_serializer(self, location)
+
+    def prepare_multipart(self, form_data: dict[str, Any]) -> tuple[list | None, dict[str, Any] | None]:
+        return self.schema.prepare_multipart(form_data, self)
+
+    def get_request_payload_content_types(self) -> list[str]:
+        return self.schema.get_request_payload_content_types(self)
+
+    def _get_default_media_type(self) -> str:
+        # If the user wants to send payload, then there should be a media type, otherwise the payload is ignored
+        media_types = self.get_request_payload_content_types()
+        if len(media_types) == 1:
+            # The only available option
+            return media_types[0]
+        media_types_repr = ", ".join(media_types)
+        raise IncorrectUsage(
+            "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}"
+        )
+
+    def Case(
+        self,
+        *,
+        method: 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,
+        meta: CaseMetadata | None = None,
+    ) -> Case:
+        """Create a new example for this API operation.
+
+        The main use case is constructing Case instances completely manually, without data generation.
+        """
+        return self.schema.make_case(
+            operation=self,
+            method=method,
+            path_parameters=path_parameters,
+            headers=headers,
+            cookies=cookies,
+            query=query,
+            body=body,
+            media_type=media_type,
+            meta=meta,
+        )
+
+    @property
+    def operation_reference(self) -> str:
+        path = self.path.replace("~", "~0").replace("/", "~1")
+        return f"#/paths/{path}/{self.method}"
+
+    def validate_response(self, response: Response) -> bool | None:
+        """Validate API response for conformance.
+
+        :raises FailureGroup: If the response does not conform to the API schema.
+        """
+        return self.schema.validate_response(self, response)
+
+    def is_response_valid(self, response: Response) -> bool:
+        """Validate API response for conformance."""
+        try:
+            self.validate_response(response)
+            return True
+        except AssertionError:
+            return False
+
+    def get_raw_payload_schema(self, media_type: str) -> dict[str, Any] | None:
+        return self.schema._get_payload_schema(self.definition.raw, media_type)
+
+    def get_resolved_payload_schema(self, media_type: str) -> dict[str, Any] | None:
+        return self.schema._get_payload_schema(self.definition.resolved, media_type)