schemathesis 3.31.1__tar.gz → 3.32.1__tar.gz

{schemathesis-3.31.1 → schemathesis-3.32.1}/.github/workflows/codeql-analysis.yml

@@ -38,7 +38,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3.25.11
+        uses: github/codeql-action/init@v3.25.12
         with:
           languages: ${{ matrix.language }}
           # If you wish to specify custom queries, you can do so here or in a config file.
@@ -49,7 +49,7 @@ jobs:
       # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
       # If this step fails, then you should remove it and run the build manually (see below)
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v3.25.11
+        uses: github/codeql-action/autobuild@v3.25.12
 
       # ℹ️ Command-line programs to run using the OS shell.
       # 📚 https://git.io/JvXDl
@@ -63,4 +63,4 @@ jobs:
       #   make release
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3.25.11
+        uses: github/codeql-action/analyze@v3.25.12

{schemathesis-3.31.1 → schemathesis-3.32.1}/.pre-commit-config.yaml

@@ -38,17 +38,17 @@ repos:
         additional_dependencies: [types-click, types-requests, types-PyYAML]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.5.0
+    rev: v0.5.1
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.5.0
+    rev: v0.5.1
     hooks:
       - id: ruff
 
   - repo: https://github.com/myint/rstcheck
-    rev: v6.2.0
+    rev: v6.2.4
     hooks:
       - id: rstcheck
         additional_dependencies:

{schemathesis-3.31.1 → schemathesis-3.32.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schemathesis
-Version: 3.31.1
+Version: 3.32.1
 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
@@ -66,6 +66,7 @@ Requires-Dist: aiohttp<4.0,>=3.9.1; extra == 'tests'
 Requires-Dist: coverage>=6; extra == 'tests'
 Requires-Dist: fastapi>=0.86.0; extra == 'tests'
 Requires-Dist: flask<3.0,>=2.1.1; extra == 'tests'
+Requires-Dist: hypothesis-openapi<1,>=0.2; python_version >= '3.10' and extra == 'tests'
 Requires-Dist: pydantic>=1.10.2; extra == 'tests'
 Requires-Dist: pytest-asyncio<1.0,>=0.18.0; extra == 'tests'
 Requires-Dist: pytest-httpserver<2.0,>=1.0; extra == 'tests'

{schemathesis-3.31.1 → schemathesis-3.32.1}/benches/schema.py

@@ -7,6 +7,7 @@ from hypothesis import HealthCheck, Phase, Verbosity
 
 import schemathesis
 from schemathesis.runner import from_schema
+from schemathesis.internal.copy import fast_deepcopy
 
 CURRENT_DIR = pathlib.Path(__file__).parent.absolute()
 sys.path.append(str(CURRENT_DIR.parent))
@@ -222,3 +223,23 @@ def test_links_count(raw_schema):
     schema = schemathesis.from_dict(raw_schema)
 
     _ = schema.links_count
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize(
+    "schema",
+    [
+        BBCI,
+        VMWARE,
+        STRIPE,
+        UNIVERSE,
+        APPVEYOR,
+        EVETECH,
+        OSISOFT,
+        ML_WEBSERVICES,
+        AZURE_NETWORK,
+    ],
+    ids=("bbci", "vmware", "stripe", "universe", "appveyor", "evetech", "osisoft", "ml_webservices", "azure_network"),
+)
+def test_deepcopy(schema):
+    fast_deepcopy(schema)

{schemathesis-3.31.1 → schemathesis-3.32.1}/docs/auth.rst

@@ -237,6 +237,7 @@ Conditions:
 - ``method``: the upper-cased HTTP method of the API operation
 - ``name``: the name of the API operation, such as ``GET /users/`` or ``Query.getUsers``
 - ``tag``: the tag assigned to the API operation. For Open API it comes from the ``tags`` field.
+- ``operation_id``: the ID of an API operation. For Open API it comes from the ``operationId`` field.
 - Each condition can take either a single string or a list of options as input
 - You can also use a regular expression to match the conditions by adding ``_regex`` to the end of the condition and passing a string or a compiled regex.
 

{schemathesis-3.31.1 → schemathesis-3.32.1}/docs/changelog.rst

@@ -1,9 +1,57 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.31.1...HEAD>` - TBD
+:version:`Unreleased <v3.32.1...HEAD>` - TBD
 --------------------------------------------
 
+.. _v3.32.1:
+
+:version:`3.32.1 <v3.32.0...v3.32.1>` - 2024-07-17
+--------------------------------------------------
+
+**Added**
+
+- Filtering by ``operation_id`` in conditional auth implementation.
+
+**Fixed**
+
+- Internal error when saving debug logs with ``--experimental=stateful-test-runner`` or ``--experimental=schema-analysis`` enabled. :issue:`2353`
+
+.. _v3.32.0:
+
+:version:`3.32.0 <v3.31.1...v3.32.0>` - 2024-07-14
+--------------------------------------------------
+
+**Added**
+
+- Support for authentication via CLI arguments in new-style stateful tests.
+- Support for ``--hypothesis-seed`` in new-style stateful tests.
+- Support for ``--set-*`` CLI options in new-style stateful tests.
+- Support for ``--max-response-time`` in new-style stateful tests.
+- Support for targeted property-based testing in new-style stateful tests.
+- Support for ``--request-*`` CLI options in new-style stateful tests.
+- Support for ``--generation-*`` CLI options in new-style stateful tests.
+- Support for ``--max-failures`` in new-style stateful tests.
+- Support for ``--dry-run`` in new-style stateful tests.
+- ``all`` variant for the ``--hypothesis-suppress-health-check`` CLI option.
+- Support for Hypothesis >= ``6.108.0``.
+
+**Fixed**
+
+- WSGI support for new-style stateful tests.
+- Ignoring configured data generation methods in new-style stateful tests.
+- Using constant ``data_generation_method`` value for HTTP interactions in VCR cassettes.
+- Not reporting errors with ``--experimental=stateful-only``. :issue:`2326`
+- Internal error on CTRL-C during new-style stateful tests.
+- Use ``--request-proxy`` for API probing.
+- Fill the ``seed`` field in cassettes for new-style stateful tests.
+- Ignoring remote scope when getting API operation by reference.
+
+**Changed**
+
+- Do not run new-style stateful tests if unit tests exited due to ``--exitfirst``.
+- Display error details if API probing fails.
+
 .. _v3.31.1:
 
 :version:`3.31.1 <v3.31.0...v3.31.1>` - 2024-07-03

{schemathesis-3.31.1 → schemathesis-3.32.1}/example/requirements-pytest.txt

@@ -15,7 +15,7 @@ attrs==23.1.0
     #   referencing
 backoff==2.2.1
     # via schemathesis
-certifi==2023.11.17
+certifi==2024.7.4
     # via
     #   httpcore
     #   httpx

{schemathesis-3.31.1 → schemathesis-3.32.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.31.1"
+version = "3.32.1"
 description = "Property-based testing framework for Open API and GraphQL based apps"
 keywords = ["pytest", "hypothesis", "openapi", "graphql", "testing"]
 authors = [{ name = "Dmitry Dygalo", email = "dmitry@dygalo.dev" }]
@@ -60,6 +60,7 @@ tests = [
     "coverage>=6",
     "fastapi>=0.86.0",
     "Flask>=2.1.1,<3.0",
+    "hypothesis-openapi>=0.2,<1; python_version >= '3.10'",
     "pydantic>=1.10.2",
     "pytest-asyncio>=0.18.0,<1.0",
     "pytest-httpserver>=1.0,<2.0",

{schemathesis-3.31.1 → schemathesis-3.32.1}/src/schemathesis/checks.py

@@ -39,6 +39,10 @@ def not_a_server_error(response: GenericResponse, case: Case) -> bool | None:
     return None
 
 
+def _make_max_response_time_failure_message(elapsed_time: float, max_response_time: int) -> str:
+    return f"Actual: {elapsed_time:.2f}ms\nLimit: {max_response_time}.00ms"
+
+
 DEFAULT_CHECKS: tuple[CheckFunction, ...] = (not_a_server_error,)
 OPTIONAL_CHECKS = (
     status_code_conformance,

{schemathesis-3.31.1 → schemathesis-3.32.1}/src/schemathesis/cli/__init__.py

@@ -47,6 +47,7 @@ from ..specs.graphql import loaders as gql_loaders
 from ..specs.openapi import loaders as oas_loaders
 from ..stateful import Stateful
 from ..targets import Target
+from ..transports import RequestConfig
 from ..transports.auth import get_requests_auth
 from ..types import Filter, PathLike, RequestCert
 from . import callbacks, cassettes, output
@@ -850,7 +851,7 @@ def run(
     _hypothesis_suppress_health_check: list[hypothesis.HealthCheck] | None = None
     if hypothesis_suppress_health_check is not None:
         _hypothesis_suppress_health_check = [
-            health_check.as_hypothesis() for health_check in hypothesis_suppress_health_check
+            entry for health_check in hypothesis_suppress_health_check for entry in health_check.as_hypothesis()
         ]
 
     if contrib_unique_data:
@@ -1073,6 +1074,7 @@ class LoaderConfig:
     wait_for_schema: float | None
     rate_limit: str | None
     output_config: OutputConfig
+    generation_config: generation.GenerationConfig
     # Network request parameters
     auth: tuple[str, str] | None
     auth_type: str | None
@@ -1151,6 +1153,7 @@ def into_event_stream(
             tag=tag or None,
             operation_id=operation_id or None,
             output_config=output_config,
+            generation_config=generation_config,
         )
         schema = load_schema(config)
         yield from runner.from_schema(
@@ -1179,9 +1182,12 @@ def into_event_stream(
             generation_config=generation_config,
             probe_config=probes.ProbeConfig(
                 base_url=config.base_url,
-                request_tls_verify=config.request_tls_verify,
-                request_proxy=config.request_proxy,
-                request_cert=config.request_cert,
+                request=RequestConfig(
+                    timeout=request_timeout,
+                    tls_verify=config.request_tls_verify,
+                    proxy=config.request_proxy,
+                    cert=config.request_cert,
+                ),
                 auth=config.auth,
                 auth_type=config.auth_type,
                 headers=config.headers,
@@ -1297,6 +1303,7 @@ def get_loader_kwargs(loader: Callable, config: LoaderConfig) -> dict[str, Any]:
         "data_generation_methods": config.data_generation_methods,
         "rate_limit": config.rate_limit,
         "output_config": config.output_config,
+        "generation_config": config.generation_config,
     }
     if loader not in (oas_loaders.from_path, oas_loaders.from_dict):
         kwargs["headers"] = config.headers

{schemathesis-3.31.1 → schemathesis-3.32.1}/src/schemathesis/cli/cassettes.py

@@ -23,7 +23,6 @@ if TYPE_CHECKING:
     import click
     import requests
 
-    from ..generation import DataGenerationMethod
     from ..models import Request, Response
     from ..runner.serialization import SerializedCheck, SerializedInteraction
     from .context import ExecutionContext
@@ -90,10 +89,6 @@ class CassetteWriter(EventHandler):
                     seed=seed,
                     correlation_id=event.correlation_id,
                     thread_id=event.thread_id,
-                    # NOTE: For backward compatibility reasons AfterExecution stores a list of data generation methods
-                    # The list always contains one element - the method that was actually used for generation
-                    # This will change in the future
-                    data_generation_method=event.data_generation_method[0],
                     interactions=event.result.interactions,
                 )
             )
@@ -105,7 +100,6 @@ class CassetteWriter(EventHandler):
                     # Correlation ID is not used in stateful testing
                     correlation_id="",
                     thread_id=event.thread_id,
-                    data_generation_method=event.data_generation_method[0],
                     interactions=event.result.interactions,
                 )
             )
@@ -132,7 +126,6 @@ class Process:
     seed: int
     correlation_id: str
     thread_id: int
-    data_generation_method: DataGenerationMethod
     interactions: list[SerializedInteraction]
 
 
@@ -239,7 +232,7 @@ http_interactions:"""
   seed: '{item.seed}'
   thread_id: {item.thread_id}
   correlation_id: '{item.correlation_id}'
-  data_generation_method: '{item.data_generation_method.value}'
+  data_generation_method: '{interaction.data_generation_method.value}'
   elapsed: '{interaction.response.elapsed}'
   recorded_at: '{interaction.recorded_at}'
   checks:

{schemathesis-3.31.1 → schemathesis-3.32.1}/src/schemathesis/cli/constants.py

@@ -42,11 +42,15 @@ class HealthCheck(IntEnum):
     filter_too_much = 2
     too_slow = 3
     large_base_example = 7
+    all = 8
 
-    def as_hypothesis(self) -> hypothesis.HealthCheck:
+    def as_hypothesis(self) -> list[hypothesis.HealthCheck]:
         from hypothesis import HealthCheck
 
-        return HealthCheck[self.name]
+        if self.name == "all":
+            return list(HealthCheck)
+
+        return [HealthCheck[self.name]]
 
 
 @unique

{schemathesis-3.31.1 → schemathesis-3.32.1}/src/schemathesis/cli/output/default.py

@@ -143,7 +143,9 @@ def display_hypothesis_output(hypothesis_output: list[str]) -> None:
 
 def display_errors(context: ExecutionContext, event: events.Finished) -> None:
     """Display all errors in the test run."""
-    if not event.has_errors:
+    probes = context.probes or []
+    has_probe_errors = any(probe.outcome == ProbeOutcome.ERROR for probe in probes)
+    if not event.has_errors and not has_probe_errors:
         return
 
     display_section_name("ERRORS")
@@ -160,6 +162,12 @@ def display_errors(context: ExecutionContext, event: events.Finished) -> None:
         should_display_full_traceback_message |= display_single_error(context, result)
     if event.generic_errors:
         display_generic_errors(context, event.generic_errors)
+    if has_probe_errors:
+        display_section_name("API Probe errors", "_", fg="red")
+        for probe in probes:
+            if probe.error is not None:
+                error = SerializedError.from_exception(probe.error)
+                _display_error(context, error)
     if should_display_full_traceback_message and not context.show_trace:
         click.secho(
             "\nAdd this option to your command line parameters to see full tracebacks: --show-trace",
@@ -848,6 +856,10 @@ def handle_finished(context: ExecutionContext, event: events.Finished) -> None:
 
 def handle_interrupted(context: ExecutionContext, event: events.Interrupted) -> None:
     click.echo()
+    _handle_interrupted(context)
+
+
+def _handle_interrupted(context: ExecutionContext) -> None:
     context.is_interrupted = True
     display_section_name("KeyboardInterrupt", "!", bold=False)
 
@@ -863,12 +875,11 @@ def handle_stateful_event(context: ExecutionContext, event: events.StatefulEvent
         if not experimental.STATEFUL_ONLY.is_enabled:
             click.echo()
         click.secho("Stateful tests\n", bold=True)
-    elif (
-        isinstance(event.data, stateful_events.ScenarioFinished)
-        and not event.data.is_final
-        and event.data.status != stateful_events.ScenarioStatus.REJECTED
-    ):
-        display_execution_result(context, event.data.status.value)
+    elif isinstance(event.data, stateful_events.ScenarioFinished) and not event.data.is_final:
+        if event.data.status == stateful_events.ScenarioStatus.INTERRUPTED:
+            _handle_interrupted(context)
+        elif event.data.status != stateful_events.ScenarioStatus.REJECTED:
+            display_execution_result(context, event.data.status.value)
     elif isinstance(event.data, stateful_events.RunFinished):
         click.echo()
     # It is initialized in `RunStarted`

{schemathesis-3.31.1 → schemathesis-3.32.1}/src/schemathesis/exceptions.py

@@ -520,6 +520,12 @@ def remove_ssl_line_number(text: str) -> str:
     return re.sub(r"\(_ssl\.c:\d+\)", "", text)
 
 
+def _clean_inner_request_message(message: Any) -> str:
+    if isinstance(message, str) and message.startswith("HTTPConnectionPool"):
+        return re.sub(r"HTTPConnectionPool\(.+?\): ", "", message).rstrip(".")
+    return str(message)
+
+
 def extract_requests_exception_details(exc: RequestException) -> tuple[str, list[str]]:
     from requests.exceptions import ChunkedEncodingError, ConnectionError, SSLError
     from urllib3.exceptions import MaxRetryError
@@ -542,7 +548,7 @@ def extract_requests_exception_details(exc: RequestException) -> tuple[str, list
                 reason = f"Max retries exceeded with url: {inner.url}"
             extra = [reason.strip()]
         else:
-            extra = [" ".join(map(str, inner.args))]
+            extra = [" ".join(map(_clean_inner_request_message, inner.args))]
     elif isinstance(exc, ChunkedEncodingError):
         message = "Connection broken. The server declared chunked encoding but sent an invalid chunk"
         extra = [str(exc.args[0].args[1])]

{schemathesis-3.31.1 → schemathesis-3.32.1}/src/schemathesis/filters.py

@@ -8,6 +8,8 @@ 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 .exceptions import UsageError
 
 if TYPE_CHECKING:
@@ -58,7 +60,12 @@ class Matcher:
     def for_regex(cls, attribute: str, regex: RegexValue) -> Matcher:
         """Matcher that checks whether the specified attribute has the provided regex."""
         if isinstance(regex, str):
-            regex = re.compile(regex)
+            flags: re.RegexFlag | int
+            if attribute == "method":
+                flags = re.IGNORECASE
+            else:
+                flags = 0
+            regex = re.compile(regex, flags=flags)
         func = partial(by_regex, attribute=attribute, regex=regex)
         label = f"{attribute}_regex={repr(regex)}"
         return cls(func, label=label, _hash=hash(label))
@@ -71,6 +78,8 @@ class Matcher:
 def get_operation_attribute(operation: APIOperation, attribute: str) -> str | list[str] | None:
     if attribute == "tag":
         return operation.tags
+    if attribute == "operation_id":
+        return operation.definition.raw.get("operationId")
     # Just uppercase `method`
     value = getattr(operation, attribute)
     if attribute == "method":
@@ -101,8 +110,8 @@ def by_regex(ctx: HasAPIOperation, attribute: str, regex: re.Pattern) -> bool:
     if value is None:
         return False
     if isinstance(value, list):
-        return any(bool(regex.match(entry)) for entry in value)
-    return bool(regex.match(value))
+        return any(bool(regex.search(entry)) for entry in value)
+    return bool(regex.search(value))
 
 
 @dataclass(repr=False, frozen=True)
@@ -111,6 +120,8 @@ class Filter:
 
     matchers: tuple[Matcher, ...]
 
+    __slots__ = ("matchers",)
+
     def __repr__(self) -> str:
         inner = " && ".join(matcher.label for matcher in self.matchers)
         return f"<{self.__class__.__name__}: [{inner}]>"
@@ -127,8 +138,14 @@ class Filter:
 class FilterSet:
     """Combines multiple filters to apply inclusion and exclusion rules on API operations."""
 
-    _includes: set[Filter] = field(default_factory=set)
-    _excludes: set[Filter] = field(default_factory=set)
+    _includes: set[Filter]
+    _excludes: set[Filter]
+
+    __slots__ = ("_includes", "_excludes")
+
+    def __init__(self) -> None:
+        self._includes = set()
+        self._excludes = set()
 
     def apply_to(self, operations: list[APIOperation]) -> list[APIOperation]:
         """Get a filtered list of the given operations that match the filters."""
@@ -168,6 +185,8 @@ class FilterSet:
         path_regex: RegexValue | None = None,
         tag: FilterValue | None = None,
         tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
     ) -> None:
         """Add a new INCLUDE filter."""
         self._add_filter(
@@ -181,6 +200,8 @@ class FilterSet:
             path_regex=path_regex,
             tag=tag,
             tag_regex=tag_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
         )
 
     def exclude(
@@ -195,6 +216,8 @@ class FilterSet:
         path_regex: RegexValue | None = None,
         tag: FilterValue | None = None,
         tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
     ) -> None:
         """Add a new EXCLUDE filter."""
         self._add_filter(
@@ -208,6 +231,8 @@ class FilterSet:
             path_regex=path_regex,
             tag=tag,
             tag_regex=tag_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
         )
 
     def _add_filter(
@@ -223,6 +248,8 @@ class FilterSet:
         path_regex: RegexValue | None = None,
         tag: FilterValue | None = None,
         tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
     ) -> None:
         matchers = []
         if func is not None:
@@ -232,6 +259,7 @@ class FilterSet:
             ("method", method, method_regex),
             ("path", path, path_regex),
             ("tag", tag, tag_regex),
+            ("operation_id", operation_id, operation_id_regex),
         ):
             if expected is not None and regex is not None:
                 # To match anything the regex should match the expected value, hence passing them together is useless
@@ -295,3 +323,74 @@ def attach_filter_chain(
     proxy.__name__ = attribute
 
     setattr(target, attribute, proxy)
+
+
+def filter_set_from_components(
+    *,
+    include: bool,
+    method: FilterType | None = None,
+    endpoint: FilterType | None = None,
+    tag: FilterType | None = None,
+    operation_id: FilterType | None = None,
+    skip_deprecated_operations: bool | None | NotSet = None,
+    parent: FilterSet | None = None,
+) -> FilterSet:
+    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
+        if isinstance(filter_, str):
+            return filter_
+        return "|".join(f"({f})" for f in filter_)
+
+    new = FilterSet()
+
+    if _is_defined(method) or _is_defined(endpoint) or _is_defined(tag) or _is_defined(operation_id):
+        new._add_filter(
+            include,
+            method_regex=_prepare_filter(method),
+            path_regex=_prepare_filter(endpoint),
+            tag_regex=_prepare_filter(tag),
+            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
+    ):
+        new.exclude(func=_is_deprecated)
+    # Merge with the parent filter set
+    if parent is not None:
+        for include_ in parent._includes:
+            matchers = include_.matchers
+            ids = []
+            for idx, matcher in enumerate(matchers):
+                label = matcher.label
+                if (
+                    (not isinstance(method, NotSet) and label.startswith("method_regex="))
+                    or (not isinstance(endpoint, NotSet) and label.startswith("path_regex="))
+                    or (not isinstance(tag, NotSet) and matcher.label.startswith("tag_regex="))
+                    or (not isinstance(operation_id, NotSet) and matcher.label.startswith("operation_id_regex="))
+                ):
+                    ids.append(idx)
+            if ids:
+                matchers = tuple(matcher for idx, matcher in enumerate(matchers) if idx not in ids)
+            if matchers:
+                if new._includes:
+                    existing = new._includes.pop()
+                    matchers = existing.matchers + matchers
+                new._includes.add(Filter(matchers=matchers))
+        for exclude_ in parent._excludes:
+            matchers = exclude_.matchers
+            ids = []
+            for idx, matcher in enumerate(exclude_.matchers):
+                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

{schemathesis-3.31.1 → schemathesis-3.32.1}/src/schemathesis/internal/copy.py

@@ -1,6 +1,9 @@
 from typing import Any
 
+from .extensions import extensible
 
+
+@extensible("SCHEMATHESIS_EXTENSION_FAST_DEEP_COPY")
 def fast_deepcopy(value: Any) -> Any:
     """A specialized version of `deepcopy` that copies only `dict` and `list` and does unrolling.
 

schemathesis-3.32.1/src/schemathesis/internal/extensions.py

@@ -0,0 +1,27 @@
+import os
+from typing import Any, Callable
+
+
+class ExtensionLoadingError(ImportError):
+    """Raised when an extension cannot be loaded."""
+
+
+def import_extension(path: str) -> Any:
+    try:
+        module, item = path.rsplit(".", 1)
+        imported = __import__(module, fromlist=[item])
+        return getattr(imported, item)
+    except ValueError as exc:
+        raise ExtensionLoadingError(f"Invalid path: {path}") from exc
+    except (ImportError, AttributeError) as exc:
+        raise ExtensionLoadingError(f"Could not import {path}") from exc
+
+
+def extensible(env_var: str) -> Callable[[Any], Any]:
+    def decorator(item: Any) -> Any:
+        path = os.getenv(env_var)
+        if path is not None:
+            return import_extension(path)
+        return item
+
+    return decorator

{schemathesis-3.31.1 → schemathesis-3.32.1}/src/schemathesis/lazy.py

@@ -19,6 +19,7 @@ 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 .generation import DataGenerationMethodInput, GenerationConfig
 from .hooks import HookDispatcher, HookScope
 from .internal.output import OutputConfig
@@ -341,18 +342,24 @@ def get_schema(
     schema = request.getfixturevalue(name)
     if not isinstance(schema, BaseSchema):
         raise ValueError(f"The given schema must be an instance of BaseSchema, got: {type(schema)}")
-    return schema.clone(
-        base_url=base_url,
+
+    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=schema.filter_set,
+    )
+    return schema.clone(
+        base_url=base_url,
+        filter_set=filter_set,
         app=app,
         test_function=test_function,
         hooks=schema.hooks.merge(hooks),
         auth=auth,
         validate_schema=validate_schema,
-        skip_deprecated_operations=skip_deprecated_operations,
         data_generation_methods=data_generation_methods,
         generation_config=generation_config,
         output_config=output_config,