schemathesis 3.29.2__py3-none-any.whl → 3.30.1__py3-none-any.whl

schemathesis/stateful/runner.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import queue
+import threading
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Generator, Iterator, Type, cast
+
+from hypothesis.control import current_build_context
+from hypothesis.errors import Flaky
+
+from ..exceptions import CheckFailed
+from . import events
+from .config import StatefulTestRunnerConfig
+from .context import RunnerContext
+from .validation import validate_response
+
+if TYPE_CHECKING:
+    from ..models import Case, CheckFunction
+    from ..transports.responses import GenericResponse
+    from .state_machine import APIStateMachine, Direction, StepResult
+
+EVENT_QUEUE_TIMEOUT = 0.01
+
+
+@dataclass
+class StatefulTestRunner:
+    """Stateful test runner for the given state machine.
+
+    By default, the test runner executes the state machine in a loop until there are no new failures are found.
+    The loop is executed in a separate thread for better control over the execution and reporting.
+    """
+
+    # State machine class to use
+    state_machine: Type[APIStateMachine]
+    # Test runner configuration that defines the runtime behavior
+    config: StatefulTestRunnerConfig = field(default_factory=StatefulTestRunnerConfig)
+    # Event to stop the execution
+    stop_event: threading.Event = field(default_factory=threading.Event)
+    # Queue to communicate with the state machine execution
+    event_queue: queue.Queue = field(default_factory=queue.Queue)
+
+    def execute(self) -> Iterator[events.StatefulEvent]:
+        """Execute a test run for a state machine."""
+        self.stop_event.clear()
+
+        yield events.RunStarted(state_machine=self.state_machine)
+
+        runner_thread = threading.Thread(
+            target=_execute_state_machine_loop,
+            kwargs={
+                "state_machine": self.state_machine,
+                "event_queue": self.event_queue,
+                "config": self.config,
+                "stop_event": self.stop_event,
+            },
+        )
+        run_status = events.RunStatus.SUCCESS
+
+        with thread_manager(runner_thread):
+            try:
+                while True:
+                    try:
+                        event = self.event_queue.get(timeout=EVENT_QUEUE_TIMEOUT)
+                        # Set the run status based on the suite status
+                        # ERROR & INTERRPUTED statuses are terminal, therefore they should not be overridden
+                        if isinstance(event, events.SuiteFinished):
+                            if event.status == events.SuiteStatus.FAILURE:
+                                run_status = events.RunStatus.FAILURE
+                            elif event.status == events.SuiteStatus.ERROR:
+                                run_status = events.RunStatus.ERROR
+                            elif event.status == events.SuiteStatus.INTERRUPTED:
+                                run_status = events.RunStatus.INTERRUPTED
+                        yield event
+                    except queue.Empty:
+                        if not runner_thread.is_alive():
+                            break
+            except KeyboardInterrupt:
+                # Immediately notify the runner thread to stop, even though that the event will be set below in `finally`
+                self.stop()
+                run_status = events.RunStatus.INTERRUPTED
+                yield events.Interrupted()
+            finally:
+                self.stop()
+
+            yield events.RunFinished(status=run_status)
+
+    def stop(self) -> None:
+        """Stop the execution of the state machine."""
+        self.stop_event.set()
+
+
+@contextmanager
+def thread_manager(thread: threading.Thread) -> Generator[None, None, None]:
+    thread.start()
+    try:
+        yield
+    finally:
+        thread.join()
+
+
+def _execute_state_machine_loop(
+    *,
+    state_machine: Type[APIStateMachine],
+    event_queue: queue.Queue,
+    config: StatefulTestRunnerConfig,
+    stop_event: threading.Event,
+) -> None:
+    """Execute the state machine testing loop."""
+    from hypothesis import reporting
+
+    from ..transports import RequestsTransport, prepare_timeout
+
+    ctx = RunnerContext()
+
+    call_kwargs: dict[str, Any] = {"headers": config.headers}
+    if isinstance(state_machine.schema.transport, RequestsTransport):
+        call_kwargs["timeout"] = prepare_timeout(config.request_timeout)
+
+    class InstrumentedStateMachine(state_machine):  # type: ignore[valid-type,misc]
+        """State machine with additional hooks for emitting events."""
+
+        def setup(self) -> None:
+            build_ctx = current_build_context()
+            event_queue.put(events.ScenarioStarted(is_final=build_ctx.is_final))
+            super().setup()
+
+        def get_call_kwargs(self, case: Case) -> dict[str, Any]:
+            return call_kwargs
+
+        def step(self, case: Case, previous: tuple[StepResult, Direction] | None = None) -> StepResult:
+            # Checking the stop event once inside `step` is sufficient as it is called frequently
+            # The idea is to stop the execution as soon as possible
+            if stop_event.is_set():
+                raise KeyboardInterrupt
+            event_queue.put(events.StepStarted())
+            try:
+                result = super().step(case, previous)
+                ctx.step_succeeded()
+            except CheckFailed:
+                ctx.step_failed()
+                raise
+            except Exception:
+                ctx.step_errored()
+                raise
+            except KeyboardInterrupt:
+                ctx.step_interrupted()
+                raise
+            finally:
+                transition_id: events.TransitionId | None
+                if previous is not None:
+                    transition = previous[1]
+                    transition_id = events.TransitionId(
+                        name=transition.name,
+                        status_code=transition.status_code,
+                        source=transition.operation.verbose_name,
+                    )
+                else:
+                    transition_id = None
+                response: events.ResponseData | None
+                if ctx.current_response is not None:
+                    response = events.ResponseData(
+                        status_code=ctx.current_response.status_code,
+                        elapsed=ctx.current_response.elapsed.total_seconds(),
+                    )
+                else:
+                    response = None
+                status = cast(events.StepStatus, ctx.current_step_status)
+                event_queue.put(
+                    events.StepFinished(
+                        status=status,
+                        transition_id=transition_id,
+                        target=case.operation.verbose_name,
+                        response=response,
+                    )
+                )
+            return result
+
+        def validate_response(
+            self, response: GenericResponse, case: Case, additional_checks: tuple[CheckFunction, ...] = ()
+        ) -> None:
+            ctx.current_response = response
+            validate_response(response, case, ctx, config.checks, additional_checks)
+
+        def teardown(self) -> None:
+            build_ctx = current_build_context()
+            event_queue.put(
+                events.ScenarioFinished(
+                    status=ctx.current_scenario_status,
+                    is_final=build_ctx.is_final,
+                )
+            )
+            ctx.reset_step()
+            super().teardown()
+
+    while True:
+        # This loop is running until no new failures are found in a single iteration
+        event_queue.put(events.SuiteStarted())
+        if stop_event.is_set():
+            event_queue.put(events.SuiteFinished(status=events.SuiteStatus.INTERRUPTED, failures=[]))
+            break
+        suite_status = events.SuiteStatus.SUCCESS
+        try:
+            with reporting.with_reporter(lambda _: None):  # type: ignore
+                InstrumentedStateMachine.run(settings=config.hypothesis_settings)
+        except KeyboardInterrupt:
+            # Raised in the state machine when the stop event is set or it is raised by the user's code
+            # that is placed in the base class of the state machine.
+            # Therefore, set the stop event to cover the latter case
+            stop_event.set()
+            suite_status = events.SuiteStatus.INTERRUPTED
+            break
+        except CheckFailed as exc:
+            # When a check fails, the state machine is stopped
+            # The failure is already sent to the queue by the state machine
+            # Here we need to either exit or re-run the state machine with this failure marked as known
+            suite_status = events.SuiteStatus.FAILURE
+            if config.exit_first:
+                break
+            ctx.mark_as_seen_in_run(exc)
+            continue
+        except Flaky:
+            suite_status = events.SuiteStatus.FAILURE
+            if config.exit_first:
+                break
+            # Mark all failures in this suite as seen to prevent them being re-discovered
+            ctx.mark_current_suite_as_seen_in_run()
+            continue
+        except Exception as exc:
+            # Any other exception is an inner error and the test run should be stopped
+            suite_status = events.SuiteStatus.ERROR
+            event_queue.put(events.Errored(exception=exc))
+            break
+        finally:
+            event_queue.put(events.SuiteFinished(status=suite_status, failures=ctx.failures_for_suite))
+            ctx.reset()
+        # Exit on the first successful state machine execution
+        break

schemathesis/stateful/sink.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from . import events
+from .statistic import TransitionStats
+
+if TYPE_CHECKING:
+    from ..models import Check
+
+
+@dataclass
+class AverageResponseTime:
+    """Average response time for a given status code.
+
+    Stored as a sum of all response times and a count of responses.
+    """
+
+    total: float
+    count: int
+
+    __slots__ = ("total", "count")
+
+    def __init__(self) -> None:
+        self.total = 0.0
+        self.count = 0
+
+
+@dataclass
+class StateMachineSink:
+    """Collects events and stores data about the state machine execution."""
+
+    transitions: TransitionStats
+    response_times: dict[str, dict[int, AverageResponseTime]] = field(default_factory=dict)
+    steps: dict[events.StepStatus, int] = field(default_factory=lambda: {status: 0 for status in events.StepStatus})
+    scenarios: dict[events.ScenarioStatus, int] = field(
+        default_factory=lambda: {status: 0 for status in events.ScenarioStatus}
+    )
+    suites: dict[events.SuiteStatus, int] = field(default_factory=lambda: {status: 0 for status in events.SuiteStatus})
+    failures: list[Check] = field(default_factory=list)
+    start_time: float | None = None
+    end_time: float | None = None
+
+    def consume(self, event: events.StatefulEvent) -> None:
+        self.transitions.consume(event)
+        if isinstance(event, events.RunStarted):
+            self.start_time = event.timestamp
+        elif isinstance(event, events.StepFinished):
+            self.steps[event.status] += 1
+            responses = self.response_times.setdefault(event.target, {})
+            if event.response is not None:
+                average = responses.setdefault(event.response.status_code, AverageResponseTime())
+                average.total += event.response.elapsed
+                average.count += 1
+        elif isinstance(event, events.ScenarioFinished):
+            self.scenarios[event.status] += 1
+        elif isinstance(event, events.SuiteFinished):
+            self.suites[event.status] += 1
+            self.failures.extend(event.failures)
+        elif isinstance(event, events.RunFinished):
+            self.end_time = event.timestamp
+
+    @property
+    def duration(self) -> float | None:
+        if self.start_time is not None and self.end_time is not None:
+            return self.end_time - self.start_time
+        return None

schemathesis/stateful/state_machine.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-import time
 import re
+import time
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, ClassVar
 
@@ -12,6 +12,9 @@ from .._dependency_versions import HYPOTHESIS_HAS_STATEFUL_NAMING_IMPROVEMENTS
 from ..constants import NO_LINKS_ERROR_MESSAGE, NOT_SET
 from ..exceptions import UsageError
 from ..models import APIOperation, Case, CheckFunction
+from .runner import StatefulTestRunner, StatefulTestRunnerConfig
+from .sink import StateMachineSink
+from .statistic import TransitionStats
 
 if TYPE_CHECKING:
     import hypothesis
@@ -30,7 +33,7 @@ class StepResult:
     elapsed: float
 
 
-def _operation_name_to_identifier(name: str) -> str:
+def _normalize_name(name: str) -> str:
     return re.sub(r"\W|^(?=\d)", "_", name).replace("__", "_")
 
 
@@ -45,6 +48,8 @@ class APIStateMachine(RuleBasedStateMachine):
     # attribute will be renamed in the future
     bundles: ClassVar[dict[str, CaseInsensitiveDict]]  # type: ignore
     schema: BaseSchema
+    # A template for transition statistics that can be filled with data from the state machine during its execution
+    _transition_stats_template: ClassVar[TransitionStats]
 
     def __init__(self) -> None:
         try:
@@ -60,18 +65,26 @@ class APIStateMachine(RuleBasedStateMachine):
             # State machines suppose to be reproducible, hence it is OK to get kwargs here
             kwargs = self.get_call_kwargs(value)
             return _print_case(value, kwargs)
-        if isinstance(value, tuple) and len(value) == 2:
-            result, direction = value
-            wrapper = _DirectionWrapper(direction)
-            return super()._pretty_print((result, wrapper))  # type: ignore
         return super()._pretty_print(value)  # type: ignore
 
     if HYPOTHESIS_HAS_STATEFUL_NAMING_IMPROVEMENTS:
 
         def _new_name(self, target: str) -> str:
-            target = _operation_name_to_identifier(target)
+            target = _normalize_name(target)
             return super()._new_name(target)  # type: ignore
 
+    def _get_target_for_result(self, result: StepResult) -> str | None:
+        raise NotImplementedError
+
+    def _add_result_to_targets(self, targets: tuple[str, ...], result: StepResult) -> None:
+        target = self._get_target_for_result(result)
+        if target is not None:
+            super()._add_result_to_targets((target,), result)
+
+    @classmethod
+    def format_rules(cls) -> str:
+        raise NotImplementedError
+
     @classmethod
     def run(cls, *, settings: hypothesis.settings | None = None) -> None:
         """Run state machine as a test."""
@@ -79,6 +92,18 @@ class APIStateMachine(RuleBasedStateMachine):
 
         return run_state_machine_as_test(cls, settings=settings)
 
+    @classmethod
+    def runner(cls, *, config: StatefulTestRunnerConfig | None = None) -> StatefulTestRunner:
+        """Create a runner for this state machine."""
+        from .runner import StatefulTestRunnerConfig
+
+        return StatefulTestRunner(cls, config=config or StatefulTestRunnerConfig())
+
+    @classmethod
+    def sink(cls) -> StateMachineSink:
+        """Create a sink to collect events into."""
+        return StateMachineSink(transitions=cls._transition_stats_template.copy())
+
     def setup(self) -> None:
         """Hook method that runs unconditionally in the beginning of each test scenario.
 
@@ -94,12 +119,14 @@ class APIStateMachine(RuleBasedStateMachine):
     def transform(self, result: StepResult, direction: Direction, case: Case) -> Case:
         raise NotImplementedError
 
-    def _step(self, case: Case, previous: tuple[StepResult, Direction] | None = None) -> StepResult:
+    def _step(self, case: Case, previous: StepResult | None = None, link: Direction | None = None) -> StepResult:
         # This method is a proxy that is used under the hood during the state machine initialization.
         # The whole point of having it is to make it possible to override `step`; otherwise, custom "step" is ignored.
         # It happens because, at the point of initialization, the final class is not yet created.
         __tracebackhide__ = True
-        return self.step(case, previous)
+        if previous is not None and link is not None:
+            return self.step(case, (previous, link))
+        return self.step(case, None)
 
     def step(self, case: Case, previous: tuple[StepResult, Direction] | None = None) -> StepResult:
         """A single state machine step.
@@ -110,6 +137,8 @@ class APIStateMachine(RuleBasedStateMachine):
         Schemathesis prepares data, makes a call and validates the received response.
         It is the most high-level point to extend the testing process. You probably don't need it in most cases.
         """
+        from ..specs.openapi.checks import use_after_free
+
         __tracebackhide__ = True
         if previous is not None:
             result, direction = previous
@@ -120,7 +149,7 @@ class APIStateMachine(RuleBasedStateMachine):
         response = self.call(case, **kwargs)
         elapsed = time.monotonic() - start
         self.after_call(response, case)
-        self.validate_response(response, case)
+        self.validate_response(response, case, additional_checks=(use_after_free,))
         return self.store_result(response, case, elapsed)
 
     def before_call(self, case: Case) -> None:
@@ -274,15 +303,3 @@ class Direction:
 
     def set_data(self, case: Case, elapsed: float, **kwargs: Any) -> None:
         raise NotImplementedError
-
-
-@dataclass(repr=False)
-class _DirectionWrapper:
-    """Purely to avoid modification of `Direction.__repr__`."""
-
-    direction: Direction
-
-    def __repr__(self) -> str:
-        path = self.direction.operation.path
-        method = self.direction.operation.method.upper()
-        return f"state.schema['{path}']['{method}'].links['{self.direction.status_code}']['{self.direction.name}']"

schemathesis/stateful/statistic.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from . import events
+
+
+@dataclass
+class TransitionStats:
+    """Statistic for transitions in a state machine."""
+
+    def consume(self, event: events.StatefulEvent) -> None:
+        raise NotImplementedError
+
+    def copy(self) -> TransitionStats:
+        """Create a copy of the statistic."""
+        raise NotImplementedError
+
+    def to_formatted_table(self, width: int) -> str:
+        raise NotImplementedError

schemathesis/stateful/validation.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..exceptions import CheckFailed, get_grouped_exception
+from .context import RunnerContext
+
+if TYPE_CHECKING:
+    from ..failures import FailureContext
+    from ..models import Case, CheckFunction
+    from ..transports.responses import GenericResponse
+
+
+def validate_response(
+    response: GenericResponse,
+    case: Case,
+    failures: RunnerContext,
+    checks: tuple[CheckFunction, ...],
+    additional_checks: tuple[CheckFunction, ...] = (),
+) -> None:
+    """Validate the response against the provided checks."""
+    from .._compat import MultipleFailures
+    from ..models import Check, Status
+
+    exceptions: list[CheckFailed | AssertionError] = []
+
+    def _on_failure(exc: CheckFailed | AssertionError, message: str, context: FailureContext | None) -> None:
+        exceptions.append(exc)
+        if failures.is_seen_in_suite(exc):
+            return
+        failures.add_failed_check(
+            Check(
+                name=name,
+                value=Status.failure,
+                response=response,
+                elapsed=response.elapsed.total_seconds(),
+                example=copied_case,
+                message=message,
+                context=context,
+                request=None,
+            )
+        )
+        failures.mark_as_seen_in_suite(exc)
+
+    for check in checks + additional_checks:
+        name = check.__name__
+        copied_case = case.partial_deepcopy()
+        try:
+            check(response, copied_case)
+        except CheckFailed as exc:
+            if failures.is_seen_in_run(exc):
+                continue
+            _on_failure(exc, str(exc), exc.context)
+        except AssertionError as exc:
+            if failures.is_seen_in_run(exc):
+                continue
+            _on_failure(exc, str(exc) or f"Custom check failed: `{name}`", None)
+        except MultipleFailures as exc:
+            for subexc in exc.exceptions:
+                if failures.is_seen_in_run(subexc):
+                    continue
+                _on_failure(subexc, str(subexc), subexc.context)
+
+    # Raise a grouped exception so Hypothesis can properly deduplicate it against the other failures
+    if exceptions:
+        raise get_grouped_exception(case.operation.verbose_name, *exceptions)(causes=tuple(exceptions))

schemathesis/targets.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Callable
 

schemathesis/throttling.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
+from ._dependency_versions import IS_PYRATE_LIMITER_ABOVE_3
 from .exceptions import UsageError
 
-
 if TYPE_CHECKING:
-    from pyrate_limiter import Limiter
+    from pyrate_limiter import Duration, Limiter
 
 
 def parse_units(rate: str) -> tuple[int, int]:
@@ -33,9 +34,28 @@ def invalid_rate(value: str) -> UsageError:
     )
 
 
+def _get_max_delay(value: int, unit: Duration) -> int:
+    from pyrate_limiter import Duration
+
+    if unit == Duration.SECOND:
+        multiplier = 1
+    elif unit == Duration.MINUTE:
+        multiplier = 60
+    elif unit == Duration.HOUR:
+        multiplier = 60 * 60
+    else:
+        multiplier = 60 * 60 * 24
+    # Delay is in milliseconds + `pyrate_limiter` adds 50ms on top.
+    # Hence adding 100 covers this
+    return value * multiplier * 1000 + 100
+
+
 def build_limiter(rate: str) -> Limiter:
     from ._rate_limiter import Limiter, Rate
 
     limit, interval = parse_units(rate)
     rate = Rate(limit, interval)
-    return Limiter(rate)
+    kwargs = {}
+    if IS_PYRATE_LIMITER_ABOVE_3:
+        kwargs["max_delay"] = _get_max_delay(limit, interval)
+    return Limiter(rate, **kwargs)

schemathesis/transports/__init__.py

@@ -2,16 +2,16 @@ 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 inspect import iscoroutinefunction
+from typing import TYPE_CHECKING, Any, Generator, Optional, 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 ..constants import DEFAULT_RESPONSE_TIMEOUT, NOT_SET
 from ..exceptions import get_timeout_error
 from ..serializers import SerializerContext
 from ..types import Cookies, NotSet
@@ -88,12 +88,17 @@ class RequestsTransport:
         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):
+        media_type: Optional[str]
+        if case.body is not NOT_SET and case.media_type is None:
+            media_type = case.operation._get_default_media_type()
+        else:
+            media_type = case.media_type
+        if media_type and 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
+                final_headers["Content-Type"] = media_type
         url = case._get_url(base_url)
-        serializer = case._get_serializer()
+        serializer = case._get_serializer(media_type)
         if serializer is not None and not isinstance(case.body, NotSet):
             context = SerializerContext(case=case)
             extra = serializer.as_requests(context, case._get_body())
@@ -169,7 +174,7 @@ class RequestsTransport:
             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)(
+            raise get_timeout_error(case.operation.verbose_name, timeout)(
                 f"\n\n1. {failures.RequestTimeout.title}\n\n{message}\n\n{code_message}",
                 context=failures.RequestTimeout(message=message, timeout=timeout),
             ) from None
@@ -186,6 +191,14 @@ def _merge_dict_to(data: dict[str, Any], data_key: str, new: dict[str, Any]) ->
     data[data_key] = original
 
 
+def prepare_timeout(timeout: int | None) -> float | None:
+    """Request timeout is in milliseconds, but `requests` uses seconds."""
+    output: int | float | None = timeout
+    if timeout is not None:
+        output = timeout / 1000
+    return output
+
+
 def validate_vanilla_requests_kwargs(data: dict[str, Any]) -> None:
     """Check arguments for `requests.Session.request`.
 
@@ -240,11 +253,16 @@ class WSGITransport:
         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):
+        media_type: Optional[str]
+        if case.body is not NOT_SET and case.media_type is None:
+            media_type = case.operation._get_default_media_type()
+        else:
+            media_type = case.media_type
+        if 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
+            final_headers["Content-Type"] = media_type
         extra: dict[str, Any]
-        serializer = case._get_serializer()
+        serializer = case._get_serializer(media_type)
         if serializer is not None and not isinstance(case.body, NotSet):
             context = SerializerContext(case=case)
             extra = serializer.as_werkzeug(context, case._get_body())

schemathesis/transports/auth.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 from ..types import RawAuth

schemathesis/transports/content_types.py

@@ -1,5 +1,5 @@
 from functools import lru_cache
-from typing import Tuple, Generator
+from typing import Generator, Tuple
 
 
 def _parseparam(s: str) -> Generator[str, None, None]: