schemathesis 3.39.16__py3-none-any.whl → 4.0.0__py3-none-any.whl

schemathesis/schemas.py

@@ -1,72 +1,53 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
-from contextlib import nullcontext
 from dataclasses import dataclass, field
-from functools import lru_cache
+from functools import cached_property, lru_cache, partial
+from itertools import chain
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    ContextManager,
     Generator,
-    Iterable,
+    Generic,
     Iterator,
     NoReturn,
-    Sequence,
     TypeVar,
 )
-from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
+from urllib.parse import quote, unquote, urljoin, urlsplit, urlunsplit
+
+from schemathesis import transport
+from schemathesis.config import ProjectConfig
+from schemathesis.core import NOT_SET, NotSet
+from schemathesis.core.errors import IncorrectUsage, InvalidSchema
+from schemathesis.core.result import Ok, Result
+from schemathesis.core.transport import Response
+from schemathesis.generation import 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 ._dependency_versions import IS_PYRATE_LIMITER_ABOVE_3
-from ._hypothesis import create_test
 from .auths import AuthStorage
-from .code_samples import CodeSampleStyle
-from .constants import NOT_SET
-from .exceptions import OperationSchemaError, UsageError
 from .filters import (
     FilterSet,
     FilterValue,
     MatcherFunc,
     RegexValue,
-    filter_set_from_components,
     is_deprecated,
 )
-from .generation import (
-    DEFAULT_DATA_GENERATION_METHODS,
-    DataGenerationMethod,
-    DataGenerationMethodInput,
-    GenerationConfig,
-    combine_strategies,
-)
-from .hooks import HookContext, HookDispatcher, HookScope, dispatch, to_filterable_hook
-from .internal.deprecation import warn_filtration_arguments
-from .internal.output import OutputConfig
-from .internal.result import Ok, Result
-from .models import APIOperation, Case
-from .utils import PARAMETRIZE_MARKER, GivenInput, given_proxy
+from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, HookScope, dispatch, to_filterable_hook
 
 if TYPE_CHECKING:
-    import hypothesis
+    import httpx
+    import requests
     from hypothesis.strategies import SearchStrategy
-    from pyrate_limiter import Limiter
-
-    from .stateful import Stateful, StatefulTest
-    from .stateful.state_machine import APIStateMachine
-    from .transports import Transport
-    from .transports.responses import GenericResponse
-    from .types import (
-        Body,
-        Cookies,
-        Filter,
-        FormData,
-        GenericTest,
-        Headers,
-        NotSet,
-        PathParameters,
-        Query,
-        Specification,
-    )
+    from requests.structures import CaseInsensitiveDict
+    from werkzeug.test import TestResponse
+
+    from schemathesis.core import Specification
+    from schemathesis.generation.stateful.state_machine import APIStateMachine
 
 
 C = TypeVar("C", bound=Case)
@@ -77,31 +58,70 @@ def get_full_path(base_path: str, path: str) -> str:
     return unquote(urljoin(base_path, quote(path.lstrip("/"))))
 
 
+@dataclass
+class FilteredCount:
+    """Count of total items and those passing filters."""
+
+    total: int
+    selected: int
+
+    __slots__ = ("total", "selected")
+
+    def __init__(self) -> None:
+        self.total = 0
+        self.selected = 0
+
+
+@dataclass
+class ApiStatistic:
+    """Statistics about API operations and links."""
+
+    operations: FilteredCount
+    links: FilteredCount
+
+    __slots__ = ("operations", "links")
+
+    def __init__(self) -> None:
+        self.operations = FilteredCount()
+        self.links = FilteredCount()
+
+
+@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]
-    transport: Transport
-    specification: Specification
+    config: ProjectConfig
     location: str | None = None
-    base_url: str | 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
-    data_generation_methods: list[DataGenerationMethod] = field(
-        default_factory=lambda: list(DEFAULT_DATA_GENERATION_METHODS)
-    )
-    generation_config: GenerationConfig = field(default_factory=GenerationConfig)
-    output_config: OutputConfig = field(default_factory=OutputConfig)
-    code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
-    rate_limiter: Limiter | None = None
-    sanitize_output: bool = True
+    test_function: Callable | 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(
@@ -119,7 +139,25 @@ class BaseSchema(Mapping):
         operation_id: FilterValue | None = None,
         operation_id_regex: RegexValue | None = None,
     ) -> BaseSchema:
-        """Include only operations that match the given filters."""
+        """Return a new schema containing only operations matching the specified criteria.
+
+        Args:
+            func: Custom filter function that accepts operation context.
+            name: Operation name(s) to include.
+            name_regex: Regex pattern for operation names.
+            method: HTTP method(s) to include.
+            method_regex: Regex pattern for HTTP methods.
+            path: API path(s) to include.
+            path_regex: Regex pattern for API paths.
+            tag: OpenAPI tag(s) to include.
+            tag_regex: Regex pattern for OpenAPI tags.
+            operation_id: Operation ID(s) to include.
+            operation_id_regex: Regex pattern for operation IDs.
+
+        Returns:
+            New schema instance with applied include filters.
+
+        """
         filter_set = self.filter_set.clone()
         filter_set.include(
             func,
@@ -152,7 +190,26 @@ class BaseSchema(Mapping):
         operation_id_regex: RegexValue | None = None,
         deprecated: bool = False,
     ) -> BaseSchema:
-        """Include only operations that match the given filters."""
+        """Return a new schema excluding operations matching the specified criteria.
+
+        Args:
+            func: Custom filter function that accepts operation context.
+            name: Operation name(s) to exclude.
+            name_regex: Regex pattern for operation names.
+            method: HTTP method(s) to exclude.
+            method_regex: Regex pattern for HTTP methods.
+            path: API path(s) to exclude.
+            path_regex: Regex pattern for API paths.
+            tag: OpenAPI tag(s) to exclude.
+            tag_regex: Regex pattern for OpenAPI tags.
+            operation_id: Operation ID(s) to exclude.
+            operation_id_regex: Regex pattern for operation IDs.
+            deprecated: Whether to exclude deprecated operations.
+
+        Returns:
+            New schema instance with applied exclude filters.
+
+        """
         filter_set = self.filter_set.clone()
         if deprecated:
             if func is None:
@@ -191,17 +248,18 @@ class BaseSchema(Mapping):
         raise NotImplementedError
 
     def __len__(self) -> int:
-        return self.operations_count
+        return self.statistic.operations.total
 
     def hook(self, hook: str | Callable) -> Callable:
-        return self.hooks.register(hook)
+        """Register a hook function for this schema only.
 
-    @property
-    def verbose_name(self) -> str:
-        raise NotImplementedError
+        Args:
+            hook: Hook name string or hook function to register.
+
+        """
+        return self.hooks.hook(hook)
 
     def get_full_path(self, path: str) -> str:
-        """Compute full path for the given path."""
         return get_full_path(self.base_path, path)
 
     @property
@@ -209,8 +267,8 @@ class BaseSchema(Mapping):
         """Base path for the schema."""
         # if `base_url` is specified, then it should include base path
         # Example: http://127.0.0.1:8080/api
-        if self.base_url:
-            path = urlsplit(self.base_url).path
+        if self.config.base_url:
+            path = urlsplit(self.config.base_url).path
         else:
             path = self._get_base_path()
         if not path.endswith("/"):
@@ -226,7 +284,7 @@ class BaseSchema(Mapping):
         return urlunsplit(parts)
 
     def get_base_url(self) -> str:
-        base_url = self.base_url
+        base_url = self.config.base_url
         if base_url is not None:
             return base_url.rstrip("/")
         return self._build_base_url()
@@ -234,108 +292,46 @@ class BaseSchema(Mapping):
     def validate(self) -> None:
         raise NotImplementedError
 
-    @property
-    def operations_count(self) -> int:
-        raise NotImplementedError
+    @cached_property
+    def statistic(self) -> ApiStatistic:
+        return self._measure_statistic()
 
-    @property
-    def links_count(self) -> int:
+    def _measure_statistic(self) -> ApiStatistic:
         raise NotImplementedError
 
-    def get_all_operations(
-        self, hooks: HookDispatcher | None = None, generation_config: GenerationConfig | None = None
-    ) -> Generator[Result[APIOperation, OperationSchemaError], None, None]:
+    def get_all_operations(self) -> Generator[Result[APIOperation, InvalidSchema], None, None]:
         raise NotImplementedError
 
-    def get_strategies_from_examples(
-        self, operation: APIOperation, as_strategy_kwargs: dict[str, Any] | None = None
-    ) -> list[SearchStrategy[Case]]:
-        """Get examples from the API operation."""
+    def get_strategies_from_examples(self, operation: APIOperation, **kwargs: Any) -> list[SearchStrategy[Case]]:
         raise NotImplementedError
 
     def get_security_requirements(self, operation: APIOperation) -> list[str]:
-        """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, generation_config=generation_config):
-            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) -> Callable:
+        """Return a decorator that marks a test function for `pytest` parametrization.
 
-    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:
-        """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
-        )
+        The decorated test function will be parametrized with test cases generated
+        from the schema's API operations.
 
-        for name in ("method", "endpoint", "tag", "operation_id", "skip_deprecated_operations"):
-            value = locals()[name]
-            if value is not NOT_SET:
-                warn_filtration_arguments(name)
+        Returns:
+            Decorator function for test parametrization.
 
-        filter_set = filter_set_from_components(
-            include=True,
-            method=method,
-            endpoint=endpoint,
-            tag=tag,
-            operation_id=operation_id,
-            skip_deprecated_operations=skip_deprecated_operations,
-            parent=self.filter_set,
-        )
+        Raises:
+            IncorrectUsage: If applied to the same function multiple times.
+
+        """
 
-        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."
@@ -343,94 +339,53 @@ class BaseSchema(Mapping):
 
                 return wrapped_test
             HookDispatcher.add_dispatcher(func)
-            cloned = self.clone(
-                test_function=func,
-                validate_schema=validate_schema,
-                data_generation_methods=data_generation_methods,
-                filter_set=filter_set,
-                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
 
     def given(self, *args: GivenInput, **kwargs: GivenInput) -> Callable:
-        """Proxy Hypothesis strategies to ``hypothesis.given``."""
+        """Proxy to Hypothesis's `given` decorator for adding custom strategies.
+
+        Args:
+            *args: Positional arguments passed to `hypothesis.given`.
+            **kwargs: Keyword arguments passed to `hypothesis.given`.
+
+        """
         return given_proxy(*args, **kwargs)
 
     def clone(
-        self,
-        *,
-        base_url: str | None | NotSet = NOT_SET,
-        test_function: GenericTest | None = None,
-        app: Any = NOT_SET,
-        hooks: HookDispatcher | NotSet = NOT_SET,
-        auth: AuthStorage | NotSet = NOT_SET,
-        validate_schema: bool | NotSet = NOT_SET,
-        data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
-        generation_config: GenerationConfig | NotSet = NOT_SET,
-        output_config: OutputConfig | NotSet = NOT_SET,
-        code_sample_style: CodeSampleStyle | NotSet = NOT_SET,
-        rate_limiter: Limiter | None = NOT_SET,
-        sanitize_output: bool | NotSet | None = NOT_SET,
-        filter_set: FilterSet | None = None,
+        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 app is NOT_SET:
-            app = self.app
-        if validate_schema is NOT_SET:
-            validate_schema = self.validate_schema
-        if filter_set is None:
-            filter_set = self.filter_set
-        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 output_config is NOT_SET:
-            output_config = self.output_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,
-            specification=self.specification,
+            config=self.config,
             location=self.location,
-            base_url=base_url,  # type: ignore
-            app=app,
-            hooks=hooks,  # type: ignore
-            auth=auth,  # type: ignore
-            test_function=test_function,
-            validate_schema=validate_schema,  # type: ignore
-            data_generation_methods=data_generation_methods,  # type: ignore
-            generation_config=generation_config,  # type: ignore
-            output_config=output_config,  # type: ignore
-            code_sample_style=code_sample_style,  # type: ignore
-            rate_limiter=rate_limiter,  # type: ignore
-            sanitize_output=sanitize_output,  # type: ignore
-            filter_set=filter_set,  # type: ignore
-            transport=self.transport,
+            app=self.app,
+            hooks=self.hooks,
+            auth=self.auth,
+            test_function=_test_function,
+            filter_set=_filter_set,
         )
 
     def get_local_hook_dispatcher(self) -> HookDispatcher | None:
-        """Get a HookDispatcher instance bound to the test if present."""
         # 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:
-        """Dispatch a hook via all available dispatchers."""
         dispatch(name, context, *args, **kwargs)
         self.hooks.dispatch(name, context, *args, **kwargs)
         local_dispatcher = self.get_local_hook_dispatcher()
@@ -438,12 +393,8 @@ 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.
-
-        Forms may contain file fields, that we should send via `files` argument in `requests`.
-        """
         raise NotImplementedError
 
     def get_request_payload_content_types(self, operation: APIOperation) -> list[str]:
@@ -452,15 +403,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] | CaseInsensitiveDict | 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(
@@ -468,14 +421,18 @@ class BaseSchema(Mapping):
         operation: APIOperation,
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
-        data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),
-        generation_config: GenerationConfig | None = None,
+        generation_mode: GenerationMode = GenerationMode.POSITIVE,
         **kwargs: Any,
     ) -> SearchStrategy:
         raise NotImplementedError
 
     def as_state_machine(self) -> type[APIStateMachine]:
-        """Create a state machine class."""
+        """Create a state machine class for stateful testing of linked API operations.
+
+        Returns:
+            APIStateMachine subclass configured for this schema.
+
+        """
         raise NotImplementedError
 
     def get_links(self, operation: APIOperation) -> dict[str, dict[str, Any]]:
@@ -484,46 +441,41 @@ 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:
-            if IS_PYRATE_LIMITER_ABOVE_3:
-                self.rate_limiter.try_acquire(label)
-            else:
-                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
 
     def as_strategy(
         self,
-        hooks: HookDispatcher | None = None,
-        auth_storage: AuthStorage | None = None,
-        data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),
-        generation_config: GenerationConfig | None = None,
+        generation_mode: GenerationMode = GenerationMode.POSITIVE,
         **kwargs: Any,
     ) -> SearchStrategy:
-        """Build a strategy for generating test cases for all defined API operations."""
-        strategies = [
-            operation.ok().as_strategy(
-                hooks=hooks,
-                auth_storage=auth_storage,
-                data_generation_method=data_generation_method,
-                generation_config=generation_config,
-                **kwargs,
-            )
-            for operation in self.get_all_operations(hooks=hooks)
+        """Create a Hypothesis strategy that generates test cases for all schema operations.
+
+        Use with `@given` in non-Schemathesis tests.
+
+        Args:
+            generation_mode: Whether to generate positive or negative test data.
+            **kwargs: Additional keywords for each strategy.
+
+        Returns:
+            Combined Hypothesis strategy for all valid operations in the schema.
+
+        """
+        _strategies = [
+            operation.ok().as_strategy(generation_mode=generation_mode, **kwargs)
+            for operation in self.get_all_operations()
             if isinstance(operation, Ok)
         ]
-        return combine_strategies(strategies)
+        return strategies.combine(_strategies)
+
+    def find_operation_by_label(self, label: str) -> APIOperation | None:
+        raise NotImplementedError
 
 
 @dataclass
@@ -542,21 +494,333 @@ class APIOperationMap(Mapping):
 
     def as_strategy(
         self,
-        hooks: HookDispatcher | None = None,
-        auth_storage: AuthStorage | None = None,
-        data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),
-        generation_config: GenerationConfig | None = None,
+        generation_mode: GenerationMode = GenerationMode.POSITIVE,
         **kwargs: Any,
     ) -> SearchStrategy:
-        """Build a strategy for generating test cases for all API operations defined in this subset."""
-        strategies = [
-            operation.as_strategy(
-                hooks=hooks,
-                auth_storage=auth_storage,
-                data_generation_method=data_generation_method,
-                generation_config=generation_config,
-                **kwargs,
-            )
-            for operation in self._data.values()
+        """Create a Hypothesis strategy that generates test cases for all schema operations in this subset.
+
+        Use with `@given` in non-Schemathesis tests.
+
+        Args:
+            generation_mode: Whether to generate positive or negative test data.
+            **kwargs: Additional keywords for each strategy.
+
+        Returns:
+            Combined Hypothesis strategy for all valid operations in the schema.
+
+        """
+        _strategies = [
+            operation.as_strategy(generation_mode=generation_mode, **kwargs) 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]):
+    """An API operation (e.g., `GET /users`)."""
+
+    # `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.path}"  # type: ignore
+
+    def __deepcopy__(self, memo: dict) -> APIOperation[P]:
+        return self
+
+    @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]:
+        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:
+        # 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,
+        generation_mode: GenerationMode = GenerationMode.POSITIVE,
+        **kwargs: Any,
+    ) -> SearchStrategy[Case]:
+        """Create a Hypothesis strategy that generates test cases for this API operation.
+
+        Use with `@given` in non-Schemathesis tests.
+
+        Args:
+            generation_mode: Whether to generate positive or negative test data.
+            **kwargs: Extra arguments to the underlying strategy function.
+
+        """
+        strategy = self.schema.get_case_strategy(self, generation_mode=generation_mode, **kwargs)
+
+        def _apply_hooks(dispatcher: HookDispatcher, _strategy: SearchStrategy[Case]) -> SearchStrategy[Case]:
+            context = HookContext(operation=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)
+        hooks = kwargs.get("hooks")
+        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]]:
+        return self.schema.get_strategies_from_examples(self, **kwargs)
+
+    def get_parameter_serializer(self, location: str) -> Callable | None:
+        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] | CaseInsensitiveDict | 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 test case with specific data instead of generated values.
+
+        Args:
+            method: Override HTTP method.
+            path_parameters: Override path variables.
+            headers: Override HTTP headers.
+            cookies: Override cookies.
+            query: Override query parameters.
+            body: Override request body.
+            media_type: Override media type.
+
+        """
+        from requests.structures import CaseInsensitiveDict
+
+        return self.schema.make_case(
+            operation=self,
+            method=method,
+            path_parameters=path_parameters or {},
+            headers=CaseInsensitiveDict() if headers is None else CaseInsensitiveDict(headers),
+            cookies=cookies or {},
+            query=query or {},
+            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 | httpx.Response | requests.Response | TestResponse) -> bool | None:
+        """Validate a response against the API schema.
+
+        Args:
+            response: The HTTP response to validate. Can be a `requests.Response`,
+                `httpx.Response`, `werkzeug.test.TestResponse`, or `schemathesis.Response`.
+
+        Raises:
+            FailureGroup: If the response does not conform to the schema.
+
+        """
+        return self.schema.validate_response(self, Response.from_any(response))
+
+    def is_valid_response(self, response: Response | httpx.Response | requests.Response | TestResponse) -> bool:
+        """Check if the provided response is valid against the API schema.
+
+        Args:
+            response: The HTTP response to validate. Can be a `requests.Response`,
+                `httpx.Response`, `werkzeug.test.TestResponse`, or `schemathesis.Response`.
+
+        Returns:
+            `True` if response is valid, `False` otherwise.
+
+        """
+        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)