schemathesis 3.32.1__py3-none-any.whl → 3.33.0__py3-none-any.whl

schemathesis/cli/__init__.py

@@ -11,7 +11,7 @@ from collections import defaultdict
 from dataclasses import dataclass
 from enum import Enum
 from queue import Queue
-from typing import TYPE_CHECKING, Any, Callable, Generator, Iterable, NoReturn, cast
+from typing import TYPE_CHECKING, Any, Callable, Generator, Iterable, Literal, NoReturn, Sequence, cast
 from urllib.parse import urlparse
 
 import click
@@ -34,6 +34,7 @@ from ..constants import (
     WAIT_FOR_SCHEMA_ENV_VAR,
 )
 from ..exceptions import SchemaError, SchemaErrorType, extract_nth_traceback
+from ..filters import FilterSet, expression_to_filter_function, is_deprecated
 from ..fixups import ALL_FIXUPS
 from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod
 from ..hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, HookScope
@@ -41,7 +42,7 @@ from ..internal.datetime import current_datetime
 from ..internal.output import OutputConfig
 from ..internal.validation import file_exists
 from ..loaders import load_app, load_yaml
-from ..models import Case, CheckFunction
+from ..models import APIOperation, Case, CheckFunction
 from ..runner import events, prepare_hypothesis_settings, probes
 from ..specs.graphql import loaders as gql_loaders
 from ..specs.openapi import loaders as oas_loaders
@@ -216,6 +217,39 @@ with_hosts_file = click.option(
 )
 
 
+def _with_filter(*, by: str, mode: Literal["include", "exclude"], modifier: Literal["regex"] | None = None) -> Callable:
+    """Generate a CLI option for filtering API operations."""
+    param = f"--{mode}-{by}"
+    action = "include in" if mode == "include" else "exclude from"
+    prop = {
+        "operation-id": "ID",
+        "name": "Operation name",
+    }.get(by, by.capitalize())
+    if modifier:
+        param += f"-{modifier}"
+        prop += " pattern"
+    help_text = f"{prop} to {action} testing."
+    return click.option(
+        param,
+        help=help_text,
+        type=str,
+        multiple=modifier is None,
+        cls=GroupedOption,
+        group=ParameterGroup.filtering,
+    )
+
+
+_BY_VALUES = ("operation-id", "tag", "name", "method", "path")
+
+
+def with_filters(command: Callable) -> Callable:
+    for by in _BY_VALUES:
+        for mode in ("exclude", "include"):
+            for modifier in ("regex", None):
+                command = _with_filter(by=by, mode=mode, modifier=modifier)(command)  # type: ignore[arg-type]
+    return command
+
+
 class ReportToService:
     pass
 
@@ -362,6 +396,33 @@ REPORT_TO_SERVICE = ReportToService()
     type=str,
     callback=callbacks.validate_headers,
 )
+@with_filters
+@click.option(
+    "--include-by",
+    "include_by",
+    type=str,
+    help="Include API operations by expression",
+    cls=GroupedOption,
+    group=ParameterGroup.filtering,
+)
+@click.option(
+    "--exclude-by",
+    "exclude_by",
+    type=str,
+    help="Exclude API operations by expression",
+    cls=GroupedOption,
+    group=ParameterGroup.filtering,
+)
+@click.option(
+    "--exclude-deprecated",
+    help="Exclude deprecated API operations from testing.",
+    is_flag=True,
+    is_eager=True,
+    default=False,
+    show_default=True,
+    cls=GroupedOption,
+    group=ParameterGroup.filtering,
+)
 @click.option(
     "--endpoint",
     "-E",
@@ -779,10 +840,33 @@ def run(
     exit_first: bool = False,
     max_failures: int | None = None,
     dry_run: bool = False,
-    endpoints: Filter | None = None,
-    methods: Filter | None = None,
-    tags: Filter | None = None,
-    operation_ids: Filter | None = None,
+    include_path: Sequence[str] = (),
+    include_path_regex: str | None = None,
+    include_method: Sequence[str] = (),
+    include_method_regex: str | None = None,
+    include_name: Sequence[str] = (),
+    include_name_regex: str | None = None,
+    include_tag: Sequence[str] = (),
+    include_tag_regex: str | None = None,
+    include_operation_id: Sequence[str] = (),
+    include_operation_id_regex: str | None = None,
+    exclude_path: Sequence[str] = (),
+    exclude_path_regex: str | None = None,
+    exclude_method: Sequence[str] = (),
+    exclude_method_regex: str | None = None,
+    exclude_name: Sequence[str] = (),
+    exclude_name_regex: str | None = None,
+    exclude_tag: Sequence[str] = (),
+    exclude_tag_regex: str | None = None,
+    exclude_operation_id: Sequence[str] = (),
+    exclude_operation_id_regex: str | None = None,
+    include_by: str | None = None,
+    exclude_by: str | None = None,
+    exclude_deprecated: bool = False,
+    endpoints: tuple[str, ...] = (),
+    methods: tuple[str, ...] = (),
+    tags: tuple[str, ...] = (),
+    operation_ids: tuple[str, ...] = (),
     workers_num: int = DEFAULT_WORKERS,
     base_url: str | None = None,
     app: str | None = None,
@@ -897,6 +981,107 @@ def run(
 
     output_config = OutputConfig(truncate=output_truncate)
 
+    deprecated_filters = {
+        "--method": "--include-method",
+        "--endpoint": "--include-path",
+        "--tag": "--include-tag",
+        "--operation-id": "--include-operation-id",
+    }
+    for values, arg_name in (
+        (include_path, "--include-path"),
+        (include_method, "--include-method"),
+        (include_name, "--include-name"),
+        (include_tag, "--include-tag"),
+        (include_operation_id, "--include-operation-id"),
+        (exclude_path, "--exclude-path"),
+        (exclude_method, "--exclude-method"),
+        (exclude_name, "--exclude-name"),
+        (exclude_tag, "--exclude-tag"),
+        (exclude_operation_id, "--exclude-operation-id"),
+        (methods, "--method"),
+        (endpoints, "--endpoint"),
+        (tags, "--tag"),
+        (operation_ids, "--operation-id"),
+    ):
+        if values and arg_name in deprecated_filters:
+            replacement = deprecated_filters[arg_name]
+            click.secho(
+                f"Warning: Option `{arg_name}` is deprecated and will be removed in Schemathesis 4.0. "
+                f"Use `{replacement}` instead.",
+                fg="yellow",
+            )
+        _ensure_unique_filter(values, arg_name)
+    include_by_function = _filter_by_expression_to_func(include_by, "--include-by")
+    exclude_by_function = _filter_by_expression_to_func(exclude_by, "--exclude-by")
+
+    filter_set = FilterSet()
+    if include_by_function:
+        filter_set.include(include_by_function)
+    for name_ in include_name:
+        filter_set.include(name=name_)
+    for method in include_method:
+        filter_set.include(method=method)
+    if methods:
+        for method in methods:
+            filter_set.include(method_regex=method)
+    for path in include_path:
+        filter_set.include(path=path)
+    if endpoints:
+        for endpoint in endpoints:
+            filter_set.include(path_regex=endpoint)
+    for tag in include_tag:
+        filter_set.include(tag=tag)
+    if tags:
+        for tag in tags:
+            filter_set.include(tag_regex=tag)
+    for operation_id in include_operation_id:
+        filter_set.include(operation_id=operation_id)
+    if operation_ids:
+        for operation_id in operation_ids:
+            filter_set.include(operation_id_regex=operation_id)
+    if (
+        include_name_regex
+        or include_method_regex
+        or include_path_regex
+        or include_tag_regex
+        or include_operation_id_regex
+    ):
+        filter_set.include(
+            name_regex=include_name_regex,
+            method_regex=include_method_regex,
+            path_regex=include_path_regex,
+            tag_regex=include_tag_regex,
+            operation_id_regex=include_operation_id_regex,
+        )
+    if exclude_by_function:
+        filter_set.exclude(exclude_by_function)
+    for name_ in exclude_name:
+        filter_set.exclude(name=name_)
+    for method in exclude_method:
+        filter_set.exclude(method=method)
+    for path in exclude_path:
+        filter_set.exclude(path=path)
+    for tag in exclude_tag:
+        filter_set.exclude(tag=tag)
+    for operation_id in exclude_operation_id:
+        filter_set.exclude(operation_id=operation_id)
+    if (
+        exclude_name_regex
+        or exclude_method_regex
+        or exclude_path_regex
+        or exclude_tag_regex
+        or exclude_operation_id_regex
+    ):
+        filter_set.exclude(
+            name_regex=exclude_name_regex,
+            method_regex=exclude_method_regex,
+            path_regex=exclude_path_regex,
+            tag_regex=exclude_tag_regex,
+            operation_id_regex=exclude_operation_id_regex,
+        )
+    if exclude_deprecated or skip_deprecated_operations:
+        filter_set.exclude(is_deprecated)
+
     schemathesis_io_hostname = urlparse(schemathesis_io_url).netloc
     token = schemathesis_io_token or service.hosts.get_token(hostname=schemathesis_io_hostname, hosts_file=hosts_file)
     schema_kind = callbacks.parse_schema_kind(schema, app)
@@ -986,7 +1171,6 @@ def run(
         base_url=base_url,
         started_at=started_at,
         validate_schema=validate_schema,
-        skip_deprecated_operations=skip_deprecated_operations,
         data_generation_methods=data_generation_methods,
         force_schema_version=force_schema_version,
         request_tls_verify=request_tls_verify,
@@ -997,10 +1181,6 @@ def run(
         auth_type=auth_type,
         override=override,
         headers=headers,
-        endpoint=endpoints or None,
-        method=methods or None,
-        tag=tags or None,
-        operation_id=operation_ids or None,
         request_timeout=request_timeout,
         seed=hypothesis_seed,
         exit_first=exit_first,
@@ -1018,6 +1198,7 @@ def run(
         generation_config=generation_config,
         output_config=output_config,
         service_client=client,
+        filter_set=filter_set,
     )
     execute(
         event_stream,
@@ -1048,6 +1229,21 @@ def run(
     )
 
 
+def _ensure_unique_filter(values: Sequence[str], arg_name: str) -> None:
+    if len(values) != len(set(values)):
+        duplicates = ",".join(sorted({value for value in values if values.count(value) > 1}))
+        raise click.UsageError(f"Duplicate values are not allowed for `{arg_name}`: {duplicates}")
+
+
+def _filter_by_expression_to_func(value: str | None, arg_name: str) -> Callable | None:
+    if value:
+        try:
+            return expression_to_filter_function(value)
+        except ValueError:
+            raise click.UsageError(f"Invalid expression for {arg_name}: {value}") from None
+    return None
+
+
 def prepare_request_cert(cert: str | None, key: str | None) -> RequestCert | None:
     if cert is not None and key is not None:
         return cert, key
@@ -1065,7 +1261,6 @@ class LoaderConfig:
     app: Any
     base_url: str | None
     validate_schema: bool
-    skip_deprecated_operations: bool
     data_generation_methods: tuple[DataGenerationMethod, ...]
     force_schema_version: str | None
     request_tls_verify: bool | str
@@ -1079,11 +1274,6 @@ class LoaderConfig:
     auth: tuple[str, str] | None
     auth_type: str | None
     headers: dict[str, str] | None
-    # Schema filters
-    endpoint: Filter | None
-    method: Filter | None
-    tag: Filter | None
-    operation_id: Filter | None
 
 
 def into_event_stream(
@@ -1093,7 +1283,6 @@ def into_event_stream(
     base_url: str | None,
     started_at: str,
     validate_schema: bool,
-    skip_deprecated_operations: bool,
     data_generation_methods: tuple[DataGenerationMethod, ...],
     force_schema_version: str | None,
     request_tls_verify: bool | str,
@@ -1106,11 +1295,7 @@ def into_event_stream(
     headers: dict[str, str] | None,
     request_timeout: int | None,
     wait_for_schema: float | None,
-    # Schema filters
-    endpoint: Filter | None,
-    method: Filter | None,
-    tag: Filter | None,
-    operation_id: Filter | None,
+    filter_set: FilterSet,
     # Runtime behavior
     checks: Iterable[CheckFunction],
     max_response_time: int | None,
@@ -1137,7 +1322,6 @@ def into_event_stream(
             app=app,
             base_url=base_url,
             validate_schema=validate_schema,
-            skip_deprecated_operations=skip_deprecated_operations,
             data_generation_methods=data_generation_methods,
             force_schema_version=force_schema_version,
             request_proxy=request_proxy,
@@ -1148,14 +1332,11 @@ def into_event_stream(
             auth=auth,
             auth_type=auth_type,
             headers=headers,
-            endpoint=endpoint or None,
-            method=method or None,
-            tag=tag or None,
-            operation_id=operation_id or None,
             output_config=output_config,
             generation_config=generation_config,
         )
         schema = load_schema(config)
+        schema.filter_set = filter_set
         yield from runner.from_schema(
             schema,
             auth=auth,
@@ -1293,11 +1474,6 @@ def get_loader_kwargs(loader: Callable, config: LoaderConfig) -> dict[str, Any]:
     kwargs = {
         "app": config.app,
         "base_url": config.base_url,
-        "method": config.method,
-        "endpoint": config.endpoint,
-        "tag": config.tag,
-        "operation_id": config.operation_id,
-        "skip_deprecated_operations": config.skip_deprecated_operations,
         "validate_schema": config.validate_schema,
         "force_schema_version": config.force_schema_version,
         "data_generation_methods": config.data_generation_methods,

schemathesis/filters.py

@@ -2,15 +2,16 @@
 
 from __future__ import annotations
 
+import json
 import re
 from dataclasses import dataclass, field
 from functools import partial
 from types import SimpleNamespace
-from typing import TYPE_CHECKING, Callable, List, Protocol, Union
-
-from .types import NotSet, Filter as FilterType
+from typing import TYPE_CHECKING, Any, Callable, List, Protocol, Union
 
 from .exceptions import UsageError
+from .types import Filter as FilterType
+from .types import NotSet
 
 if TYPE_CHECKING:
     from .models import APIOperation
@@ -143,9 +144,29 @@ class FilterSet:
 
     __slots__ = ("_includes", "_excludes")
 
-    def __init__(self) -> None:
-        self._includes = set()
-        self._excludes = set()
+    def __init__(self, _includes: set[Filter] | None = None, _excludes: set[Filter] | None = None) -> None:
+        self._includes = _includes or set()
+        self._excludes = _excludes or set()
+
+    def clone(self) -> FilterSet:
+        return FilterSet(_includes=self._includes.copy(), _excludes=self._excludes.copy())
+
+    def merge(self, other: FilterSet) -> FilterSet:
+        def _merge(lhs: set[Filter], rhs: set[Filter]) -> set[Filter]:
+            result = lhs.copy()
+            for new in rhs:
+                for old in lhs:
+                    for new_matcher in new.matchers:
+                        for old_matcher in old.matchers:
+                            if "=" in new_matcher.label and "=" in old_matcher.label:
+                                if new_matcher.label.split("=")[0] == old_matcher.label.split("=")[0]:
+                                    result.remove(old)
+                result.add(new)
+            return result
+
+        return FilterSet(
+            _includes=_merge(self._includes, other._includes), _excludes=_merge(self._excludes, other._excludes)
+        )
 
     def apply_to(self, operations: list[APIOperation]) -> list[APIOperation]:
         """Get a filtered list of the given operations that match the filters."""
@@ -304,8 +325,12 @@ def attach_filter_chain(
         name_regex: str | None = None,
         method: FilterValue | None = None,
         method_regex: str | None = None,
+        tag: FilterValue | None = None,
+        tag_regex: RegexValue | None = None,
         path: FilterValue | None = None,
         path_regex: str | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
     ) -> Callable:
         __tracebackhide__ = True
         filter_func(
@@ -314,8 +339,12 @@ def attach_filter_chain(
             name_regex=name_regex,
             method=method,
             method_regex=method_regex,
+            tag=tag,
+            tag_regex=tag_regex,
             path=path,
             path_regex=path_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
         )
         return target
 
@@ -325,6 +354,10 @@ def attach_filter_chain(
     setattr(target, attribute, proxy)
 
 
+def is_deprecated(ctx: HasAPIOperation) -> bool:
+    return ctx.operation.definition.raw.get("deprecated") is True
+
+
 def filter_set_from_components(
     *,
     include: bool,
@@ -338,9 +371,6 @@ def filter_set_from_components(
     def _is_defined(x: FilterType | None) -> bool:
         return x is not None and not isinstance(x, NotSet)
 
-    def _is_deprecated(ctx: HasAPIOperation) -> bool:
-        return ctx.operation.definition.raw.get("deprecated") is True
-
     def _prepare_filter(filter_: FilterType | None) -> RegexValue | None:
         if filter_ is None or isinstance(filter_, NotSet):
             return None
@@ -359,9 +389,9 @@ def filter_set_from_components(
             operation_id_regex=_prepare_filter(operation_id),
         )
     if skip_deprecated_operations is True and not any(
-        matcher.label == _is_deprecated.__name__ for exclude_ in new._excludes for matcher in exclude_.matchers
+        matcher.label == is_deprecated.__name__ for exclude_ in new._excludes for matcher in exclude_.matchers
     ):
-        new.exclude(func=_is_deprecated)
+        new.exclude(func=is_deprecated)
     # Merge with the parent filter set
     if parent is not None:
         for include_ in parent._includes:
@@ -387,10 +417,56 @@ def filter_set_from_components(
             matchers = exclude_.matchers
             ids = []
             for idx, matcher in enumerate(exclude_.matchers):
-                if skip_deprecated_operations is False and matcher.label == _is_deprecated.__name__:
+                if skip_deprecated_operations is False and matcher.label == is_deprecated.__name__:
                     ids.append(idx)
             if ids:
                 matchers = tuple(matcher for idx, matcher in enumerate(matchers) if idx not in ids)
             if matchers:
                 new._excludes.add(exclude_)
     return new
+
+
+def parse_expression(expression: str) -> tuple[str, str, Any]:
+    expression = expression.strip()
+
+    # Find the operator
+    for op in ("==", "!="):
+        try:
+            pointer, value = expression.split(op, 1)
+            break
+        except ValueError:
+            continue
+    else:
+        raise ValueError(f"Invalid expression: {expression}")
+
+    pointer = pointer.strip()
+    value = value.strip()
+    if not pointer or not value:
+        raise ValueError(f"Invalid expression: {expression}")
+    # Parse the JSON value
+    try:
+        return pointer, op, json.loads(value)
+    except json.JSONDecodeError:
+        # If it's not valid JSON, treat it as a string
+        return pointer, op, value
+
+
+def expression_to_filter_function(expression: str) -> Callable[[HasAPIOperation], bool]:
+    from .specs.openapi.references import resolve_pointer
+
+    pointer, op, value = parse_expression(expression)
+
+    if op == "==":
+
+        def filter_function(ctx: HasAPIOperation) -> bool:
+            definition = ctx.operation.definition.resolved
+            resolved = resolve_pointer(definition, pointer)
+            return resolved == value
+    else:
+
+        def filter_function(ctx: HasAPIOperation) -> bool:
+            definition = ctx.operation.definition.resolved
+            resolved = resolve_pointer(definition, pointer)
+            return resolved != value
+
+    return filter_function

schemathesis/hooks.py

@@ -42,7 +42,7 @@ class HookContext:
 
     operation: APIOperation | None = None
 
-    @deprecated_property(removed_in="4.0", replacement="operation")
+    @deprecated_property(removed_in="4.0", replacement="`operation`")
     def endpoint(self) -> APIOperation | None:
         return self.operation
 

schemathesis/internal/deprecation.py

@@ -5,7 +5,7 @@ from typing import Any, Callable
 def _warn_deprecation(*, kind: str, thing: str, removed_in: str, replacement: str) -> None:
     warnings.warn(
         f"{kind} `{thing}` is deprecated and will be removed in Schemathesis {removed_in}. "
-        f"Use `{replacement}` instead.",
+        f"Use {replacement} instead.",
         DeprecationWarning,
         stacklevel=1,
     )
@@ -23,6 +23,10 @@ def deprecated_property(*, removed_in: str, replacement: str) -> Callable:
     return wrapper
 
 
+def warn_filtration_arguments(name: str) -> None:
+    _warn_deprecation(kind="Argument", thing=name, removed_in="4.0", replacement="`include` and `exclude` methods")
+
+
 def deprecated_function(*, removed_in: str, replacement: str) -> Callable:
     def wrapper(func: Callable) -> Callable:
         def inner(*args: Any, **kwargs: Any) -> Any:

schemathesis/lazy.py

@@ -19,9 +19,10 @@ from .auths import AuthStorage
 from .code_samples import CodeSampleStyle
 from .constants import FLAKY_FAILURE_MESSAGE, NOT_SET
 from .exceptions import CheckFailed, OperationSchemaError, SkipTest, get_grouped_exception
-from .filters import filter_set_from_components
+from .filters import FilterSet, FilterValue, MatcherFunc, RegexValue, filter_set_from_components, is_deprecated
 from .generation import DataGenerationMethodInput, GenerationConfig
 from .hooks import HookDispatcher, HookScope
+from .internal.deprecation import warn_filtration_arguments
 from .internal.output import OutputConfig
 from .internal.result import Ok
 from .models import APIOperation
@@ -43,15 +44,11 @@ from .utils import (
 class LazySchema:
     fixture_name: str
     base_url: str | None | NotSet = NOT_SET
-    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
+    filter_set: FilterSet = field(default_factory=FilterSet)
     hooks: HookDispatcher = field(default_factory=lambda: HookDispatcher(scope=HookScope.SCHEMA))
     auth: AuthStorage = field(default_factory=AuthStorage)
     validate_schema: bool = True
-    skip_deprecated_operations: bool = False
     data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET
     generation_config: GenerationConfig | NotSet = NOT_SET
     output_config: OutputConfig | NotSet = NOT_SET
@@ -59,6 +56,104 @@ class LazySchema:
     rate_limiter: Limiter | None = None
     sanitize_output: bool = True
 
+    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,
+    ) -> LazySchema:
+        """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.__class__(
+            fixture_name=self.fixture_name,
+            base_url=self.base_url,
+            app=self.app,
+            hooks=self.hooks,
+            auth=self.auth,
+            validate_schema=self.validate_schema,
+            data_generation_methods=self.data_generation_methods,
+            generation_config=self.generation_config,
+            output_config=self.output_config,
+            code_sample_style=self.code_sample_style,
+            rate_limiter=self.rate_limiter,
+            sanitize_output=self.sanitize_output,
+            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,
+    ) -> LazySchema:
+        """Exclude 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.__class__(
+            fixture_name=self.fixture_name,
+            base_url=self.base_url,
+            app=self.app,
+            hooks=self.hooks,
+            auth=self.auth,
+            validate_schema=self.validate_schema,
+            data_generation_methods=self.data_generation_methods,
+            generation_config=self.generation_config,
+            output_config=self.output_config,
+            code_sample_style=self.code_sample_style,
+            rate_limiter=self.rate_limiter,
+            sanitize_output=self.sanitize_output,
+            filter_set=filter_set,
+        )
+
     def hook(self, hook: str | Callable) -> Callable:
         return self.hooks.register(hook)
 
@@ -75,14 +170,10 @@ class LazySchema:
         output_config: OutputConfig | NotSet = NOT_SET,
         code_sample_style: str | NotSet = NOT_SET,
     ) -> Callable:
-        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
+        for name in ("method", "endpoint", "tag", "operation_id", "skip_deprecated_operations"):
+            value = locals()[name]
+            if value is not NOT_SET:
+                warn_filtration_arguments(name)
         if data_generation_methods is NOT_SET:
             data_generation_methods = self.data_generation_methods
         if generation_config is NOT_SET:
@@ -133,6 +224,7 @@ class LazySchema:
                     app=self.app,
                     rate_limiter=self.rate_limiter,
                     sanitize_output=self.sanitize_output,
+                    filter_set=self.filter_set,
                 )
                 fixtures = get_fixtures(test, request, given_kwargs)
                 # Changing the node id is required for better reporting - the method and path will appear there
@@ -325,6 +417,7 @@ def get_schema(
     endpoint: Filter | None = None,
     tag: Filter | None = None,
     operation_id: Filter | None = None,
+    filter_set: FilterSet,
     app: Any = None,
     test_function: GenericTest,
     hooks: HookDispatcher,
@@ -350,7 +443,7 @@ def get_schema(
         tag=tag,
         operation_id=operation_id,
         skip_deprecated_operations=skip_deprecated_operations,
-        parent=schema.filter_set,
+        parent=schema.filter_set.merge(filter_set),
     )
     return schema.clone(
         base_url=base_url,

schemathesis/models.py

@@ -174,7 +174,7 @@ class Case:
     def __hash__(self) -> int:
         return hash(self.as_curl_command({SCHEMATHESIS_TEST_CASE_HEADER: "0"}))
 
-    @deprecated_property(removed_in="4.0", replacement="operation")
+    @deprecated_property(removed_in="4.0", replacement="`operation`")
     def endpoint(self) -> APIOperation:
         return self.operation
 

schemathesis/runner/events.py

@@ -10,7 +10,6 @@ from ..exceptions import RuntimeErrorType, SchemaError, SchemaErrorType, format_
 from ..generation import DataGenerationMethod
 from ..internal.datetime import current_datetime
 from ..internal.result import Err, Ok, Result
-from ..service.models import AnalysisSuccess
 from .serialization import SerializedError, SerializedTestResult
 
 if TYPE_CHECKING:
@@ -107,6 +106,8 @@ class AfterAnalysis(ExecutionEvent):
     analysis: Result[AnalysisResult, Exception] | None
 
     def _serialize(self) -> dict[str, Any]:
+        from ..service.models import AnalysisSuccess
+
         data = {}
         if isinstance(self.analysis, Ok):
             result = self.analysis.ok()

schemathesis/runner/impl/core.py

@@ -535,8 +535,10 @@ def run_test(
         if isinstance(exc.__cause__, hypothesis.errors.DeadlineExceeded):
             status = Status.error
             result.add_error(DeadlineExceeded.from_exc(exc.__cause__))
-        elif isinstance(exc, hypothesis.errors.FlakyFailure) and any(
-            isinstance(subexc, hypothesis.errors.DeadlineExceeded) for subexc in exc.exceptions
+        elif (
+            hasattr(hypothesis.errors, "FlakyFailure")
+            and isinstance(exc, hypothesis.errors.FlakyFailure)
+            and any(isinstance(subexc, hypothesis.errors.DeadlineExceeded) for subexc in exc.exceptions)
         ):
             for sub_exc in exc.exceptions:
                 if isinstance(sub_exc, hypothesis.errors.DeadlineExceeded):
@@ -579,8 +581,7 @@ def run_test(
         result.mark_errored()
         for error in deduplicate_errors(errors):
             result.add_error(error)
-    except hypothesis.errors.FlakyFailure as exc:
-        # Hypothesis >= 6.108.0
+    except hypothesis.errors.Flaky as exc:
         status = _on_flaky(exc)
     except MultipleFailures:
         # Schemathesis may detect multiple errors that come from different check results
@@ -590,8 +591,6 @@ def run_test(
             add_errors(result, errors)
         else:
             status = Status.failure
-    except hypothesis.errors.Flaky as exc:
-        status = _on_flaky(exc)
     except hypothesis.errors.Unsatisfiable:
         # We need more clear error message here
         status = Status.error

schemathesis/schemas.py

@@ -37,7 +37,7 @@ from .auths import AuthStorage
 from .code_samples import CodeSampleStyle
 from .constants import NOT_SET
 from .exceptions import OperationSchemaError, UsageError
-from .filters import FilterSet, filter_set_from_components
+from .filters import FilterSet, FilterValue, MatcherFunc, RegexValue, filter_set_from_components, is_deprecated
 from .generation import (
     DEFAULT_DATA_GENERATION_METHODS,
     DataGenerationMethod,
@@ -45,6 +45,7 @@ from .generation import (
     GenerationConfig,
 )
 from .hooks import HookContext, HookDispatcher, HookScope, dispatch
+from .internal.deprecation import warn_filtration_arguments
 from .internal.output import OutputConfig
 from .internal.result import Ok, Result
 from .models import APIOperation, Case
@@ -97,6 +98,76 @@ class BaseSchema(Mapping):
     rate_limiter: Limiter | None = None
     sanitize_output: bool = True
 
+    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]:
         raise NotImplementedError
 
@@ -239,6 +310,11 @@ class BaseSchema(Mapping):
             CodeSampleStyle.from_str(code_sample_style) if isinstance(code_sample_style, str) else code_sample_style
         )
 
+        for name in ("method", "endpoint", "tag", "operation_id", "skip_deprecated_operations"):
+            value = locals()[name]
+            if value is not NOT_SET:
+                warn_filtration_arguments(name)
+
         filter_set = filter_set_from_components(
             include=True,
             method=method,

schemathesis/specs/graphql/schemas.py

@@ -5,6 +5,7 @@ import time
 from dataclasses import dataclass, field
 from difflib import get_close_matches
 from enum import unique
+from types import SimpleNamespace
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -184,7 +185,8 @@ class GraphQLSchema(BaseSchema):
         return 0
 
     def get_all_operations(
-        self, hooks: HookDispatcher | None = None
+        self,
+        hooks: HookDispatcher | None = None,
     ) -> Generator[Result[APIOperation, OperationSchemaError], None, None]:
         schema = self.client_schema
         for root_type, operation_type in (
@@ -195,6 +197,8 @@ class GraphQLSchema(BaseSchema):
                 continue
             for field_name, field_ in operation_type.fields.items():
                 operation = self._build_operation(root_type, operation_type, field_name, field_)
+                if self._should_skip(operation):
+                    continue
                 context = HookContext(operation=operation)
                 if (
                     should_skip_operation(GLOBAL_HOOK_DISPATCHER, context)
@@ -204,6 +208,14 @@ class GraphQLSchema(BaseSchema):
                     continue
                 yield Ok(operation)
 
+    def _should_skip(
+        self,
+        operation: APIOperation,
+        _ctx_cache: SimpleNamespace = SimpleNamespace(operation=None),
+    ) -> bool:
+        _ctx_cache.operation = operation
+        return not self.filter_set.match(_ctx_cache)
+
     def _build_operation(
         self,
         root_type: RootType,

schemathesis/specs/openapi/loaders.py

@@ -19,6 +19,7 @@ from ...generation import (
     GenerationConfig,
 )
 from ...hooks import HookContext, dispatch
+from ...internal.deprecation import warn_filtration_arguments
 from ...internal.output import OutputConfig
 from ...internal.validation import require_relative_url
 from ...loaders import load_schema_from_url, load_yaml
@@ -76,7 +77,7 @@ def from_path(
     endpoint: Filter | None = None,
     tag: Filter | None = None,
     operation_id: Filter | None = None,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
@@ -126,7 +127,7 @@ def from_uri(
     endpoint: Filter | None = None,
     tag: Filter | None = None,
     operation_id: Filter | None = None,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
@@ -222,7 +223,7 @@ def from_file(
     endpoint: Filter | None = None,
     tag: Filter | None = None,
     operation_id: Filter | None = None,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
@@ -298,7 +299,7 @@ def from_dict(
     endpoint: Filter | None = None,
     tag: Filter | None = None,
     operation_id: Filter | None = None,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
@@ -331,6 +332,10 @@ def from_dict(
     if rate_limit is not None:
         rate_limiter = build_limiter(rate_limit)
 
+    for name in ("method", "endpoint", "tag", "operation_id", "skip_deprecated_operations"):
+        value = locals()[name]
+        if value is not None:
+            warn_filtration_arguments(name)
     filter_set = filter_set_from_components(
         include=True,
         method=method,
@@ -475,7 +480,7 @@ def from_pytest_fixture(
     endpoint: Filter | None = NOT_SET,
     tag: Filter | None = NOT_SET,
     operation_id: Filter | None = NOT_SET,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
     generation_config: GenerationConfig | NotSet = NOT_SET,
@@ -505,15 +510,23 @@ def from_pytest_fixture(
     rate_limiter: Limiter | None = None
     if rate_limit is not None:
         rate_limiter = build_limiter(rate_limit)
-    return LazySchema(
-        fixture_name,
-        app=app,
-        base_url=base_url,
+    for name in ("method", "endpoint", "tag", "operation_id", "skip_deprecated_operations"):
+        value = locals()[name]
+        if value is not None:
+            warn_filtration_arguments(name)
+    filter_set = filter_set_from_components(
+        include=True,
         method=method,
         endpoint=endpoint,
         tag=tag,
         operation_id=operation_id,
         skip_deprecated_operations=skip_deprecated_operations,
+    )
+    return LazySchema(
+        fixture_name,
+        app=app,
+        base_url=base_url,
+        filter_set=filter_set,
         validate_schema=validate_schema,
         data_generation_methods=_data_generation_methods,
         generation_config=generation_config,
@@ -533,7 +546,7 @@ def from_wsgi(
     endpoint: Filter | None = None,
     tag: Filter | None = None,
     operation_id: Filter | None = None,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
@@ -598,7 +611,7 @@ def from_aiohttp(
     endpoint: Filter | None = None,
     tag: Filter | None = None,
     operation_id: Filter | None = None,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
@@ -648,7 +661,7 @@ def from_asgi(
     endpoint: Filter | None = None,
     tag: Filter | None = None,
     operation_id: Filter | None = None,
-    skip_deprecated_operations: bool = False,
+    skip_deprecated_operations: bool | None = None,
     validate_schema: bool = False,
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,

schemathesis/stateful/events.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 import time
-from dataclasses import asdict as _asdict, dataclass
+from dataclasses import asdict as _asdict
+from dataclasses import dataclass
 from enum import Enum
-from typing import TYPE_CHECKING, Type, Any
+from typing import TYPE_CHECKING, Any, Type
 
 from ..exceptions import format_exception
 

{schemathesis-3.32.1.dist-info → schemathesis-3.33.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schemathesis
-Version: 3.32.1
+Version: 3.33.0
 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://schemathesis.readthedocs.io/en/stable/changelog.html

{schemathesis-3.32.1.dist-info → schemathesis-3.33.0.dist-info}/RECORD

@@ -12,22 +12,22 @@ schemathesis/code_samples.py,sha256=xk1-1jnXg5hS40VzIZp8PEtZwGaazNlVKMT7_X-zG-M,
 schemathesis/constants.py,sha256=l1YQ7PXhEj9dyf9CTESVUpPOaFCH7iz-Fe8o4v6Th_s,2673
 schemathesis/exceptions.py,sha256=w-5A-2Yb6EJOSvPycbx79T9Lr1IcMWJ8UFq6DW9kIMc,19975
 schemathesis/failures.py,sha256=wXz5Kr5i-ojcYc-BdzFlNbNGOfoVXHZM6kd4iULdHK4,7003
-schemathesis/filters.py,sha256=02mg5Gn32AkOprfk33wjH8oXmbsYpogN8XGlrHkEo8Q,14265
+schemathesis/filters.py,sha256=t1P236DPVaWvhu2Sm6OGy6Oe2x-nnwEVYRau4qqX6C4,17034
 schemathesis/graphql.py,sha256=YkoKWY5K8lxp7H3ikAs-IsoDbiPwJvChG7O8p3DgwtI,229
-schemathesis/hooks.py,sha256=dveqMmThIvt4fDahUXhU2nCq5pFvYjzzd1Ys_MhrJZA,12398
-schemathesis/lazy.py,sha256=yEMQXbve2cB5mX-9Kv9npUECYfXVMc-dK33k82WJVcM,15405
+schemathesis/hooks.py,sha256=YuPauQfs-xFDiBDoGxMRmWX5bb4IfCf02nw7IH36J9g,12400
+schemathesis/lazy.py,sha256=hGwSuWe5tDaGpjZTV4Mj8zqdrHDYHxR22N2p5h2yh1g,18897
 schemathesis/loaders.py,sha256=OtCD1o0TVmSNAUF7dgHpouoAXtY6w9vEtsRVGv4lE0g,4588
-schemathesis/models.py,sha256=nbm9Agqw94RYib2Q4OH7iOiEPDGw64NlQnEB7o5Spio,44925
+schemathesis/models.py,sha256=HiFWcZO1m2DrmM8fGrXm2sW_uSk2tcYbY5ignfqPpJM,44927
 schemathesis/parameters.py,sha256=PndmqQRlEYsCt1kWjSShPsFf6vj7X_7FRdz_-A95eNg,2258
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/sanitization.py,sha256=mRR4YvXpzqbmgX8Xu6rume6LBcz9g_oyusvbesZl44I,8958
-schemathesis/schemas.py,sha256=wfcZflxe6ITt6s1-d37RwoRHJaYckWS76T-_PBCC7hI,17757
+schemathesis/schemas.py,sha256=MJv5NQn55o9ezsJTQxdlP-AD0vqJ7NCs62VW_Thhz6o,20441
 schemathesis/serializers.py,sha256=kxXZ-UGa1v_vOm0sC4QYcrNv4rfvI7tHGT2elRVbCbc,11649
 schemathesis/targets.py,sha256=XIGRghvEzbmEJjse9aZgNEj67L3jAbiazm2rxURWgDE,2351
 schemathesis/throttling.py,sha256=aisUc4MJDGIOGUAs9L2DlWWpdd4KyAFuNVKhYoaUC9M,1719
 schemathesis/types.py,sha256=xOzNAeMs6qqeaJnWs5Fpw5JPbvVjyfRfxTJa3G2Ln5I,920
 schemathesis/utils.py,sha256=NX04p9mO-lCAH3DIISXDXPxWZk6lkGNM4-ubRi8vlvY,5234
-schemathesis/cli/__init__.py,sha256=tMlrDVuzKhmS6FC9HwvkEjvmBr0odBuVyM-dZ5x69mE,66839
+schemathesis/cli/__init__.py,sha256=BvV9r2HG5lCclzsfTuydmJrJFq8CFmZrIF0e_YzROBY,73032
 schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
 schemathesis/cli/callbacks.py,sha256=R2noVRu8zDBWmA3dJ2YnmhAjYdkxPDA1zIpA3_2DkFQ,15144
 schemathesis/cli/cassettes.py,sha256=lKKKKLjoVT8VnZXjCOCmDYhvLKn1XSrCXCMF9EeftHA,18498
@@ -61,7 +61,7 @@ schemathesis/generation/__init__.py,sha256=mC1NVAHyce1_B_wu-GYO9U21Gut8KFrjPXETR
 schemathesis/internal/__init__.py,sha256=93HcdG3LF0BbQKbCteOsFMa1w6nXl8yTmx87QLNJOik,161
 schemathesis/internal/copy.py,sha256=DcL56z-d69kKR_5u8mlHvjSL1UTyUKNMAwexrwHFY1s,1031
 schemathesis/internal/datetime.py,sha256=zPLBL0XXLNfP-KYel3H2m8pnsxjsA_4d-zTOhJg2EPQ,136
-schemathesis/internal/deprecation.py,sha256=cF3FYy5syihneSIY7M7aVJW2KTzcd88WOItHFCJtADg,1107
+schemathesis/internal/deprecation.py,sha256=Ty5VBFBlufkITpP0WWTPIPbnB7biDi0kQgXVYWZp820,1273
 schemathesis/internal/extensions.py,sha256=h0aHRK_PTKfiAufkeBziegQS8537TL-Gr1hPW48q8Yc,790
 schemathesis/internal/jsonschema.py,sha256=-7tF15cXo1ZdhiRFYYfEClXihX2Svc5Loi_Dz1x201k,1157
 schemathesis/internal/output.py,sha256=zMaG5knIuBieVH8CrcmPJgbmQukDs2xdekX0BrK7BZs,1989
@@ -69,11 +69,11 @@ schemathesis/internal/result.py,sha256=d449YvyONjqjDs-A5DAPgtAI96iT753K8sU6_1HLo
 schemathesis/internal/transformation.py,sha256=3S6AzAqdsEsB5iobFgSuvL0UMUqH0JHC7hGxKwcpqPw,450
 schemathesis/internal/validation.py,sha256=G7i8jIMUpAeOnDsDF_eWYvRZe_yMprRswx0QAtMPyEw,966
 schemathesis/runner/__init__.py,sha256=mXFJTAjbjfGImIOB5d1rkpZC5TtVRxSf_SMiBEhKNMI,21350
-schemathesis/runner/events.py,sha256=ljwDjv-4hLS4MPfdfYDB2EAxkJR_67-fVvMu-pJU-yk,11498
+schemathesis/runner/events.py,sha256=2XnZJQN3bx_AjYqCuucDjFSuVr-UrkN0yiOatXWWn8E,11507
 schemathesis/runner/probes.py,sha256=no5AfO3kse25qvHevjeUfB0Q3C860V2AYzschUW3QMQ,5688
 schemathesis/runner/serialization.py,sha256=erbXEHyI8rIlkQ42AwgmlH7aAbh313EPqCEfrGKxUls,20040
 schemathesis/runner/impl/__init__.py,sha256=1E2iME8uthYPBh9MjwVBCTFV-P3fi7AdphCCoBBspjs,199
-schemathesis/runner/impl/core.py,sha256=k1c2QMMoqtXk1bafVRxJwGnIxTQxU0Pr1Am0Xo9WPd4,45063
+schemathesis/runner/impl/core.py,sha256=4HsnVYXcJ3qNj_vPpQJn7uu6nQwobzS0aGwmvtKy3L0,45022
 schemathesis/runner/impl/solo.py,sha256=N7-pUL6nWGiSRUC4Zqy1T4h99vbeQowP6b6cMnobOow,3042
 schemathesis/runner/impl/threadpool.py,sha256=JtTn5X7gqpbkO4q8n5kykGEPQCpJ9hXJrvU3KMF1CXA,14948
 schemathesis/service/__init__.py,sha256=cDVTCFD1G-vvhxZkJUwiToTAEQ-0ByIoqwXvJBCf_V8,472
@@ -95,7 +95,7 @@ schemathesis/specs/graphql/_cache.py,sha256=7ras3q_InDJBPykgHroerl9f2jFamC8xJD35
 schemathesis/specs/graphql/loaders.py,sha256=qxNGL67_AfhoRh0hIxlnJVe6do26vqwWS_TrJtB-Lro,12198
 schemathesis/specs/graphql/nodes.py,sha256=bE3G1kNmqJ8OV4igBvIK-UORrkQA6Nofduf87O3TD9I,541
 schemathesis/specs/graphql/scalars.py,sha256=9tvLTiYVe8A_E8ASA0czz3Z0Mp9lyak7R4wHpAE_jKo,1805
-schemathesis/specs/graphql/schemas.py,sha256=i6fAW9pYcOplQE7BejP6P8GQ9z6Y43Vx4_feVvbd1B4,13555
+schemathesis/specs/graphql/schemas.py,sha256=w9EvZZ3KrRAmpfIIWZz4qHPRwCOmKX_eovTiqpqLoKs,13926
 schemathesis/specs/graphql/validation.py,sha256=uINIOt-2E7ZuQV2CxKzwez-7L9tDtqzMSpnVoRWvxy0,1635
 schemathesis/specs/openapi/__init__.py,sha256=HDcx3bqpa6qWPpyMrxAbM3uTo0Lqpg-BUNZhDJSJKnw,279
 schemathesis/specs/openapi/_cache.py,sha256=PAiAu4X_a2PQgD2lG5H3iisXdyg4SaHpU46bRZvfNkM,4320
@@ -107,7 +107,7 @@ schemathesis/specs/openapi/definitions.py,sha256=Z186F0gNBSCmPg-Kk7Q-n6XxEZHIOzg
 schemathesis/specs/openapi/examples.py,sha256=5bjmW3BnJVTiLlWZbimdfOzQQFR6m1P9G0FErr9g3WI,15128
 schemathesis/specs/openapi/formats.py,sha256=JmmkQWNAj5XreXb7Edgj4LADAf4m86YulR_Ec8evpJ4,1220
 schemathesis/specs/openapi/links.py,sha256=2ucOLs50OhCqu0PEdbT_BGUM3fKnHBl97YGISLpAxLY,16023
-schemathesis/specs/openapi/loaders.py,sha256=NOVG8Jrl9pv5O64wAgWHrco1okpRzQDamHDnidZdIwY,24905
+schemathesis/specs/openapi/loaders.py,sha256=AcpvTK8qdirSRcHcinCjQbwfSQSx448LAh_GvFML1C0,25515
 schemathesis/specs/openapi/media_types.py,sha256=dNTxpRQbY3SubdVjh4Cjb38R6Bc9MF9BsRQwPD87x0g,1017
 schemathesis/specs/openapi/parameters.py,sha256=_6vNCnPXcdxjfAQbykCRLHjvmTpu_02xDJghxDrGYr8,13611
 schemathesis/specs/openapi/references.py,sha256=euxM02kQGMHh4Ss1jWjOY_gyw_HazafKITIsvOEiAvI,9831
@@ -133,7 +133,7 @@ schemathesis/specs/openapi/stateful/types.py,sha256=UuGcCTFvaHsqeLN9ZeUNcbjsEwmt
 schemathesis/stateful/__init__.py,sha256=qyQJ-9Ect-AWZiAsK63F3BTGu-jZnPCOp1q46YAonkQ,4911
 schemathesis/stateful/config.py,sha256=rtGl3egoUuPFxrWcl5xZj_6KmKzZyYaC0b_AUotvurs,2930
 schemathesis/stateful/context.py,sha256=MeP3-lKyhtAd-jzApC65AWlDZSOBzQq0IgK-nvagYqs,4519
-schemathesis/stateful/events.py,sha256=3AANEwTZFuW9Gbcig70NvdT_h4o5r-Esx9Hpm7zphdg,6710
+schemathesis/stateful/events.py,sha256=reGjsmS-y2izRd3bahpEZNe4zxTSpKAkPI-nCQyoUzI,6733
 schemathesis/stateful/runner.py,sha256=vFd8Id3zzSQVHBK9UgInBpBT7oyUNagQ0p7ZJnPyHRk,10969
 schemathesis/stateful/sink.py,sha256=xjsqJYH5WETKh5pDGlchYyjT3HcjzHEotUjvo1p0JsE,2470
 schemathesis/stateful/state_machine.py,sha256=iRbznWxHnUdLhMpiBaHxe6Nh1EacyGnGFz4DCRwV5j4,12228
@@ -144,8 +144,8 @@ schemathesis/transports/auth.py,sha256=yELjkEkfx4g74hNrd0Db9aFf0xDJDRIwhg2vzKOTZ
 schemathesis/transports/content_types.py,sha256=VrcRQvF5T_TUjrCyrZcYF2LOwKfs3IrLcMtkVSp1ImI,2189
 schemathesis/transports/headers.py,sha256=hr_AIDOfUxsJxpHfemIZ_uNG3_vzS_ZeMEKmZjbYiBE,990
 schemathesis/transports/responses.py,sha256=6-gvVcRK0Ho_lSydUysBNFWoJwZEiEgf6Iv-GWkQGd8,1675
-schemathesis-3.32.1.dist-info/METADATA,sha256=LN3HsIvSIqjk0_UQP7qzHHe9tHceThbE-wu9L15SiF0,17795
-schemathesis-3.32.1.dist-info/WHEEL,sha256=hKi7AIIx6qfnsRbr087vpeJnrVUuDokDHZacPPMW7-Y,87
-schemathesis-3.32.1.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.32.1.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.32.1.dist-info/RECORD,,
+schemathesis-3.33.0.dist-info/METADATA,sha256=hssTV_lu8kmDJgiFDIyKPF7iO7nmsD2NURQh4FlMhaI,17795
+schemathesis-3.33.0.dist-info/WHEEL,sha256=hKi7AIIx6qfnsRbr087vpeJnrVUuDokDHZacPPMW7-Y,87
+schemathesis-3.33.0.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.33.0.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.33.0.dist-info/RECORD,,