schemathesis 3.25.6__py3-none-any.whl → 3.39.7__py3-none-any.whl

schemathesis/lazy.py

@@ -1,29 +1,28 @@
 from __future__ import annotations
+
+from contextlib import nullcontext
 from dataclasses import dataclass, field
 from inspect import signature
-from typing import Any, Callable, Generator
+from typing import TYPE_CHECKING, Any, Callable, Generator, Type
 
 import pytest
-from _pytest.fixtures import FixtureRequest
 from hypothesis.core import HypothesisHandle
 from hypothesis.errors import Flaky
 from hypothesis.internal.escalation import format_exception, get_trimmed_traceback
 from hypothesis.internal.reflection import impersonate
-from pyrate_limiter import Limiter
-from pytest_subtests import SubTests, nullcontext
+from pytest_subtests import SubTests
 
 from ._compat import MultipleFailures, get_interesting_origin
-from ._override import check_no_override_mark, CaseOverride, set_override_mark, get_override_from_mark
+from ._override import CaseOverride, check_no_override_mark, get_override_from_mark, set_override_mark
 from .auths import AuthStorage
 from .code_samples import CodeSampleStyle
 from .constants import FLAKY_FAILURE_MESSAGE, NOT_SET
-from .generation import DataGenerationMethodInput, GenerationConfig
 from .exceptions import CheckFailed, OperationSchemaError, SkipTest, get_grouped_exception
+from .filters import FilterSet, FilterValue, MatcherFunc, RegexValue, filter_set_from_components, is_deprecated
 from .hooks import HookDispatcher, HookScope
+from .internal.deprecation import warn_filtration_arguments
 from .internal.result import Ok
-from .models import APIOperation
 from .schemas import BaseSchema
-from .types import Filter, GenericTest, NotSet
 from .utils import (
     GivenInput,
     fail_on_no_matches,
@@ -35,26 +34,130 @@ from .utils import (
     validate_given_args,
 )
 
+if TYPE_CHECKING:
+    from _pytest.fixtures import FixtureRequest
+    from pyrate_limiter import Limiter
+
+    from .generation import DataGenerationMethodInput, GenerationConfig
+    from .internal.output import OutputConfig
+    from .models import APIOperation
+    from .types import Filter, GenericTest, NotSet
+
 
 @dataclass
 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
     code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
     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)
 
@@ -68,20 +171,19 @@ class LazySchema:
         skip_deprecated_operations: 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: 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:
             generation_config = self.generation_config
+        if output_config is NOT_SET:
+            output_config = self.output_config
         if isinstance(code_sample_style, str):
             _code_sample_style = CodeSampleStyle.from_str(code_sample_style)
         else:
@@ -121,10 +223,12 @@ class LazySchema:
                     skip_deprecated_operations=skip_deprecated_operations,
                     data_generation_methods=data_generation_methods,
                     generation_config=generation_config,
+                    output_config=output_config,
                     code_sample_style=_code_sample_style,
                     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
@@ -207,7 +311,7 @@ def _copy_marks(source: Callable, target: Callable) -> None:
     target.pytestmark.extend(marks)  # type: ignore
 
 
-def _get_capturemanager(request: FixtureRequest) -> Generator:
+def _get_capturemanager(request: FixtureRequest) -> Generator | Type[nullcontext]:
     capturemanager = request.node.config.pluginmanager.get_plugin("capturemanager")
     if capturemanager is not None:
         return capturemanager.global_and_fixture_disabled
@@ -317,6 +421,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,
@@ -325,6 +430,7 @@ def get_schema(
     skip_deprecated_operations: 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,
     rate_limiter: Limiter | None,
     sanitize_output: bool,
@@ -333,20 +439,27 @@ 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.merge(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,
         code_sample_style=code_sample_style,
         rate_limiter=rate_limiter,
         sanitize_output=sanitize_output,

schemathesis/loaders.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
+
 import re
 import sys
 from functools import lru_cache
-from typing import Callable, TypeVar, TYPE_CHECKING, TextIO, Any, BinaryIO
+from typing import TYPE_CHECKING, Any, BinaryIO, Callable, TextIO, TypeVar
 
 from .exceptions import SchemaError, SchemaErrorType, extract_requests_exception_details
 
 if TYPE_CHECKING:
-    from .transports.responses import GenericResponse
     import yaml
 
+    from .transports.responses import GenericResponse
+
 R = TypeVar("R", bound="GenericResponse")
 
 
@@ -49,13 +51,13 @@ def _raise_for_status(response: GenericResponse) -> None:
         else:
             type_ = SchemaErrorType.HTTP_CLIENT_ERROR
     else:
-        return None
+        return
     raise SchemaError(message=message, type=type_, url=response.request.url, response=response, extras=[])
 
 
 def load_app(path: str) -> Any:
     """Import an application from a string."""
-    path, name = (re.split(r":(?![\\/])", path, maxsplit=1) + [""])[:2]
+    path, name = ([*re.split(":(?![\\\\/])", path, maxsplit=1), ""])[:2]
     __import__(path)
     # accessing the module from sys.modules returns a proper module, while `__import__`
     # may return a parent module (system dependent)
@@ -90,7 +92,7 @@ def get_yaml_loader() -> type[yaml.SafeLoader]:
                        |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*
                        |[-+]?\.(?:inf|Inf|INF)
                        |\.(?:nan|NaN|NAN))$""",
-            re.X,
+            re.VERBOSE,
         ),
         list("-+0123456789."),
     )