schemathesis 3.26.2__py3-none-any.whl → 3.27.1__py3-none-any.whl

schemathesis/specs/openapi/_hypothesis.py

@@ -45,7 +45,8 @@ StrategyFactory = Callable[[Dict[str, Any], str, str, Optional[str], GenerationC
 def header_values(blacklist_characters: str = "\n\r") -> st.SearchStrategy[str]:
     return st.text(
         alphabet=st.characters(min_codepoint=0, max_codepoint=255, blacklist_characters=blacklist_characters)
-    )
+        # Header values with leading non-visible chars can't be sent with `requests`
+    ).map(str.lstrip)
 
 
 @lru_cache
@@ -67,8 +68,7 @@ def get_default_format_strategies() -> dict[str, st.SearchStrategy]:
         "_header_name": st.text(
             min_size=1, alphabet=st.sampled_from("!#$%&'*+-.^_`|~" + string.digits + string.ascii_letters)
         ),
-        # Header values with leading non-visible chars can't be sent with `requests`
-        HEADER_FORMAT: header_value.map(str.lstrip),
+        HEADER_FORMAT: header_value,
         "_basic_auth": st.tuples(latin1_text, latin1_text).map(make_basic_auth_str),
         "_bearer_auth": header_value.map("Bearer {}".format),
     }
@@ -425,6 +425,15 @@ def jsonify_python_specific_types(value: dict[str, Any]) -> dict[str, Any]:
     return value
 
 
+def _build_custom_formats(
+    custom_formats: dict[str, st.SearchStrategy] | None, generation_config: GenerationConfig
+) -> dict[str, st.SearchStrategy]:
+    custom_formats = {**get_default_format_strategies(), **STRING_FORMATS, **(custom_formats or {})}
+    if generation_config.headers.strategy is not None:
+        custom_formats[HEADER_FORMAT] = generation_config.headers.strategy
+    return custom_formats
+
+
 def make_positive_strategy(
     schema: dict[str, Any],
     operation_name: str,
@@ -441,9 +450,10 @@ def make_positive_strategy(
         for sub_schema in schema.get("properties", {}).values():
             if list(sub_schema) == ["type"] and sub_schema["type"] == "string":
                 sub_schema.setdefault("format", HEADER_FORMAT)
+    custom_formats = _build_custom_formats(custom_formats, generation_config)
     return from_schema(
         schema,
-        custom_formats={**get_default_format_strategies(), **STRING_FORMATS, **(custom_formats or {})},
+        custom_formats=custom_formats,
         allow_x00=generation_config.allow_x00,
         codec=generation_config.codec,
     )
@@ -462,12 +472,13 @@ def make_negative_strategy(
     generation_config: GenerationConfig,
     custom_formats: dict[str, st.SearchStrategy] | None = None,
 ) -> st.SearchStrategy:
+    custom_formats = _build_custom_formats(custom_formats, generation_config)
     return negative_schema(
         schema,
         operation_name=operation_name,
         location=location,
         media_type=media_type,
-        custom_formats={**get_default_format_strategies(), **STRING_FORMATS, **(custom_formats or {})},
+        custom_formats=custom_formats,
         generation_config=generation_config,
     )
 

schemathesis/specs/openapi/loaders.py

@@ -304,6 +304,7 @@ def from_dict(
     :param dict raw_schema: A schema to load.
     """
     from .schemas import OpenApi30, SwaggerV20
+    from ... import transports
 
     if not isinstance(raw_schema, dict):
         raise SchemaError(SchemaErrorType.OPEN_API_INVALID_SCHEMA, SCHEMA_INVALID_ERROR)
@@ -338,6 +339,7 @@ def from_dict(
             location=location,
             rate_limiter=rate_limiter,
             sanitize_output=sanitize_output,
+            transport=transports.get(app),
         )
         dispatch("after_load_schema", hook_context, instance)
         return instance
@@ -379,6 +381,7 @@ def from_dict(
             location=location,
             rate_limiter=rate_limiter,
             sanitize_output=sanitize_output,
+            transport=transports.get(app),
         )
         dispatch("after_load_schema", hook_context, instance)
         return instance

schemathesis/stateful/state_machine.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import time
 import re
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Callable, ClassVar
+from typing import TYPE_CHECKING, Any, ClassVar
 
 from hypothesis.errors import InvalidDefinition
 from hypothesis.stateful import RuleBasedStateMachine
@@ -189,13 +189,12 @@ class APIStateMachine(RuleBasedStateMachine):
         :return: Response from the application under test.
 
         Note that WSGI/ASGI applications are detected automatically in this method. Depending on the result of this
-        detection the state machine will call ``call``, ``call_wsgi`` or ``call_asgi`` methods.
+        detection the state machine will call the ``call`` method.
 
         Usually, you don't need to override this method unless you are building a different state machine on top of this
         one and want to customize the transport layer itself.
         """
-        method = self._get_call_method(case)
-        return method(**kwargs)
+        return case.call(**kwargs)
 
     def get_call_kwargs(self, case: Case) -> dict[str, Any]:
         """Create custom keyword arguments that will be passed to the :meth:`Case.call` method.
@@ -214,15 +213,6 @@ class APIStateMachine(RuleBasedStateMachine):
         """
         return {}
 
-    def _get_call_method(self, case: Case) -> Callable:
-        if case.app is not None:
-            from starlette.applications import Starlette
-
-            if isinstance(case.app, Starlette):
-                return case.call_asgi
-            return case.call_wsgi
-        return case.call
-
     def validate_response(
         self, response: GenericResponse, case: Case, additional_checks: tuple[CheckFunction, ...] = ()
     ) -> None:

schemathesis/transports/__init__.py

@@ -1,5 +1,312 @@
+from __future__ import annotations
+
 import base64
+import time
+from inspect import iscoroutinefunction
+from contextlib import contextmanager
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import TYPE_CHECKING, Any, Generator, Protocol, TypeVar, cast
+from urllib.parse import urlparse
+
+from .. import failures
+from .._dependency_versions import IS_WERKZEUG_ABOVE_3
+from ..constants import DEFAULT_RESPONSE_TIMEOUT
+from ..exceptions import get_timeout_error
+from ..serializers import SerializerContext
+from ..types import Cookies, NotSet
+
+if TYPE_CHECKING:
+    import requests
+    import werkzeug
+    from _typeshed.wsgi import WSGIApplication
+    from starlette_testclient._testclient import ASGI2App, ASGI3App
+
+    from ..models import Case
+    from .responses import WSGIResponse
 
 
 def serialize_payload(payload: bytes) -> str:
     return base64.b64encode(payload).decode()
+
+
+def get(app: Any) -> Transport:
+    """Get transport to send the data to the application."""
+    if app is None:
+        return RequestsTransport()
+    if iscoroutinefunction(app) or (
+        hasattr(app, "__call__") and iscoroutinefunction(app.__call__)  # noqa: B004
+    ):
+        return ASGITransport(app=app)
+    return WSGITransport(app=app)
+
+
+S = TypeVar("S", contravariant=True)
+R = TypeVar("R", covariant=True)
+
+
+class Transport(Protocol[S, R]):
+    def serialize_case(
+        self,
+        case: Case,
+        *,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        raise NotImplementedError
+
+    def send(
+        self,
+        case: Case,
+        *,
+        session: S | None = None,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> R:
+        raise NotImplementedError
+
+
+class RequestsTransport:
+    def serialize_case(
+        self,
+        case: Case,
+        *,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        final_headers = case._get_headers(headers)
+        if case.media_type and case.media_type != "multipart/form-data" and not isinstance(case.body, NotSet):
+            # `requests` will handle multipart form headers with the proper `boundary` value.
+            if "content-type" not in final_headers:
+                final_headers["Content-Type"] = case.media_type
+        url = case._get_url(base_url)
+        serializer = case._get_serializer()
+        if serializer is not None and not isinstance(case.body, NotSet):
+            context = SerializerContext(case=case)
+            extra = serializer.as_requests(context, case._get_body())
+        else:
+            extra = {}
+        if case._auth is not None:
+            extra["auth"] = case._auth
+        additional_headers = extra.pop("headers", None)
+        if additional_headers:
+            # Additional headers, needed for the serializer
+            for key, value in additional_headers.items():
+                final_headers.setdefault(key, value)
+        data = {
+            "method": case.method,
+            "url": url,
+            "cookies": case.cookies,
+            "headers": final_headers,
+            "params": case.query,
+            **extra,
+        }
+        if params is not None:
+            _merge_dict_to(data, "params", params)
+        if cookies is not None:
+            _merge_dict_to(data, "cookies", cookies)
+        return data
+
+    def send(
+        self,
+        case: Case,
+        *,
+        session: requests.Session | None = None,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> requests.Response:
+        import requests
+        from urllib3.exceptions import ReadTimeoutError
+
+        data = self.serialize_case(case, base_url=base_url, headers=headers, params=params, cookies=cookies)
+        data.update(kwargs)
+        data.setdefault("timeout", DEFAULT_RESPONSE_TIMEOUT / 1000)
+        if session is None:
+            validate_vanilla_requests_kwargs(data)
+            session = requests.Session()
+            close_session = True
+        else:
+            close_session = False
+        verify = data.get("verify", True)
+        try:
+            with case.operation.schema.ratelimit():
+                response = session.request(**data)  # type: ignore
+        except (requests.Timeout, requests.ConnectionError) as exc:
+            if isinstance(exc, requests.ConnectionError):
+                if not isinstance(exc.args[0], ReadTimeoutError):
+                    raise
+                req = requests.Request(
+                    method=data["method"].upper(),
+                    url=data["url"],
+                    headers=data["headers"],
+                    files=data.get("files"),
+                    data=data.get("data") or {},
+                    json=data.get("json"),
+                    params=data.get("params") or {},
+                    auth=data.get("auth"),
+                    cookies=data["cookies"],
+                    hooks=data.get("hooks"),
+                )
+                request = session.prepare_request(req)
+            else:
+                request = cast(requests.PreparedRequest, exc.request)
+            timeout = 1000 * data["timeout"]  # It is defined and not empty, since the exception happened
+            code_message = case._get_code_message(case.operation.schema.code_sample_style, request, verify=verify)
+            message = f"The server failed to respond within the specified limit of {timeout:.2f}ms"
+            raise get_timeout_error(timeout)(
+                f"\n\n1. {failures.RequestTimeout.title}\n\n{message}\n\n{code_message}",
+                context=failures.RequestTimeout(message=message, timeout=timeout),
+            ) from None
+        response.verify = verify  # type: ignore[attr-defined]
+        if close_session:
+            session.close()
+        return response
+
+
+def _merge_dict_to(data: dict[str, Any], data_key: str, new: dict[str, Any]) -> None:
+    original = data[data_key] or {}
+    for key, value in new.items():
+        original[key] = value
+    data[data_key] = original
+
+
+def validate_vanilla_requests_kwargs(data: dict[str, Any]) -> None:
+    """Check arguments for `requests.Session.request`.
+
+    Some arguments can be valid for cases like ASGI integration, but at the same time they won't work for the regular
+    `requests` calls. In such cases we need to avoid an obscure error message, that comes from `requests`.
+    """
+    url = data["url"]
+    if not urlparse(url).netloc:
+        raise RuntimeError(
+            "The URL should be absolute, so Schemathesis knows where to send the data. \n"
+            f"If you use the ASGI integration, please supply your test client "
+            f"as the `session` argument to `call`.\nURL: {url}"
+        )
+
+
+@dataclass
+class ASGITransport(RequestsTransport):
+    app: ASGI2App | ASGI3App
+
+    def send(
+        self,
+        case: Case,
+        *,
+        session: requests.Session | None = None,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> requests.Response:
+        from starlette_testclient import TestClient as ASGIClient
+
+        if base_url is None:
+            base_url = case.get_full_base_url()
+        with ASGIClient(self.app) as client:
+            return super().send(
+                case, session=client, base_url=base_url, headers=headers, params=params, cookies=cookies, **kwargs
+            )
+
+
+@dataclass
+class WSGITransport:
+    app: WSGIApplication
+
+    def serialize_case(
+        self,
+        case: Case,
+        *,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        final_headers = case._get_headers(headers)
+        if case.media_type and not isinstance(case.body, NotSet):
+            # If we need to send a payload, then the Content-Type header should be set
+            final_headers["Content-Type"] = case.media_type
+        extra: dict[str, Any]
+        serializer = case._get_serializer()
+        if serializer is not None and not isinstance(case.body, NotSet):
+            context = SerializerContext(case=case)
+            extra = serializer.as_werkzeug(context, case._get_body())
+        else:
+            extra = {}
+        data = {
+            "method": case.method,
+            "path": case.operation.schema.get_full_path(case.formatted_path),
+            # Convert to a regular dictionary, as we use `CaseInsensitiveDict` which is not supported by Werkzeug
+            "headers": dict(final_headers),
+            "query_string": case.query,
+            **extra,
+        }
+        if params is not None:
+            _merge_dict_to(data, "query_string", params)
+        return data
+
+    def send(
+        self,
+        case: Case,
+        *,
+        session: Any = None,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> WSGIResponse:
+        import requests
+        import werkzeug
+
+        from .responses import WSGIResponse
+
+        application = kwargs.pop("app", self.app) or self.app
+        data = self.serialize_case(case, headers=headers, params=params)
+        data.update(kwargs)
+        client = werkzeug.Client(application, WSGIResponse)
+        cookies = {**(case.cookies or {}), **(cookies or {})}
+        with cookie_handler(client, cookies), case.operation.schema.ratelimit():
+            start = time.monotonic()
+            response = client.open(**data)
+            elapsed = time.monotonic() - start
+        requests_kwargs = RequestsTransport().serialize_case(
+            case,
+            base_url=case.get_full_base_url(),
+            headers=headers,
+            params=params,
+            cookies=cookies,
+        )
+        response.request = requests.Request(**requests_kwargs).prepare()
+        response.elapsed = timedelta(seconds=elapsed)
+        return response
+
+
+@contextmanager
+def cookie_handler(client: werkzeug.Client, cookies: Cookies | None) -> Generator[None, None, None]:
+    """Set cookies required for a call."""
+    if not cookies:
+        yield
+    else:
+        for key, value in cookies.items():
+            if IS_WERKZEUG_ABOVE_3:
+                client.set_cookie(key=key, value=value, domain="localhost")
+            else:
+                client.set_cookie("localhost", key=key, value=value)
+        yield
+        for key in cookies:
+            if IS_WERKZEUG_ABOVE_3:
+                client.delete_cookie(key=key, domain="localhost")
+            else:
+                client.delete_cookie("localhost", key=key)

schemathesis/transports/responses.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import sys
 import json
+from datetime import timedelta
 from typing import Union, TYPE_CHECKING, NoReturn, Any
 from .._compat import JSONMixin
 from werkzeug.wrappers import Response as BaseResponse
@@ -15,6 +16,7 @@ if TYPE_CHECKING:
 class WSGIResponse(BaseResponse, JSONMixin):
     # We store "requests" request to build a reproduction code
     request: PreparedRequest
+    elapsed: timedelta
 
     def on_json_loading_failed(self, e: json.JSONDecodeError) -> NoReturn:
         # We don't need a werkzeug-specific exception when JSON parsing error happens

{schemathesis-3.26.2.dist-info → schemathesis-3.27.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schemathesis
-Version: 3.26.2
+Version: 3.27.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
@@ -28,7 +28,6 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.8
-Requires-Dist: anyio<4
 Requires-Dist: backoff<3.0,>=2.1.2
 Requires-Dist: click<9.0,>=7.0
 Requires-Dist: colorama<1.0,>=0.4
@@ -44,7 +43,7 @@ Requires-Dist: pytest-subtests<0.8.0,>=0.2.1
 Requires-Dist: pytest<9,>=4.6.4
 Requires-Dist: pyyaml<7.0,>=5.1
 Requires-Dist: requests<3,>=2.22
-Requires-Dist: starlette-testclient<1
+Requires-Dist: starlette-testclient<1,>=0.4.1
 Requires-Dist: starlette<1,>=0.13
 Requires-Dist: tomli-w<2.0,>=1.0.0
 Requires-Dist: tomli<3.0,>=2.0.1

{schemathesis-3.26.2.dist-info → schemathesis-3.27.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-schemathesis/__init__.py,sha256=WW1NBZxmc5jRR0c24xz-ZtTkJMUQG5MOw1MGVRRGc1s,1970
+schemathesis/__init__.py,sha256=zAa981OnVdIdjiETPP5a5vZL8QXAh2HbTWj8iEoxKC4,1984
 schemathesis/_compat.py,sha256=VizWR0QAVj4l7WZautNe_zmo3AJ7WBl2zrJQOfJAQtk,1837
 schemathesis/_dependency_versions.py,sha256=InIv6MZmuRVHc_9FxAiRg7_dY-vuF0jT69FBxrBLK6U,879
 schemathesis/_hypothesis.py,sha256=O3rfMbT0rChFONMUsYmMEGV9nPG5cHd_6v9NhWDI_IQ,10763
@@ -17,28 +17,30 @@ schemathesis/graphql.py,sha256=YkoKWY5K8lxp7H3ikAs-IsoDbiPwJvChG7O8p3DgwtI,229
 schemathesis/hooks.py,sha256=cNJgCh7SyLWT1sYDKF5ncDC80ld08CinvKo2IqLMV4g,12396
 schemathesis/lazy.py,sha256=CivWpvesh4iYLSkatXbQPTEOruWmXvuZQ29gng5p9wM,14846
 schemathesis/loaders.py,sha256=RJnrbf-3vZ7KXmRBkmr3uqWyg0eHzOnONABuudWcTIg,4586
-schemathesis/models.py,sha256=Rcgm2VX7oQN3HN-ThZlqWmBuNsV1Hrd2_xbvh0K6KQY,46883
+schemathesis/models.py,sha256=KtWx7k9M8wrkaCZ82kfLMKd7jmvFxZnGyUuTE_nPhU0,42974
 schemathesis/parameters.py,sha256=VheEffVzoSfYaSEcG7KhPlA4ypifosG8biiHifzwL8g,2257
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/sanitization.py,sha256=WSV_MB5YRrYkp1pQRPHrzsidqsKcqYZiq64N9grKobo,8956
-schemathesis/schemas.py,sha256=H13rs5X-FkNcGIB9W__oolu-AM-vIyYEiArXpg-rKU0,18429
+schemathesis/schemas.py,sha256=RzxAoBoJJSLsixrkTZPe2N_oWbWv8n5RL4XaYRyoSIo,18531
 schemathesis/serializers.py,sha256=_xoebWkVrgbGbPjPgTgwuN-fN4YT004aj7kImyPComY,11619
 schemathesis/targets.py,sha256=tzp7VZ2-7g2nZHCooRgFzTMtOVcbl0rvtNR421hQthA,1162
 schemathesis/throttling.py,sha256=uwhL4XWPWAU8HECg0NhibfCMn5dT7NElTx3fdL3Mmcc,1065
 schemathesis/types.py,sha256=AglR5M0bce-YXeDRkweToXTP0GjNOWVjS_mIsxLobwc,919
 schemathesis/utils.py,sha256=4HXvHysnHp-Uz2HfNgLfW5F5VjL-mtixrjjzRCEJhYo,5233
-schemathesis/cli/__init__.py,sha256=MSdz9Xt2qvey-3HbWj5nfwV2nZ-rdV05u_Eh_Be9m0c,64909
+schemathesis/cli/__init__.py,sha256=oTBqweV5CP681LqRFdRXtkd0VyYoG_xUKshkKEPnqIQ,64871
+schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
 schemathesis/cli/callbacks.py,sha256=HmD0WmSYf5x8v4xeZdOKzy_8CEk23NitUlL8JQ7LHdQ,14950
 schemathesis/cli/cassettes.py,sha256=1ucgYyOZiNu44uOv044FdfKTzQolUyhAM2onk4m3MD0,12988
 schemathesis/cli/constants.py,sha256=XoezT0_fHuiOY2e--cmBUhNieJsepcUoW8e48QuLSDI,1544
 schemathesis/cli/context.py,sha256=wwfdSL_NKHEyzQnj8PcnaJdzasa_N08e2KPvy4Wl8N4,1874
 schemathesis/cli/debug.py,sha256=PDEa-oHyz5bZ8aYjRYARwQaCv_AC6HM_L43LJfe4vUM,657
 schemathesis/cli/handlers.py,sha256=62GPWPmgeGUz3pkDd01H4UCXcIy5a9yRtU7qaAeeR-A,389
-schemathesis/cli/junitxml.py,sha256=jMZzYBYpBE7Rl5n1ct3J0bhhPa1lhBeYb33lTZE1eW8,1792
+schemathesis/cli/junitxml.py,sha256=JMMtWz7grPQw66Ruh-tLR8YVn-58Q0o0l_MxZWQ4V3M,4586
 schemathesis/cli/options.py,sha256=7_dXcrPT0kWqAkm60cAT1J0IsTOcvNFxT1pcHYttBuI,2558
+schemathesis/cli/reporting.py,sha256=uTtoEJT4maJRGPsVZH184S0hohX-4SwO_dAL__i6H10,3401
 schemathesis/cli/sanitization.py,sha256=v-9rsMCBpWhom0Bfzj_8c6InqxkVjSWK6kRoURa52Nk,727
 schemathesis/cli/output/__init__.py,sha256=AXaUzQ1nhQ-vXhW4-X-91vE2VQtEcCOrGtQXXNN55iQ,29
-schemathesis/cli/output/default.py,sha256=XxnfZXXERuB1X3M8dlVBZnYUuZ0JXsQMCX4EEv5-oYg,38213
+schemathesis/cli/output/default.py,sha256=GjT-j9pNxVYQmU6nOu08hBqvR9uD_TMI15jZitWgI0A,36781
 schemathesis/cli/output/short.py,sha256=MmFMOKBRqqvgq7Kmx6XJc7Vqkr9g5BrJBxRbyZ0Rh-k,2068
 schemathesis/contrib/__init__.py,sha256=FH8NL8NXgSKBFOF8Jy_EB6T4CJEaiM-tmDhz16B2o4k,187
 schemathesis/contrib/unique_data.py,sha256=zxrmAlQH7Bcil9YSfy2EazwLj2rxLzOvAE3O6QRRkFY,1317
@@ -55,7 +57,7 @@ schemathesis/extra/pytest_plugin.py,sha256=44RRkjkN1JupWu0muq9B5b3K9goucYndB394Q
 schemathesis/fixups/__init__.py,sha256=iTpOm-cwyZQRglbWRJHxj3k7WO9a4a-MCq-UDQa6U0Y,966
 schemathesis/fixups/fast_api.py,sha256=-gjYNSUtiKl7cKgyQ_rON0Oo_sGm6r7rOQDH0ahG32A,1322
 schemathesis/fixups/utf8_bom.py,sha256=ttzPOaJb6K7QtNAbIZ_TWrrm0N9FylS8QzO6zI0jXgY,764
-schemathesis/generation/__init__.py,sha256=NOmYWmbTt0uW5Vlx2-xfoXV_lLQs08d9T12v9pFBhrA,1951
+schemathesis/generation/__init__.py,sha256=UXRrDTaUEX29VEK9bLqVi_xVzyNNqul3WhpLh1za90M,2277
 schemathesis/internal/__init__.py,sha256=93HcdG3LF0BbQKbCteOsFMa1w6nXl8yTmx87QLNJOik,161
 schemathesis/internal/copy.py,sha256=xsC7RyrFa9KadMsj9ai_aAy0XZg0oplz3cFZCka_2fg,459
 schemathesis/internal/datetime.py,sha256=zPLBL0XXLNfP-KYel3H2m8pnsxjsA_4d-zTOhJg2EPQ,136
@@ -67,9 +69,9 @@ schemathesis/internal/validation.py,sha256=G7i8jIMUpAeOnDsDF_eWYvRZe_yMprRswx0QA
 schemathesis/runner/__init__.py,sha256=kkqjC_5G2Mrq00syLNUDHP3sXqwiId8_cusKtIlOyXM,21419
 schemathesis/runner/events.py,sha256=eZc4TT8C8mWCMr9h4JvlijvQQ-x8wFry8LntdsYIL-A,10200
 schemathesis/runner/probes.py,sha256=t_B38-ljy-p3Odw-dqcZUVIjYTPwBvac8KE5GaLnz4M,5546
-schemathesis/runner/serialization.py,sha256=JgkZrbELi2rL7iCsQ0yySOADwxSNF96gd_DOHVANPVU,16080
+schemathesis/runner/serialization.py,sha256=7DBve7E6JAbAHH5npzjME7lFnysKCc9dPXMmdIIYrNI,16667
 schemathesis/runner/impl/__init__.py,sha256=1E2iME8uthYPBh9MjwVBCTFV-P3fi7AdphCCoBBspjs,199
-schemathesis/runner/impl/core.py,sha256=vaw6OBgYOVT44-gR2t_EiWLArX2RmtAxITR3WZWCX8k,39558
+schemathesis/runner/impl/core.py,sha256=Y8WyKEUeuEs0xi9hWmEA63a39-NO7L6I5hQRhwo9JBQ,39621
 schemathesis/runner/impl/solo.py,sha256=Y_tNhVBVxcuxv65hN0FjxLlVSC41ebHMOM1xSzVrNk8,3358
 schemathesis/runner/impl/threadpool.py,sha256=2-2Wvw7msezZtenZY5vU_x3FGLLVlH-ywvhU9hTwAAo,15073
 schemathesis/service/__init__.py,sha256=cDVTCFD1G-vvhxZkJUwiToTAEQ-0ByIoqwXvJBCf_V8,472
@@ -87,13 +89,13 @@ schemathesis/service/serialization.py,sha256=OjWG7FfihEl4LtpOD8N-fmjOTzSPUm6A4x6
 schemathesis/service/usage.py,sha256=Z-GCwFcW1pS6YdC-ziEOynikqgOttxp2Uyj_dfK5Q7A,2437
 schemathesis/specs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/specs/graphql/__init__.py,sha256=fgyHtvWNUVWismBTOqxQtgLoTighTfvMv6v6QCD_Oyc,85
-schemathesis/specs/graphql/loaders.py,sha256=16fGT4rSqVF91DPY90cKDaFsbtRb9_ZdLnlGY1Gb_vg,11391
+schemathesis/specs/graphql/loaders.py,sha256=5BcHD-w0XU_CRfS53SN4iuGDOfvUfjOfyiRMRGmNDVc,11461
 schemathesis/specs/graphql/nodes.py,sha256=7F5jbk96uTZZXK9Ulr86KpCAn8z6LKMBcrLrdJHggH0,540
 schemathesis/specs/graphql/scalars.py,sha256=W5oj6AcjiXpR-Z6eSSp1oPWl0mjH2NF-w87nRFhrHHg,1805
-schemathesis/specs/graphql/schemas.py,sha256=XK-zbR_d8zER2HLU3zH-BrKnfoV9hb0VXvDueryp8Y0,14091
+schemathesis/specs/graphql/schemas.py,sha256=6BlTF9iAongsDxzy4_l85YjDob2QzpB0Vt7mlbIUxaw,12637
 schemathesis/specs/graphql/validation.py,sha256=SqQbj9uymGUQxlHXc8HkQccIq25uwP5CvLF1zReb1Xg,1636
 schemathesis/specs/openapi/__init__.py,sha256=HDcx3bqpa6qWPpyMrxAbM3uTo0Lqpg-BUNZhDJSJKnw,279
-schemathesis/specs/openapi/_hypothesis.py,sha256=o1ssS7JJZ45l750ogoZ3gXoedzLmRsXqpPb1LCZXikY,22835
+schemathesis/specs/openapi/_hypothesis.py,sha256=Qrm6Po2W2wsxZAlLFRUwq0svO8SmQp-5InCFa2cwYaw,23275
 schemathesis/specs/openapi/checks.py,sha256=1WB_UGNqptfJThWLUNbds1Q-IzOGbbHCOYPIhBYk-zs,5411
 schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnKDwCwPLhID4,783
 schemathesis/specs/openapi/converter.py,sha256=9TKeKvNi9MVvoNMfqoPz_cODO8oNrMSTXTOwLLfjD_Q,2799
@@ -102,7 +104,7 @@ schemathesis/specs/openapi/examples.py,sha256=igLDfMpNhRMAk7mYBqi93CtVRQTZCWjCJ2
 schemathesis/specs/openapi/filters.py,sha256=Ei-QTFcGCvGSIunT-GYQrtqzB-kqvUePOcUuC7B7mT8,1436
 schemathesis/specs/openapi/formats.py,sha256=JmmkQWNAj5XreXb7Edgj4LADAf4m86YulR_Ec8evpJ4,1220
 schemathesis/specs/openapi/links.py,sha256=FUjqEf6Sv6PeS0UX7CLL5p2VHa9vA1MGDPhx2pfYg1s,14576
-schemathesis/specs/openapi/loaders.py,sha256=Jm37MTUmbVVkOxoRAJOo_T_Ex-tWu2ir7YG7y-v-BjM,24014
+schemathesis/specs/openapi/loaders.py,sha256=QoEFJ7fxJz5XcGTEWV_ZGXARiektmyyT_xmVtcHco6Q,24131
 schemathesis/specs/openapi/media_types.py,sha256=dNTxpRQbY3SubdVjh4Cjb38R6Bc9MF9BsRQwPD87x0g,1017
 schemathesis/specs/openapi/parameters.py,sha256=5jMZQZFsZNBFjG22Bqot-Rc65emiSA4E95rIzwImThk,13610
 schemathesis/specs/openapi/references.py,sha256=YGunHAGubYPKbMqQtpFWZm1D4AGxB8wLuiVhE6T6cWo,8978
@@ -124,14 +126,14 @@ schemathesis/specs/openapi/negative/utils.py,sha256=ozcOIuASufLqZSgnKUACjX-EOZrr
 schemathesis/specs/openapi/stateful/__init__.py,sha256=R8RhPJD3rDzqL4eA9jSnUwh9Q_Mv27ka1C5FdRuyusY,4509
 schemathesis/specs/openapi/stateful/links.py,sha256=cSIwho2Hroty6au-gyCD-OwqnuCcIpnIIHU6FvF0SwA,3533
 schemathesis/stateful/__init__.py,sha256=T7rvhzftfl3wumEsir33DBBzCTK2PtRp9CxBxMLdMSE,4693
-schemathesis/stateful/state_machine.py,sha256=o940A5Uk-7DaeaVUg4Yf_xbG11v36eoEz-I5D4JKpOY,11717
-schemathesis/transports/__init__.py,sha256=Wix_WnOxZlDFD_XFqPMIqz_3TAc7Xda6UGicONaLnNM,108
+schemathesis/stateful/state_machine.py,sha256=ZcKpbvEl1QGhVOYnA7Ow6zkuFHtEPDAyCjroPrj-FgU,11343
+schemathesis/transports/__init__.py,sha256=IHQaob4pLHPP0zXXJukWEQBpV4aSIhGPHHMm0up8x64,11287
 schemathesis/transports/auth.py,sha256=ZKFku9gjhIG6445qNC2p_64Yt9Iz_4azbvja8AMptBk,404
 schemathesis/transports/content_types.py,sha256=xU8RZWxz-CyWRqQTI2fGYQacB7KasoY7LL_bxPQdyPY,2144
 schemathesis/transports/headers.py,sha256=EDxpm8su0AuhyqZUkMex-OFZMAJN_5NHah7fDT2HDZE,989
-schemathesis/transports/responses.py,sha256=U6z1VW5w19c9qRRoyf2ljkuXR2smTfWikmrTGqlgl18,1619
-schemathesis-3.26.2.dist-info/METADATA,sha256=6ILqISo9c7aYKJCwsxMgNop39oJl1ZPz2qtbhLD_1nc,16257
-schemathesis-3.26.2.dist-info/WHEEL,sha256=hKi7AIIx6qfnsRbr087vpeJnrVUuDokDHZacPPMW7-Y,87
-schemathesis-3.26.2.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.26.2.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.26.2.dist-info/RECORD,,
+schemathesis/transports/responses.py,sha256=j_-udvWbmi6XtEYmpdX8WoFnlrQ6-i3PSBizfozRjQI,1673
+schemathesis-3.27.1.dist-info/METADATA,sha256=GtcBreI2a4R9b3KL_eS-QQb57LTmQckmsQ_vkPTIdDs,16242
+schemathesis-3.27.1.dist-info/WHEEL,sha256=hKi7AIIx6qfnsRbr087vpeJnrVUuDokDHZacPPMW7-Y,87
+schemathesis-3.27.1.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.27.1.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.27.1.dist-info/RECORD,,