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

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/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,

schemathesis/runner/events.py

@@ -9,7 +9,8 @@ from typing import TYPE_CHECKING, Any
 from ..exceptions import RuntimeErrorType, SchemaError, SchemaErrorType, format_exception
 from ..generation import DataGenerationMethod
 from ..internal.datetime import current_datetime
-from ..internal.result import Result
+from ..internal.result import Err, Ok, Result
+from ..service.models import AnalysisSuccess
 from .serialization import SerializedError, SerializedTestResult
 
 if TYPE_CHECKING:
@@ -105,6 +106,23 @@ class BeforeAnalysis(ExecutionEvent):
 class AfterAnalysis(ExecutionEvent):
     analysis: Result[AnalysisResult, Exception] | None
 
+    def _serialize(self) -> dict[str, Any]:
+        data = {}
+        if isinstance(self.analysis, Ok):
+            result = self.analysis.ok()
+            if isinstance(result, AnalysisSuccess):
+                data["analysis_id"] = result.id
+            else:
+                data["error"] = result.message
+        elif isinstance(self.analysis, Err):
+            data["error"] = format_exception(self.analysis.err())
+        return data
+
+    def asdict(self, **kwargs: Any) -> dict[str, Any]:
+        data = self._serialize()
+        data["event_type"] = self.__class__.__name__
+        return data
+
 
 class CurrentOperationMixin:
     method: str
@@ -296,6 +314,9 @@ class StatefulEvent(ExecutionEvent):
 
     __slots__ = ("data",)
 
+    def asdict(self, **kwargs: Any) -> dict[str, Any]:
+        return {"data": self.data.asdict(**kwargs), "event_type": self.__class__.__name__}
+
 
 @dataclass
 class AfterStatefulExecution(ExecutionEvent):

schemathesis/runner/serialization.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 import logging
 import re
 import textwrap
-from dataclasses import dataclass, field
+from dataclasses import asdict, dataclass, field
 from typing import TYPE_CHECKING, Any, cast
 
 from ..code_samples import get_excluded_headers
@@ -453,3 +453,72 @@ def deduplicate_failures(checks: list[SerializedCheck]) -> list[SerializedCheck]
                 unique_checks.append(check)
                 seen.add(key)
     return unique_checks
+
+
+def _serialize_case(case: SerializedCase) -> dict[str, Any]:
+    return {
+        "id": case.id,
+        "generation_time": case.generation_time,
+        "verbose_name": case.verbose_name,
+        "path_template": case.path_template,
+        "path_parameters": stringify_path_parameters(case.path_parameters),
+        "query": prepare_query(case.query),
+        "cookies": case.cookies,
+        "media_type": case.media_type,
+    }
+
+
+def _serialize_response(response: Response) -> dict[str, Any]:
+    return {
+        "status_code": response.status_code,
+        "headers": response.headers,
+        "body": response.body,
+        "encoding": response.encoding,
+        "elapsed": response.elapsed,
+    }
+
+
+def _serialize_check(check: SerializedCheck) -> dict[str, Any]:
+    return {
+        "name": check.name,
+        "value": check.value,
+        "request": {
+            "method": check.request.method,
+            "uri": check.request.uri,
+            "body": check.request.body,
+            "headers": check.request.headers,
+        },
+        "response": _serialize_response(check.response) if check.response is not None else None,
+        "example": _serialize_case(check.example),
+        "message": check.message,
+        "context": asdict(check.context) if check.context is not None else None,  # type: ignore
+        "history": [
+            {"case": _serialize_case(entry.case), "response": _serialize_response(entry.response)}
+            for entry in check.history
+        ],
+    }
+
+
+def stringify_path_parameters(path_parameters: dict[str, Any] | None) -> dict[str, str]:
+    """Cast all path parameter values to strings.
+
+    Path parameter values may be of arbitrary type, but to display them properly they should be casted to strings.
+    """
+    return {key: str(value) for key, value in (path_parameters or {}).items()}
+
+
+def prepare_query(query: dict[str, Any] | None) -> dict[str, list[str]]:
+    """Convert all query values to list of strings.
+
+    Query parameters may be generated in different shapes, including integers, strings, list of strings, etc.
+    It can also be an object, if the schema contains an object, but `style` and `explode` combo is not applicable.
+    """
+
+    def to_list_of_strings(value: Any) -> list[str]:
+        if isinstance(value, list):
+            return list(map(str, value))
+        if isinstance(value, str):
+            return [value]
+        return [str(value)]
+
+    return {key: to_list_of_strings(value) for key, value in (query or {}).items()}

schemathesis/schemas.py

@@ -37,6 +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 .generation import (
     DEFAULT_DATA_GENERATION_METHODS,
     DataGenerationMethod,
@@ -81,16 +82,12 @@ class BaseSchema(Mapping):
     transport: Transport
     location: str | None = None
     base_url: str | None = None
-    method: Filter | None = None
-    endpoint: Filter | None = None
-    tag: Filter | None = None
-    operation_id: Filter | None = None
+    filter_set: FilterSet = field(default_factory=FilterSet)
     app: Any = None
     hooks: HookDispatcher = field(default_factory=lambda: HookDispatcher(scope=HookScope.SCHEMA))
     auth: AuthStorage = field(default_factory=AuthStorage)
     test_function: GenericTest | None = None
     validate_schema: bool = True
-    skip_deprecated_operations: bool = False
     data_generation_methods: list[DataGenerationMethod] = field(
         default_factory=lambda: list(DEFAULT_DATA_GENERATION_METHODS)
     )
@@ -242,6 +239,16 @@ class BaseSchema(Mapping):
             CodeSampleStyle.from_str(code_sample_style) if isinstance(code_sample_style, str) else code_sample_style
         )
 
+        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,
+        )
+
         def wrapper(func: GenericTest) -> GenericTest:
             if hasattr(func, PARAMETRIZE_MARKER):
 
@@ -256,13 +263,9 @@ class BaseSchema(Mapping):
             HookDispatcher.add_dispatcher(func)
             cloned = self.clone(
                 test_function=func,
-                method=method,
-                endpoint=endpoint,
-                tag=tag,
-                operation_id=operation_id,
                 validate_schema=validate_schema,
-                skip_deprecated_operations=skip_deprecated_operations,
                 data_generation_methods=data_generation_methods,
+                filter_set=filter_set,
                 code_sample_style=_code_sample_style,  # type: ignore
             )
             setattr(func, PARAMETRIZE_MARKER, cloned)
@@ -279,38 +282,26 @@ class BaseSchema(Mapping):
         *,
         base_url: str | None | NotSet = NOT_SET,
         test_function: GenericTest | None = None,
-        method: Filter | None = NOT_SET,
-        endpoint: Filter | None = NOT_SET,
-        tag: Filter | None = NOT_SET,
-        operation_id: Filter | None = NOT_SET,
         app: Any = NOT_SET,
         hooks: HookDispatcher | NotSet = NOT_SET,
         auth: AuthStorage | NotSet = NOT_SET,
         validate_schema: bool | NotSet = NOT_SET,
-        skip_deprecated_operations: bool | NotSet = NOT_SET,
         data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
         generation_config: GenerationConfig | NotSet = NOT_SET,
         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,
     ) -> BaseSchema:
         if base_url is NOT_SET:
             base_url = self.base_url
-        if method is NOT_SET:
-            method = self.method
-        if endpoint is NOT_SET:
-            endpoint = self.endpoint
-        if tag is NOT_SET:
-            tag = self.tag
-        if operation_id is NOT_SET:
-            operation_id = self.operation_id
         if app is NOT_SET:
             app = self.app
         if validate_schema is NOT_SET:
             validate_schema = self.validate_schema
-        if skip_deprecated_operations is NOT_SET:
-            skip_deprecated_operations = self.skip_deprecated_operations
+        if filter_set is None:
+            filter_set = self.filter_set
         if hooks is NOT_SET:
             hooks = self.hooks
         if auth is NOT_SET:
@@ -332,22 +323,18 @@ class BaseSchema(Mapping):
             self.raw_schema,
             location=self.location,
             base_url=base_url,  # type: ignore
-            method=method,
-            endpoint=endpoint,
-            tag=tag,
-            operation_id=operation_id,
             app=app,
             hooks=hooks,  # type: ignore
             auth=auth,  # type: ignore
             test_function=test_function,
             validate_schema=validate_schema,  # type: ignore
-            skip_deprecated_operations=skip_deprecated_operations,  # type: ignore
             data_generation_methods=data_generation_methods,  # type: ignore
             generation_config=generation_config,  # type: ignore
             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,
         )
 

schemathesis/service/serialization.py

@@ -3,14 +3,10 @@ from __future__ import annotations
 from dataclasses import asdict
 from typing import Any, Callable, Dict, Optional, TypeVar, cast
 
-from ..exceptions import format_exception
-from ..internal.result import Err, Ok
 from ..internal.transformation import merge_recursively
-from ..models import Response
 from ..runner import events
-from ..runner.serialization import SerializedCase, SerializedCheck
+from ..runner.serialization import _serialize_check
 from ..stateful import events as stateful_events
-from .models import AnalysisSuccess
 
 S = TypeVar("S", bound=events.ExecutionEvent)
 SerializeFunc = Callable[[S], Optional[Dict[str, Any]]]
@@ -38,17 +34,7 @@ def serialize_before_analysis(_: events.BeforeAnalysis) -> None:
 
 
 def serialize_after_analysis(event: events.AfterAnalysis) -> dict[str, Any] | None:
-    data = {}
-    analysis = event.analysis
-    if isinstance(analysis, Ok):
-        result = analysis.ok()
-        if isinstance(result, AnalysisSuccess):
-            data["analysis_id"] = result.id
-        else:
-            data["error"] = result.message
-    elif isinstance(analysis, Err):
-        data["error"] = format_exception(analysis.err())
-    return data
+    return event._serialize()
 
 
 def serialize_before_execution(event: events.BeforeExecution) -> dict[str, Any] | None:
@@ -59,50 +45,6 @@ def serialize_before_execution(event: events.BeforeExecution) -> dict[str, Any]
     }
 
 
-def _serialize_case(case: SerializedCase) -> dict[str, Any]:
-    return {
-        "id": case.id,
-        "generation_time": case.generation_time,
-        "verbose_name": case.verbose_name,
-        "path_template": case.path_template,
-        "path_parameters": stringify_path_parameters(case.path_parameters),
-        "query": prepare_query(case.query),
-        "cookies": case.cookies,
-        "media_type": case.media_type,
-    }
-
-
-def _serialize_response(response: Response) -> dict[str, Any]:
-    return {
-        "status_code": response.status_code,
-        "headers": response.headers,
-        "body": response.body,
-        "encoding": response.encoding,
-        "elapsed": response.elapsed,
-    }
-
-
-def _serialize_check(check: SerializedCheck) -> dict[str, Any]:
-    return {
-        "name": check.name,
-        "value": check.value,
-        "request": {
-            "method": check.request.method,
-            "uri": check.request.uri,
-            "body": check.request.body,
-            "headers": check.request.headers,
-        },
-        "response": _serialize_response(check.response) if check.response is not None else None,
-        "example": _serialize_case(check.example),
-        "message": check.message,
-        "context": asdict(check.context) if check.context is not None else None,  # type: ignore
-        "history": [
-            {"case": _serialize_case(entry.case), "response": _serialize_response(entry.response)}
-            for entry in check.history
-        ],
-    }
-
-
 def serialize_after_execution(event: events.AfterExecution) -> dict[str, Any] | None:
     return {
         "correlation_id": event.correlation_id,
@@ -154,45 +96,7 @@ def serialize_stateful_event(event: events.StatefulEvent) -> dict[str, Any] | No
 
 
 def _serialize_stateful_event(event: stateful_events.StatefulEvent) -> dict[str, Any] | None:
-    data: dict[str, Any]
-    if isinstance(event, stateful_events.RunStarted):
-        data = {
-            "timestamp": event.timestamp,
-            "started_at": event.started_at,
-        }
-    elif isinstance(event, stateful_events.SuiteFinished):
-        data = {
-            "timestamp": event.timestamp,
-            "status": event.status,
-            "failures": [_serialize_check(SerializedCheck.from_check(failure)) for failure in event.failures],
-        }
-    elif isinstance(event, stateful_events.Errored):
-        data = {
-            "timestamp": event.timestamp,
-            "exception": format_exception(event.exception, True),
-        }
-    elif isinstance(event, stateful_events.StepFinished):
-        data = {
-            "timestamp": event.timestamp,
-            "status": event.status,
-            "transition_id": {
-                "name": event.transition_id.name,
-                "status_code": event.transition_id.status_code,
-                "source": event.transition_id.source,
-            }
-            if event.transition_id is not None
-            else None,
-            "target": event.target,
-            "response": {
-                "status_code": event.response.status_code,
-                "elapsed": event.response.elapsed.total_seconds(),
-            }
-            if event.response is not None
-            else None,
-        }
-    else:
-        data = asdict(event)
-    return {"data": {event.__class__.__name__: data}}
+    return {"data": {event.__class__.__name__: event.asdict()}}
 
 
 def serialize_after_stateful_execution(event: events.AfterStatefulExecution) -> dict[str, Any] | None:
@@ -264,28 +168,3 @@ def serialize_event(
             data = merge_recursively(data, extra)
     # Externally tagged structure
     return {event.__class__.__name__: data}
-
-
-def stringify_path_parameters(path_parameters: dict[str, Any] | None) -> dict[str, str]:
-    """Cast all path parameter values to strings.
-
-    Path parameter values may be of arbitrary type, but to display them properly they should be casted to strings.
-    """
-    return {key: str(value) for key, value in (path_parameters or {}).items()}
-
-
-def prepare_query(query: dict[str, Any] | None) -> dict[str, list[str]]:
-    """Convert all query values to list of strings.
-
-    Query parameters may be generated in different shapes, including integers, strings, list of strings, etc.
-    It can also be an object, if the schema contains an object, but `style` and `explode` combo is not applicable.
-    """
-
-    def to_list_of_strings(value: Any) -> list[str]:
-        if isinstance(value, list):
-            return list(map(str, value))
-        if isinstance(value, str):
-            return [value]
-        return [str(value)]
-
-    return {key: to_list_of_strings(value) for key, value in (query or {}).items()}

schemathesis/specs/openapi/loaders.py

@@ -11,6 +11,7 @@ from ... import experimental, fixups
 from ...code_samples import CodeSampleStyle
 from ...constants import NOT_SET, WAIT_FOR_SCHEMA_INTERVAL
 from ...exceptions import SchemaError, SchemaErrorType
+from ...filters import filter_set_from_components
 from ...generation import (
     DEFAULT_DATA_GENERATION_METHODS,
     DataGenerationMethod,
@@ -330,17 +331,22 @@ def from_dict(
     if rate_limit is not None:
         rate_limiter = build_limiter(rate_limit)
 
+    filter_set = filter_set_from_components(
+        include=True,
+        method=method,
+        endpoint=endpoint,
+        tag=tag,
+        operation_id=operation_id,
+        skip_deprecated_operations=skip_deprecated_operations,
+    )
+
     def init_openapi_2() -> SwaggerV20:
         _maybe_validate_schema(raw_schema, definitions.SWAGGER_20_VALIDATOR, validate_schema)
         instance = SwaggerV20(
             raw_schema,
             app=app,
             base_url=base_url,
-            method=method,
-            endpoint=endpoint,
-            tag=tag,
-            operation_id=operation_id,
-            skip_deprecated_operations=skip_deprecated_operations,
+            filter_set=filter_set,
             validate_schema=validate_schema,
             data_generation_methods=DataGenerationMethod.ensure_list(data_generation_methods),
             generation_config=generation_config or GenerationConfig(),
@@ -379,11 +385,7 @@ def from_dict(
             raw_schema,
             app=app,
             base_url=base_url,
-            method=method,
-            endpoint=endpoint,
-            tag=tag,
-            operation_id=operation_id,
-            skip_deprecated_operations=skip_deprecated_operations,
+            filter_set=filter_set,
             validate_schema=validate_schema,
             data_generation_methods=DataGenerationMethod.ensure_list(data_generation_methods),
             generation_config=generation_config or GenerationConfig(),

schemathesis/specs/openapi/schemas.py

@@ -8,6 +8,7 @@ from difflib import get_close_matches
 from hashlib import sha1
 from json import JSONDecodeError
 from threading import RLock
+from types import SimpleNamespace
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -63,13 +64,6 @@ from ._hypothesis import get_case_strategy
 from .converter import to_json_schema, to_json_schema_recursive
 from .definitions import OPENAPI_30_VALIDATOR, OPENAPI_31_VALIDATOR, SWAGGER_20_VALIDATOR
 from .examples import get_strategies_from_examples
-from .filters import (
-    should_skip_by_operation_id,
-    should_skip_by_tag,
-    should_skip_deprecated,
-    should_skip_endpoint,
-    should_skip_method,
-)
 from .parameters import (
     OpenAPI20Body,
     OpenAPI20CompositeBody,
@@ -149,14 +143,32 @@ class BaseOpenAPISchema(BaseSchema):
             message += f". Did you mean `{matches[0]}`?"
         raise OperationNotFound(message=message, item=item) from exc
 
-    def _should_skip(self, method: str, definition: dict[str, Any]) -> bool:
-        return (
-            method not in HTTP_METHODS
-            or should_skip_method(method, self.method)
-            or should_skip_deprecated(definition.get("deprecated", False), self.skip_deprecated_operations)
-            or should_skip_by_tag(definition.get("tags"), self.tag)
-            or should_skip_by_operation_id(definition.get("operationId"), self.operation_id)
-        )
+    def _should_skip(
+        self,
+        path: str,
+        method: str,
+        definition: dict[str, Any],
+        _ctx_cache: SimpleNamespace = SimpleNamespace(
+            operation=APIOperation(
+                method="",
+                path="",
+                verbose_name="",
+                definition=OperationDefinition(raw=None, resolved=None, scope=""),
+                schema=None,  # type: ignore
+            )
+        ),
+    ) -> bool:
+        if method not in HTTP_METHODS:
+            return True
+        # Attribute assignment is way faster than creating a new namespace every time
+        operation = _ctx_cache.operation
+        operation.method = method
+        operation.path = path
+        operation.verbose_name = f"{method.upper()} {path}"
+        operation.definition.raw = definition
+        operation.definition.resolved = definition
+        operation.schema = self
+        return not self.filter_set.match(_ctx_cache)
 
     def _operation_iter(self) -> Generator[dict[str, Any], None, None]:
         try:
@@ -164,19 +176,16 @@ class BaseOpenAPISchema(BaseSchema):
         except KeyError:
             return
         get_full_path = self.get_full_path
-        endpoint = self.endpoint
         resolve = self.resolver.resolve
         should_skip = self._should_skip
         for path, path_item in paths.items():
             full_path = get_full_path(path)
-            if should_skip_endpoint(full_path, endpoint):
-                continue
             try:
                 if "$ref" in path_item:
                     _, path_item = resolve(path_item["$ref"])
                 # Straightforward iteration is faster than converting to a set & calculating length.
                 for method, definition in path_item.items():
-                    if should_skip(method, definition):
+                    if should_skip(full_path, method, definition):
                         continue
                     yield definition
             except SCHEMA_PARSING_ERRORS:
@@ -274,7 +283,6 @@ class BaseOpenAPISchema(BaseSchema):
         context = HookContext()
         # Optimization: local variables are faster than attribute access
         get_full_path = self.get_full_path
-        endpoint = self.endpoint
         dispatch_hook = self.dispatch_hook
         resolve_path_item = self._resolve_path_item
         resolve_shared_parameters = self._resolve_shared_parameters
@@ -287,8 +295,6 @@ class BaseOpenAPISchema(BaseSchema):
             method = None
             try:
                 full_path = get_full_path(path)  # Should be available for later use
-                if should_skip_endpoint(full_path, endpoint):
-                    continue
                 dispatch_hook("before_process_path", context, path, path_item)
                 scope, path_item = resolve_path_item(path_item)
                 with in_scope(self.resolver, scope):
@@ -298,7 +304,7 @@ class BaseOpenAPISchema(BaseSchema):
                             continue
                         try:
                             resolved = resolve_operation(entry)
-                            if should_skip(method, resolved):
+                            if should_skip(full_path, method, resolved):
                                 continue
                             parameters = resolved.get("parameters", ())
                             parameters = collect_parameters(itertools.chain(parameters, shared_parameters), resolved)

schemathesis/stateful/events.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 import time
-from dataclasses import dataclass
+from dataclasses import asdict as _asdict, dataclass
 from enum import Enum
-from typing import TYPE_CHECKING, Type
+from typing import TYPE_CHECKING, Type, Any
+
+from ..exceptions import format_exception
 
 if TYPE_CHECKING:
     from ..models import Case, Check
@@ -28,6 +30,9 @@ class StatefulEvent:
 
     __slots__ = ("timestamp",)
 
+    def asdict(self) -> dict[str, Any]:
+        return _asdict(self)
+
 
 @dataclass
 class RunStarted(StatefulEvent):
@@ -43,6 +48,12 @@ class RunStarted(StatefulEvent):
         self.started_at = time.time()
         self.timestamp = time.monotonic()
 
+    def asdict(self) -> dict[str, Any]:
+        return {
+            "timestamp": self.timestamp,
+            "started_at": self.started_at,
+        }
+
 
 @dataclass
 class RunFinished(StatefulEvent):
@@ -90,6 +101,15 @@ class SuiteFinished(StatefulEvent):
         self.failures = failures
         self.timestamp = time.monotonic()
 
+    def asdict(self) -> dict[str, Any]:
+        from ..runner.serialization import SerializedCheck, _serialize_check
+
+        return {
+            "timestamp": self.timestamp,
+            "status": self.status,
+            "failures": [_serialize_check(SerializedCheck.from_check(failure)) for failure in self.failures],
+        }
+
 
 class ScenarioStatus(str, Enum):
     """Status of a single scenario execution."""
@@ -203,6 +223,26 @@ class StepFinished(StatefulEvent):
         self.checks = checks
         self.timestamp = time.monotonic()
 
+    def asdict(self) -> dict[str, Any]:
+        return {
+            "timestamp": self.timestamp,
+            "status": self.status,
+            "transition_id": {
+                "name": self.transition_id.name,
+                "status_code": self.transition_id.status_code,
+                "source": self.transition_id.source,
+            }
+            if self.transition_id is not None
+            else None,
+            "target": self.target,
+            "response": {
+                "status_code": self.response.status_code,
+                "elapsed": self.response.elapsed.total_seconds(),
+            }
+            if self.response is not None
+            else None,
+        }
+
 
 @dataclass
 class Interrupted(StatefulEvent):
@@ -225,3 +265,9 @@ class Errored(StatefulEvent):
     def __init__(self, *, exception: Exception) -> None:
         self.exception = exception
         self.timestamp = time.monotonic()
+
+    def asdict(self) -> dict[str, Any]:
+        return {
+            "timestamp": self.timestamp,
+            "exception": format_exception(self.exception, True),
+        }

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schemathesis
-Version: 3.32.0
+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

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

@@ -12,16 +12,16 @@ 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=0fYzn9sJ35k3Znx1P8FrbSdoUcdslcibtGh-IOTRwB8,10251
+schemathesis/filters.py,sha256=02mg5Gn32AkOprfk33wjH8oXmbsYpogN8XGlrHkEo8Q,14265
 schemathesis/graphql.py,sha256=YkoKWY5K8lxp7H3ikAs-IsoDbiPwJvChG7O8p3DgwtI,229
 schemathesis/hooks.py,sha256=dveqMmThIvt4fDahUXhU2nCq5pFvYjzzd1Ys_MhrJZA,12398
-schemathesis/lazy.py,sha256=eVdGkTZK0fWvUlFUCFGGlViH2NWEtYIjxiNkF4fBWhI,15218
+schemathesis/lazy.py,sha256=yEMQXbve2cB5mX-9Kv9npUECYfXVMc-dK33k82WJVcM,15405
 schemathesis/loaders.py,sha256=OtCD1o0TVmSNAUF7dgHpouoAXtY6w9vEtsRVGv4lE0g,4588
 schemathesis/models.py,sha256=nbm9Agqw94RYib2Q4OH7iOiEPDGw64NlQnEB7o5Spio,44925
 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=nUJIfR0mXYpKwEX3mZiS3hpUDdkD3vulROVeovL0dqU,18331
+schemathesis/schemas.py,sha256=wfcZflxe6ITt6s1-d37RwoRHJaYckWS76T-_PBCC7hI,17757
 schemathesis/serializers.py,sha256=kxXZ-UGa1v_vOm0sC4QYcrNv4rfvI7tHGT2elRVbCbc,11649
 schemathesis/targets.py,sha256=XIGRghvEzbmEJjse9aZgNEj67L3jAbiazm2rxURWgDE,2351
 schemathesis/throttling.py,sha256=aisUc4MJDGIOGUAs9L2DlWWpdd4KyAFuNVKhYoaUC9M,1719
@@ -69,9 +69,9 @@ 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=VVFy-qAgxoHBNrexBakq_QX_hx52pnWK-67HgSPpYRw,10694
+schemathesis/runner/events.py,sha256=ljwDjv-4hLS4MPfdfYDB2EAxkJR_67-fVvMu-pJU-yk,11498
 schemathesis/runner/probes.py,sha256=no5AfO3kse25qvHevjeUfB0Q3C860V2AYzschUW3QMQ,5688
-schemathesis/runner/serialization.py,sha256=sEUhNBGmTGMidaJEQt66tF5LEbwwxciT-ldDsZpSkL8,17522
+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/solo.py,sha256=N7-pUL6nWGiSRUC4Zqy1T4h99vbeQowP6b6cMnobOow,3042
@@ -87,7 +87,7 @@ schemathesis/service/hosts.py,sha256=ad2Lxq9Zcc9PP-1eFLQnxen4ImglcGOH8n7CGG72NNg
 schemathesis/service/metadata.py,sha256=x2LeCED1mdPf-YQJmjY8xtcIKHfD1ap5V0BGl-UgqNo,2087
 schemathesis/service/models.py,sha256=ihItUJ9CvH4TvmdfJY3W88NR82OODF8a3RD7WRXn6RM,6578
 schemathesis/service/report.py,sha256=4A8nf6_KOjDW3x1VXF8gSf_WY2xXp1Cbz-Owl_GeR7o,8294
-schemathesis/service/serialization.py,sha256=GFNc1-w1ShZopFdR7OFLT9ZKe8Y2S1hYnlXMrdMj3VE,10600
+schemathesis/service/serialization.py,sha256=QX7-wbh3vvUrZtRQWZkwaIUSIkcPtD-RMNFmHBY8J5s,6196
 schemathesis/service/usage.py,sha256=UbXqxeDq5mAjKkfV4hApZsReZmQHXiqoXUYn_Z6YuZk,2438
 schemathesis/specs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/specs/graphql/__init__.py,sha256=fgyHtvWNUVWismBTOqxQtgLoTighTfvMv6v6QCD_Oyc,85
@@ -105,14 +105,13 @@ schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnK
 schemathesis/specs/openapi/converter.py,sha256=TaYgc5BBHPdkN-n0lqpbeVgLu3eL3L8Wu3y_Vo3TJaQ,2800
 schemathesis/specs/openapi/definitions.py,sha256=Z186F0gNBSCmPg-Kk7Q-n6XxEZHIOzgUyeqixlC62XE,94058
 schemathesis/specs/openapi/examples.py,sha256=5bjmW3BnJVTiLlWZbimdfOzQQFR6m1P9G0FErr9g3WI,15128
-schemathesis/specs/openapi/filters.py,sha256=6Q9eNQ6zCR-NQkUxgnkSDWxfk3hsZuxemBv7v1rhwb4,1437
 schemathesis/specs/openapi/formats.py,sha256=JmmkQWNAj5XreXb7Edgj4LADAf4m86YulR_Ec8evpJ4,1220
 schemathesis/specs/openapi/links.py,sha256=2ucOLs50OhCqu0PEdbT_BGUM3fKnHBl97YGISLpAxLY,16023
-schemathesis/specs/openapi/loaders.py,sha256=JJdIz1aT03J9WmUWTLOz6Yhuu69IqmhobQ9_vL6XJ6U,24916
+schemathesis/specs/openapi/loaders.py,sha256=NOVG8Jrl9pv5O64wAgWHrco1okpRzQDamHDnidZdIwY,24905
 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
-schemathesis/specs/openapi/schemas.py,sha256=OF-a5dHthqw3z1X4RcYJqkOoKAsXFKc46RewePNYoBs,52279
+schemathesis/specs/openapi/schemas.py,sha256=EvdW-aJ-OY-zdSU3AbgK1TydsEJueWMfCZRIfAyMUbI,52420
 schemathesis/specs/openapi/security.py,sha256=nEhDB_SvEFldmfpa9uOQywfWN6DtXHKmgtwucJvfN5Q,7096
 schemathesis/specs/openapi/serialization.py,sha256=5qGdFHZ3n80UlbSXrO_bkr4Al_7ci_Z3aSUjZczNDQY,11384
 schemathesis/specs/openapi/utils.py,sha256=-TCu0hTrlwp2x5qHNp-TxiHRMeIZC9OBmlhLssjRIiQ,742
@@ -134,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=Tj0vaVnhYm2QEw9M_qrj2qbmR4-1xSjpco3L0IXAqvQ,5229
+schemathesis/stateful/events.py,sha256=3AANEwTZFuW9Gbcig70NvdT_h4o5r-Esx9Hpm7zphdg,6710
 schemathesis/stateful/runner.py,sha256=vFd8Id3zzSQVHBK9UgInBpBT7oyUNagQ0p7ZJnPyHRk,10969
 schemathesis/stateful/sink.py,sha256=xjsqJYH5WETKh5pDGlchYyjT3HcjzHEotUjvo1p0JsE,2470
 schemathesis/stateful/state_machine.py,sha256=iRbznWxHnUdLhMpiBaHxe6Nh1EacyGnGFz4DCRwV5j4,12228
@@ -145,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.0.dist-info/METADATA,sha256=vl38Pgh74x0u92WP7xmmgbQ7_2zy4n00secYTo7A5sU,17795
-schemathesis-3.32.0.dist-info/WHEEL,sha256=hKi7AIIx6qfnsRbr087vpeJnrVUuDokDHZacPPMW7-Y,87
-schemathesis-3.32.0.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.32.0.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.32.0.dist-info/RECORD,,
+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/specs/openapi/filters.py

@@ -1,50 +0,0 @@
-from __future__ import annotations
-
-import re
-
-from ...types import Filter
-
-
-def should_skip_method(method: str, pattern: Filter | None) -> bool:
-    if pattern is None:
-        return False
-    patterns = _ensure_tuple(pattern)
-    return method.upper() not in map(str.upper, patterns)
-
-
-def should_skip_endpoint(endpoint: str, pattern: Filter | None) -> bool:
-    if pattern is None:
-        return False
-    return not _match_any_pattern(endpoint, pattern)
-
-
-def should_skip_by_tag(tags: list[str] | None, pattern: Filter | None) -> bool:
-    if pattern is None:
-        return False
-    if not tags:
-        return True
-    patterns = _ensure_tuple(pattern)
-    return not any(re.search(item, tag) for item in patterns for tag in tags)
-
-
-def should_skip_by_operation_id(operation_id: str | None, pattern: Filter | None) -> bool:
-    if pattern is None:
-        return False
-    if not operation_id:
-        return True
-    return not _match_any_pattern(operation_id, pattern)
-
-
-def should_skip_deprecated(is_deprecated: bool, skip_deprecated_operations: bool) -> bool:
-    return skip_deprecated_operations and is_deprecated
-
-
-def _match_any_pattern(target: str, pattern: Filter) -> bool:
-    patterns = _ensure_tuple(pattern)
-    return any(re.search(item, target) for item in patterns)
-
-
-def _ensure_tuple(item: Filter) -> list | set | tuple:
-    if not isinstance(item, (list, set, tuple)):
-        return (item,)
-    return item