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

schemathesis/schemas.py

@@ -1,17 +1,11 @@
-"""Schema objects provide a convenient interface to raw schemas.
-
-Their responsibilities:
-  - Provide a unified way to work with different types of schemas
-  - Give all paths / methods combinations that are available directly from the schema;
-
-They give only static definitions of paths.
-"""
 from __future__ import annotations
-from collections.abc import Mapping, MutableMapping
+
+from collections.abc import Mapping
 from contextlib import nullcontext
 from dataclasses import dataclass, field
 from functools import lru_cache
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     ContextManager,
@@ -21,45 +15,58 @@ from typing import (
     NoReturn,
     Sequence,
     TypeVar,
-    TYPE_CHECKING,
 )
 from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
 
-import hypothesis
-from hypothesis.strategies import SearchStrategy
-from pyrate_limiter import Limiter
-
-from .constants import NOT_SET
+from ._dependency_versions import IS_PYRATE_LIMITER_ABOVE_3
 from ._hypothesis import create_test
 from .auths import AuthStorage
 from .code_samples import CodeSampleStyle
+from .constants import NOT_SET
+from .exceptions import OperationSchemaError, UsageError
+from .filters import (
+    FilterSet,
+    FilterValue,
+    MatcherFunc,
+    RegexValue,
+    filter_set_from_components,
+    is_deprecated,
+)
 from .generation import (
     DEFAULT_DATA_GENERATION_METHODS,
     DataGenerationMethod,
     DataGenerationMethodInput,
     GenerationConfig,
+    combine_strategies,
 )
-from .exceptions import OperationSchemaError, UsageError
-from .hooks import HookContext, HookDispatcher, HookScope, dispatch
-from .internal.result import Result, Ok
+from .hooks import HookContext, HookDispatcher, HookScope, dispatch, to_filterable_hook
+from .internal.deprecation import warn_filtration_arguments
+from .internal.output import OutputConfig
+from .internal.result import Ok, Result
 from .models import APIOperation, Case
-from .stateful.state_machine import APIStateMachine
-from .stateful import Stateful, StatefulTest
-from .types import (
-    Body,
-    Cookies,
-    Filter,
-    FormData,
-    GenericTest,
-    Headers,
-    NotSet,
-    PathParameters,
-    Query,
-)
-from .utils import PARAMETRIZE_MARKER, GivenInput, given_proxy, combine_strategies
+from .utils import PARAMETRIZE_MARKER, GivenInput, given_proxy
 
 if TYPE_CHECKING:
+    import hypothesis
+    from hypothesis.strategies import SearchStrategy
+    from pyrate_limiter import Limiter
+
+    from .stateful import Stateful, StatefulTest
+    from .stateful.state_machine import APIStateMachine
+    from .transports import Transport
     from .transports.responses import GenericResponse
+    from .types import (
+        Body,
+        Cookies,
+        Filter,
+        FormData,
+        GenericTest,
+        Headers,
+        NotSet,
+        PathParameters,
+        Query,
+        Specification,
+    )
 
 
 C = TypeVar("C", bound=Case)
@@ -73,41 +80,118 @@ def get_full_path(base_path: str, path: str) -> str:
 @dataclass(eq=False)
 class BaseSchema(Mapping):
     raw_schema: dict[str, Any]
+    transport: Transport
+    specification: Specification
     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)
     )
     generation_config: GenerationConfig = field(default_factory=GenerationConfig)
+    output_config: OutputConfig = field(default_factory=OutputConfig)
     code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
     rate_limiter: Limiter | None = None
     sanitize_output: bool = True
 
+    def __post_init__(self) -> None:
+        self.hook = to_filterable_hook(self.hooks)  # type: ignore[method-assign]
+
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
+    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]:
-        return iter(self.operations)
+        raise NotImplementedError
 
     def __getitem__(self, item: str) -> APIOperationMap:
         __tracebackhide__ = True
         try:
-            return self.operations[item]
+            return self._get_operation_map(item)
         except KeyError as exc:
             self.on_missing_operation(item, exc)
 
+    def _get_operation_map(self, key: str) -> APIOperationMap:
+        raise NotImplementedError
+
     def on_missing_operation(self, item: str, exc: KeyError) -> NoReturn:
         raise NotImplementedError
 
     def __len__(self) -> int:
-        return len(self.operations)
+        return self.operations_count
 
     def hook(self, hook: str | Callable) -> Callable:
         return self.hooks.register(hook)
@@ -150,18 +234,6 @@ class BaseSchema(Mapping):
     def validate(self) -> None:
         raise NotImplementedError
 
-    @property
-    def operations(self) -> dict[str, APIOperationMap]:
-        if not hasattr(self, "_operations"):
-            operations = self.get_all_operations()
-            self._operations = self._store_operations(operations)
-        return self._operations
-
-    def _store_operations(
-        self, operations: Generator[Result[APIOperation, OperationSchemaError], None, None]
-    ) -> dict[str, APIOperationMap]:
-        raise NotImplementedError
-
     @property
     def operations_count(self) -> int:
         raise NotImplementedError
@@ -171,11 +243,13 @@ class BaseSchema(Mapping):
         raise NotImplementedError
 
     def get_all_operations(
-        self, hooks: HookDispatcher | None = None
+        self, hooks: HookDispatcher | None = None, generation_config: GenerationConfig | None = None
     ) -> Generator[Result[APIOperation, OperationSchemaError], None, None]:
         raise NotImplementedError
 
-    def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
+    def get_strategies_from_examples(
+        self, operation: APIOperation, as_strategy_kwargs: dict[str, Any] | None = None
+    ) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
         raise NotImplementedError
 
@@ -204,7 +278,7 @@ class BaseSchema(Mapping):
         _given_kwargs: dict[str, GivenInput] | None = None,
     ) -> Generator[Result[tuple[APIOperation, Callable], OperationSchemaError], None, None]:
         """Generate all operations and Hypothesis tests for them."""
-        for result in self.get_all_operations(hooks=hooks):
+        for result in self.get_all_operations(hooks=hooks, generation_config=generation_config):
             if isinstance(result, Ok):
                 operation = result.ok()
                 _as_strategy_kwargs: dict[str, Any] | None
@@ -242,6 +316,21 @@ 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,
+            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 +345,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,37 +364,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:
@@ -318,6 +392,8 @@ class BaseSchema(Mapping):
             data_generation_methods = self.data_generation_methods
         if generation_config is NOT_SET:
             generation_config = self.generation_config
+        if output_config is NOT_SET:
+            output_config = self.output_config
         if code_sample_style is NOT_SET:
             code_sample_style = self.code_sample_style
         if rate_limiter is NOT_SET:
@@ -327,23 +403,22 @@ class BaseSchema(Mapping):
 
         return self.__class__(
             self.raw_schema,
+            specification=self.specification,
             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,
         )
 
     def get_local_hook_dispatcher(self) -> HookDispatcher | None:
@@ -400,10 +475,7 @@ class BaseSchema(Mapping):
         raise NotImplementedError
 
     def as_state_machine(self) -> type[APIStateMachine]:
-        """Create a state machine class.
-
-        Use it for stateful testing.
-        """
+        """Create a state machine class."""
         raise NotImplementedError
 
     def get_links(self, operation: APIOperation) -> dict[str, dict[str, Any]]:
@@ -422,7 +494,10 @@ class BaseSchema(Mapping):
         """Limit the rate of sending generated requests."""
         label = urlparse(self.base_url).netloc
         if self.rate_limiter is not None:
-            return self.rate_limiter.ratelimit(label, delay=True, max_delay=0)
+            if IS_PYRATE_LIMITER_ABOVE_3:
+                self.rate_limiter.try_acquire(label)
+            else:
+                return self.rate_limiter.ratelimit(label, delay=True, max_delay=0)
         return nullcontext()
 
     def _get_payload_schema(self, definition: dict[str, Any], media_type: str) -> dict[str, Any] | None:
@@ -437,39 +512,33 @@ class BaseSchema(Mapping):
         **kwargs: Any,
     ) -> SearchStrategy:
         """Build a strategy for generating test cases for all defined API operations."""
-        assert len(self.operations) > 0, "No API operations found"
         strategies = [
-            operation.as_strategy(
+            operation.ok().as_strategy(
                 hooks=hooks,
                 auth_storage=auth_storage,
                 data_generation_method=data_generation_method,
                 generation_config=generation_config,
                 **kwargs,
             )
-            for operations in self.operations.values()
-            for operation in operations.values()
+            for operation in self.get_all_operations(hooks=hooks)
+            if isinstance(operation, Ok)
         ]
         return combine_strategies(strategies)
 
 
 @dataclass
-class APIOperationMap(MutableMapping):
-    data: MutableMapping
-
-    def __setitem__(self, key: str, value: APIOperation) -> None:
-        self.data[key] = value
+class APIOperationMap(Mapping):
+    _schema: BaseSchema
+    _data: Mapping
 
     def __getitem__(self, item: str) -> APIOperation:
-        return self.data[item]
-
-    def __delitem__(self, key: str) -> None:
-        del self.data[key]
+        return self._data[item]
 
     def __len__(self) -> int:
-        return len(self.data)
+        return len(self._data)
 
     def __iter__(self) -> Iterator[str]:
-        return iter(self.data)
+        return iter(self._data)
 
     def as_strategy(
         self,
@@ -480,7 +549,6 @@ class APIOperationMap(MutableMapping):
         **kwargs: Any,
     ) -> SearchStrategy:
         """Build a strategy for generating test cases for all API operations defined in this subset."""
-        assert len(self.data) > 0, "No API operations found"
         strategies = [
             operation.as_strategy(
                 hooks=hooks,
@@ -489,6 +557,6 @@ class APIOperationMap(MutableMapping):
                 generation_config=generation_config,
                 **kwargs,
             )
-            for operation in self.data.values()
+            for operation in self._data.values()
         ]
         return combine_strategies(strategies)

schemathesis/serializers.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import binascii
 import os
 from dataclasses import dataclass
@@ -10,13 +11,14 @@ from typing import (
     Collection,
     Dict,
     Generator,
-    cast,
     Protocol,
+    cast,
     runtime_checkable,
 )
 
-from .internal.copy import fast_deepcopy
 from ._xml import _to_xml
+from .internal.copy import fast_deepcopy
+from .internal.jsonschema import traverse_schema
 from .transports.content_types import (
     is_json_media_type,
     is_plain_text_media_type,
@@ -41,6 +43,11 @@ class Binary(str):
 
     data: bytes
 
+    __slots__ = ("data",)
+
+    def __hash__(self) -> int:
+        return hash(self.data)
+
 
 @dataclass
 class SerializerContext:
@@ -150,6 +157,10 @@ class JSONSerializer:
         return _to_json(value)
 
 
+def _replace_binary(value: dict) -> dict:
+    return {key: value.data if isinstance(value, Binary) else value for key, value in value.items()}
+
+
 def _to_yaml(value: Any) -> dict[str, Any]:
     import yaml
 
@@ -162,10 +173,12 @@ def _to_yaml(value: Any) -> dict[str, Any]:
         return {"data": value}
     if isinstance(value, Binary):
         return {"data": value.data}
+    if isinstance(value, (list, dict)):
+        value = traverse_schema(value, _replace_binary)
     return {"data": yaml.dump(value, Dumper=SafeDumper)}
 
 
-@register("text/yaml", aliases=("text/x-yaml", "application/x-yaml", "text/vnd.yaml"))
+@register("text/yaml", aliases=("text/x-yaml", "text/vnd.yaml", "text/yml", "application/yaml", "application/x-yaml"))
 class YAMLSerializer:
     def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         return _to_yaml(value)
@@ -233,7 +246,7 @@ def _encode_multipart(value: Any, boundary: str) -> bytes:
     return body.getvalue()
 
 
-@register("multipart/form-data")
+@register("multipart/form-data", aliases=("multipart/mixed",))
 class MultipartSerializer:
     def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         if isinstance(value, bytes):

schemathesis/service/ci.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import enum
 import os
 from dataclasses import asdict, dataclass

schemathesis/service/client.py

@@ -1,27 +1,35 @@
 from __future__ import annotations
+
 import hashlib
 import http
+import json
 from dataclasses import asdict
-from typing import Any
+from typing import TYPE_CHECKING, Any
 from urllib.parse import urljoin
 
 import requests
 from requests.adapters import HTTPAdapter, Retry
 
 from ..constants import USER_AGENT
-from .ci import CIProvider
 from .constants import CI_PROVIDER_HEADER, REPORT_CORRELATION_ID_HEADER, REQUEST_TIMEOUT, UPLOAD_SOURCE_HEADER
-from .metadata import Metadata
+from .metadata import Metadata, collect_dependency_versions
 from .models import (
-    ProjectDetails,
+    AnalysisError,
+    AnalysisResult,
+    AnalysisSuccess,
     AuthResponse,
     FailedUploadResponse,
-    UploadResponse,
-    UploadSource,
+    ProjectDetails,
     ProjectEnvironment,
     Specification,
+    UploadResponse,
+    UploadSource,
 )
 
+if TYPE_CHECKING:
+    from ..runner import probes
+    from .ci import CIProvider
+
 
 def response_hook(response: requests.Response, **_kwargs: Any) -> None:
     if response.status_code != http.HTTPStatus.REQUEST_ENTITY_TOO_LARGE:
@@ -98,3 +106,28 @@ class ServiceClient(requests.Session):
         if response.status_code == http.HTTPStatus.REQUEST_ENTITY_TOO_LARGE:
             return FailedUploadResponse(detail=data["detail"])
         return UploadResponse(message=data["message"], next_url=data["next"], correlation_id=data["correlation_id"])
+
+    def analyze_schema(self, probes: list[probes.ProbeRun] | None, schema: dict[str, Any]) -> AnalysisResult:
+        """Analyze the API schema."""
+        # Manual serialization reduces the size of the payload a bit
+        dependencies = collect_dependency_versions()
+        if probes is not None:
+            _probes = [probe.serialize() for probe in probes]
+        else:
+            _probes = []
+        content = json.dumps(
+            {
+                "probes": _probes,
+                "schema": schema,
+                "dependencies": list(map(asdict, dependencies)),
+            },
+            separators=(",", ":"),
+        )
+        response = self.post("/cli/analysis/", data=content, headers={"Content-Type": "application/json"}, timeout=None)
+        if response.status_code == http.HTTPStatus.REQUEST_ENTITY_TOO_LARGE:
+            try:
+                message = response.json()["detail"]
+            except json.JSONDecodeError:
+                message = response.text
+            return AnalysisError(message=message)
+        return AnalysisSuccess.from_dict(response.json())

schemathesis/service/events.py

@@ -1,9 +1,13 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
-from . import ci
 from ..exceptions import format_exception
 
+if TYPE_CHECKING:
+    from . import ci
+
 
 class Event:
     """Signalling events coming from the Schemathesis.io worker.