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

schemathesis/internal/output.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, replace
+from typing import Any
+
+TRUNCATED = "// Output truncated..."
+MAX_PAYLOAD_SIZE = 512
+MAX_LINES = 10
+MAX_WIDTH = 80
+
+
+@dataclass
+class OutputConfig:
+    """Options for configuring various aspects of Schemathesis output."""
+
+    truncate: bool = True
+    max_payload_size: int = MAX_PAYLOAD_SIZE
+    max_lines: int = MAX_LINES
+    max_width: int = MAX_WIDTH
+
+    @classmethod
+    def from_parent(cls, parent: OutputConfig | None = None, **changes: Any) -> OutputConfig:
+        parent = parent or OutputConfig()
+        return parent.replace(**changes)
+
+    def replace(self, **changes: Any) -> OutputConfig:
+        """Create a new instance with updated values."""
+        return replace(self, **changes)
+
+
+def truncate_json(data: Any, *, config: OutputConfig | None = None) -> str:
+    config = config or OutputConfig()
+    # Convert JSON to string with indentation
+    indent = 4
+    serialized = json.dumps(data, indent=indent)
+    if not config.truncate:
+        return serialized
+
+    # Split string by lines
+
+    lines = [
+        line[: config.max_width - 3] + "..." if len(line) > config.max_width else line
+        for line in serialized.split("\n")
+    ]
+
+    if len(lines) <= config.max_lines:
+        return "\n".join(lines)
+
+    truncated_lines = lines[: config.max_lines - 1]
+    indentation = " " * indent
+    truncated_lines.append(f"{indentation}{TRUNCATED}")
+    truncated_lines.append(lines[-1])
+
+    return "\n".join(truncated_lines)
+
+
+def prepare_response_payload(payload: str, *, config: OutputConfig | None = None) -> str:
+    if payload.endswith("\r\n"):
+        payload = payload[:-2]
+    elif payload.endswith("\n"):
+        payload = payload[:-1]
+    config = config or OutputConfig()
+    if not config.truncate:
+        return payload
+    if len(payload) > config.max_payload_size:
+        payload = payload[: config.max_payload_size] + f" {TRUNCATED}"
+    return payload

schemathesis/internal/result.py

@@ -1,4 +1,4 @@
-from typing import TypeVar, Generic, Union
+from typing import Generic, TypeVar, Union
 
 T = TypeVar("T")
 E = TypeVar("E", bound=Exception)

schemathesis/internal/transformation.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from typing import Any
 
 

schemathesis/lazy.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from dataclasses import dataclass, field
 from inspect import signature
 from typing import Any, Callable, Generator
@@ -13,13 +14,14 @@ from pyrate_limiter import Limiter
 from pytest_subtests import SubTests, nullcontext
 
 from ._compat import MultipleFailures, get_interesting_origin
-from ._override import check_no_override_mark, CaseOverride, set_override_mark, get_override_from_mark
+from ._override import CaseOverride, check_no_override_mark, get_override_from_mark, set_override_mark
 from .auths import AuthStorage
 from .code_samples import CodeSampleStyle
 from .constants import FLAKY_FAILURE_MESSAGE, NOT_SET
-from .generation import DataGenerationMethodInput, GenerationConfig
 from .exceptions import CheckFailed, OperationSchemaError, SkipTest, get_grouped_exception
+from .generation import DataGenerationMethodInput, GenerationConfig
 from .hooks import HookDispatcher, HookScope
+from .internal.output import OutputConfig
 from .internal.result import Ok
 from .models import APIOperation
 from .schemas import BaseSchema
@@ -51,6 +53,7 @@ class LazySchema:
     skip_deprecated_operations: bool = False
     data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET
     generation_config: GenerationConfig | NotSet = NOT_SET
+    output_config: OutputConfig | NotSet = NOT_SET
     code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
     rate_limiter: Limiter | None = None
     sanitize_output: bool = True
@@ -68,6 +71,7 @@ class LazySchema:
         skip_deprecated_operations: bool | NotSet = NOT_SET,
         data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
         generation_config: GenerationConfig | NotSet = NOT_SET,
+        output_config: OutputConfig | NotSet = NOT_SET,
         code_sample_style: str | NotSet = NOT_SET,
     ) -> Callable:
         if method is NOT_SET:
@@ -82,6 +86,8 @@ class LazySchema:
             data_generation_methods = self.data_generation_methods
         if generation_config is NOT_SET:
             generation_config = self.generation_config
+        if output_config is NOT_SET:
+            output_config = self.output_config
         if isinstance(code_sample_style, str):
             _code_sample_style = CodeSampleStyle.from_str(code_sample_style)
         else:
@@ -121,6 +127,7 @@ class LazySchema:
                     skip_deprecated_operations=skip_deprecated_operations,
                     data_generation_methods=data_generation_methods,
                     generation_config=generation_config,
+                    output_config=output_config,
                     code_sample_style=_code_sample_style,
                     app=self.app,
                     rate_limiter=self.rate_limiter,
@@ -325,6 +332,7 @@ def get_schema(
     skip_deprecated_operations: bool | NotSet = NOT_SET,
     data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
     generation_config: GenerationConfig | NotSet = NOT_SET,
+    output_config: OutputConfig | NotSet = NOT_SET,
     code_sample_style: CodeSampleStyle,
     rate_limiter: Limiter | None,
     sanitize_output: bool,
@@ -347,6 +355,7 @@ def get_schema(
         skip_deprecated_operations=skip_deprecated_operations,
         data_generation_methods=data_generation_methods,
         generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=code_sample_style,
         rate_limiter=rate_limiter,
         sanitize_output=sanitize_output,

schemathesis/loaders.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
+
 import re
 import sys
 from functools import lru_cache
-from typing import Callable, TypeVar, TYPE_CHECKING, TextIO, Any, BinaryIO
+from typing import TYPE_CHECKING, Any, BinaryIO, Callable, TextIO, TypeVar
 
 from .exceptions import SchemaError, SchemaErrorType, extract_requests_exception_details
 
 if TYPE_CHECKING:
-    from .transports.responses import GenericResponse
     import yaml
 
+    from .transports.responses import GenericResponse
+
 R = TypeVar("R", bound="GenericResponse")
 
 

schemathesis/models.py

@@ -42,19 +42,20 @@ from .exceptions import (
     OperationSchemaError,
     SerializationNotPossible,
     SkipTest,
+    UsageError,
     deduplicate_failed_checks,
     get_grouped_exception,
     maybe_set_assertion_message,
-    prepare_response_payload,
 )
 from .generation import DataGenerationMethod, GenerationConfig, generate_random_case_id
 from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, dispatch
 from .internal.copy import fast_deepcopy
 from .internal.deprecation import deprecated_function, deprecated_property
+from .internal.output import prepare_response_payload
 from .parameters import Parameter, ParameterSet, PayloadAlternatives
 from .sanitization import sanitize_request, sanitize_response
 from .serializers import Serializer
-from .transports import ASGITransport, RequestsTransport, WSGITransport, serialize_payload, deserialize_payload
+from .transports import ASGITransport, RequestsTransport, WSGITransport, deserialize_payload, serialize_payload
 from .types import Body, Cookies, FormData, Headers, NotSet, PathParameters, Query
 
 if TYPE_CHECKING:
@@ -271,13 +272,14 @@ class Case:
         final_headers.setdefault(SCHEMATHESIS_TEST_CASE_HEADER, self.id)
         return final_headers
 
-    def _get_serializer(self) -> Serializer | None:
+    def _get_serializer(self, media_type: str | None = None) -> Serializer | None:
         """Get a serializer for the payload, if there is any."""
-        if self.media_type is not None:
-            media_type = serializers.get_first_matching_media_type(self.media_type)
+        input_media_type = media_type or self.media_type
+        if input_media_type is not None:
+            media_type = serializers.get_first_matching_media_type(input_media_type)
             if media_type is None:
                 # This media type is set manually. Otherwise, it should have been rejected during the data generation
-                raise SerializationNotPossible.for_media_type(self.media_type)
+                raise SerializationNotPossible.for_media_type(input_media_type)
             # SAFETY: It is safe to assume that serializer will be found, because `media_type` returned above
             # is registered. This intentionally ignores cases with concurrent serializers registry modification.
             cls = cast(Type[serializers.Serializer], serializers.get(media_type))
@@ -418,7 +420,7 @@ class Case:
             if not payload:
                 formatted += "\n\n    <EMPTY>"
             else:
-                payload = prepare_response_payload(payload)
+                payload = prepare_response_payload(payload, config=self.operation.schema.output_config)
                 payload = textwrap.indent(f"\n`{payload}`", prefix="    ")
                 formatted += f"\n{payload}"
             code_sample_style = (
@@ -694,6 +696,19 @@ class APIOperation(Generic[P, C]):
     def get_request_payload_content_types(self) -> list[str]:
         return self.schema.get_request_payload_content_types(self)
 
+    def _get_default_media_type(self) -> str:
+        # If the user wants to send payload, then there should be a media type, otherwise the payload is ignored
+        media_types = self.get_request_payload_content_types()
+        if len(media_types) == 1:
+            # The only available option
+            return media_types[0]
+        media_types_repr = ", ".join(media_types)
+        raise UsageError(
+            "Can not detect appropriate media type. "
+            "You can either specify one of the defined media types "
+            f"or pass any other media type available for serialization. Defined media types: {media_types_repr}"
+        )
+
     def partial_deepcopy(self) -> APIOperation:
         return self.__class__(
             path=self.path,  # string, immutable

schemathesis/parameters.py

@@ -4,6 +4,7 @@ These are basic entities that describe what data could be sent to the API.
 """
 
 from __future__ import annotations
+
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Generator, Generic, TypeVar
 

schemathesis/runner/__init__.py

@@ -28,10 +28,10 @@ if TYPE_CHECKING:
 
     from ..models import CheckFunction
     from ..schemas import BaseSchema
+    from ..service.client import ServiceClient
     from ..stateful import Stateful
     from . import events
     from .impl import BaseRunner
-    from ..service.client import ServiceClient
 
 
 @deprecated_function(removed_in="4.0", replacement="schemathesis.runner.from_schema")

schemathesis/runner/events.py

@@ -1,21 +1,22 @@
 from __future__ import annotations
+
 import enum
 import threading
 import time
 from dataclasses import asdict, dataclass, field
-from typing import Any, TYPE_CHECKING
+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 ..generation import DataGenerationMethod
-from ..exceptions import SchemaError, SchemaErrorType, format_exception, RuntimeErrorType
 from .serialization import SerializedError, SerializedTestResult
 
-
 if TYPE_CHECKING:
     from ..models import APIOperation, Status, TestResult, TestResultSet
     from ..schemas import BaseSchema
     from ..service.models import AnalysisResult
+    from ..stateful import events
     from . import probes
 
 
@@ -287,6 +288,23 @@ class InternalError(ExecutionEvent):
         )
 
 
+@dataclass
+class StatefulEvent(ExecutionEvent):
+    """Represents an event originating from the state machine runner."""
+
+    data: events.StatefulEvent
+
+    __slots__ = ("data",)
+
+
+@dataclass
+class AfterStatefulExecution(ExecutionEvent):
+    """Happens after the stateful test run."""
+
+    status: Status
+    result: SerializedTestResult
+
+
 @dataclass
 class Finished(ExecutionEvent):
     """The final event of the run.

schemathesis/runner/impl/core.py

@@ -21,9 +21,7 @@ from jsonschema.exceptions import SchemaError as JsonSchemaError
 from jsonschema.exceptions import ValidationError
 from requests.auth import HTTPDigestAuth, _basic_auth_str
 
-from schemathesis.transports import RequestsTransport
-
-from ... import failures, hooks
+from ... import experimental, failures, hooks
 from ..._compat import MultipleFailures
 from ..._hypothesis import (
     get_invalid_example_headers_mark,
@@ -65,7 +63,10 @@ from ...service import extensions
 from ...service.models import AnalysisResult, AnalysisSuccess
 from ...specs.openapi import formats
 from ...stateful import Feedback, Stateful
+from ...stateful import events as stateful_events
+from ...stateful import runner as stateful_runner
 from ...targets import Target, TargetContext
+from ...transports import RequestsTransport, prepare_timeout
 from ...types import RawAuth, RequestCert
 from ...utils import capture_hypothesis_output
 from .. import probes
@@ -191,7 +192,9 @@ class BaseRunner:
                 return
 
         try:
-            yield from self._execute(results, stop_event)
+            if not experimental.STATEFUL_ONLY.is_enabled:
+                yield from self._execute(results, stop_event)
+            yield from self._run_stateful_tests(results)
         except KeyboardInterrupt:
             yield events.Interrupted()
 
@@ -211,6 +214,40 @@ class BaseRunner:
     ) -> Generator[events.ExecutionEvent, None, None]:
         raise NotImplementedError
 
+    def _run_stateful_tests(self, results: TestResultSet) -> Generator[events.ExecutionEvent, None, None]:
+        # Run new-style stateful tests
+        if self.stateful is not None and experimental.STATEFUL_TEST_RUNNER.is_enabled and self.schema.links_count > 0:
+            result = TestResult(
+                method="",
+                path="",
+                verbose_name="Stateful tests",
+                data_generation_method=self.schema.data_generation_methods,
+            )
+            config = stateful_runner.StatefulTestRunnerConfig(
+                checks=tuple(self.checks),
+                headers=self.headers or {},
+                hypothesis_settings=self.hypothesis_settings,
+                exit_first=self.exit_first,
+                request_timeout=self.request_timeout,
+            )
+            state_machine = self.schema.as_state_machine()
+            runner = state_machine.runner(config=config)
+            status = Status.success
+            for stateful_event in runner.execute():
+                if isinstance(stateful_event, stateful_events.SuiteFinished):
+                    if stateful_event.failures and status != Status.error:
+                        status = Status.failure
+                    for failure in stateful_event.failures:
+                        result.checks.append(failure)
+                elif isinstance(stateful_event, stateful_events.Errored):
+                    status = Status.error
+                yield events.StatefulEvent(data=stateful_event)
+            results.append(result)
+            yield events.AfterStatefulExecution(
+                status=status,
+                result=SerializedTestResult.from_test_result(result),
+            )
+
     def _run_tests(
         self,
         maker: Callable,
@@ -246,7 +283,10 @@ class BaseRunner:
         ):
             if isinstance(result, Ok):
                 operation, test = result.ok()
-                feedback = Feedback(self.stateful, operation)
+                if self.stateful is not None and not experimental.STATEFUL_TEST_RUNNER.is_enabled:
+                    feedback = Feedback(self.stateful, operation)
+                else:
+                    feedback = None
                 # Track whether `BeforeExecution` was already emitted.
                 # Schema error may happen before / after `BeforeExecution`, but it should be emitted only once
                 # and the `AfterExecution` event should have the same correlation id as previous `BeforeExecution`
@@ -268,17 +308,18 @@ class BaseRunner:
                         if isinstance(event, events.Interrupted):
                             return
                     # Additional tests, generated via the `feedback` instance
-                    yield from self._run_tests(
-                        feedback.get_stateful_tests,
-                        template,
-                        settings=settings,
-                        generation_config=generation_config,
-                        seed=seed,
-                        recursion_level=recursion_level + 1,
-                        results=results,
-                        headers=headers,
-                        **kwargs,
-                    )
+                    if feedback is not None:
+                        yield from self._run_tests(
+                            feedback.get_stateful_tests,
+                            template,
+                            settings=settings,
+                            generation_config=generation_config,
+                            seed=seed,
+                            recursion_level=recursion_level + 1,
+                            results=results,
+                            headers=headers,
+                            **kwargs,
+                        )
                 except OperationSchemaError as exc:
                     yield from handle_schema_error(
                         exc,
@@ -788,7 +829,7 @@ def network_test(
     request_cert: RequestCert | None,
     store_interactions: bool,
     headers: dict[str, Any] | None,
-    feedback: Feedback,
+    feedback: Feedback | None,
     max_response_time: int | None,
     data_generation_methods: list[DataGenerationMethod],
     dry_run: bool,
@@ -830,7 +871,7 @@ def _network_test(
     timeout: float | None,
     store_interactions: bool,
     headers: dict[str, Any] | None,
-    feedback: Feedback,
+    feedback: Feedback | None,
     request_tls_verify: bool,
     request_proxy: str | None,
     request_cert: RequestCert | None,
@@ -877,7 +918,8 @@ def _network_test(
         status = Status.failure
         raise
     finally:
-        feedback.add_test_case(case, response)
+        if feedback is not None:
+            feedback.add_test_case(case, response)
         if store_interactions:
             result.store_requests_response(case, response, status, check_results)
     return response
@@ -891,14 +933,6 @@ def get_session(auth: HTTPDigestAuth | RawAuth | None = None) -> Generator[reque
         yield session
 
 
-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 wsgi_test(
     case: Case,
     checks: Iterable[CheckFunction],
@@ -908,7 +942,7 @@ def wsgi_test(
     auth_type: str | None,
     headers: dict[str, Any] | None,
     store_interactions: bool,
-    feedback: Feedback,
+    feedback: Feedback | None,
     max_response_time: int | None,
     data_generation_methods: list[DataGenerationMethod],
     dry_run: bool,
@@ -939,7 +973,7 @@ def _wsgi_test(
     result: TestResult,
     headers: dict[str, Any],
     store_interactions: bool,
-    feedback: Feedback,
+    feedback: Feedback | None,
     max_response_time: int | None,
 ) -> WSGIResponse:
     from ...transports.responses import WSGIResponse
@@ -968,7 +1002,8 @@ def _wsgi_test(
         status = Status.failure
         raise
     finally:
-        feedback.add_test_case(case, response)
+        if feedback is not None:
+            feedback.add_test_case(case, response)
         if store_interactions:
             result.store_wsgi_response(case, response, headers, response.elapsed.total_seconds(), status, check_results)
     return response
@@ -1001,7 +1036,7 @@ def asgi_test(
     result: TestResult,
     store_interactions: bool,
     headers: dict[str, Any] | None,
-    feedback: Feedback,
+    feedback: Feedback | None,
     max_response_time: int | None,
     data_generation_methods: list[DataGenerationMethod],
     dry_run: bool,
@@ -1034,7 +1069,7 @@ def _asgi_test(
     result: TestResult,
     store_interactions: bool,
     headers: dict[str, Any] | None,
-    feedback: Feedback,
+    feedback: Feedback | None,
     max_response_time: int | None,
 ) -> requests.Response:
     hook_context = HookContext(operation=case.operation)
@@ -1059,7 +1094,8 @@ def _asgi_test(
         status = Status.failure
         raise
     finally:
-        feedback.add_test_case(case, response)
+        if feedback is not None:
+            feedback.add_test_case(case, response)
         if store_interactions:
             result.store_requests_response(case, response, status, check_results)
     return response

schemathesis/runner/impl/solo.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
+
 import threading
 from dataclasses import dataclass
 from typing import Generator
 
 from ...models import TestResultSet
-from ...types import RequestCert
 from ...transports.auth import get_requests_auth
+from ...types import RequestCert
 from .. import events
 from .core import BaseRunner, asgi_test, get_session, network_test, wsgi_test
 

schemathesis/runner/impl/threadpool.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
+
 import ctypes
 import queue
 import threading
 import time
+import warnings
 from dataclasses import dataclass
 from queue import Queue
 from typing import Any, Callable, Generator, Iterable, cast
 
 import hypothesis
+from hypothesis.errors import HypothesisWarning
 
 from ..._hypothesis import create_test
 from ...generation import DataGenerationMethod, GenerationConfig
@@ -39,6 +42,7 @@ def _run_task(
     headers: dict[str, Any] | None = None,
     **kwargs: Any,
 ) -> None:
+    warnings.filterwarnings("ignore", message="The recursion limit will not be reset", category=HypothesisWarning)
     as_strategy_kwargs = {}
     if headers is not None:
         as_strategy_kwargs["headers"] = {key: value for key, value in headers.items() if key.lower() != "user-agent"}

schemathesis/runner/probes.py

@@ -22,8 +22,8 @@ from ..transports.auth import get_requests_auth
 if TYPE_CHECKING:
     import requests
 
-    from ..types import RequestCert
     from ..schemas import BaseSchema
+    from ..types import RequestCert
 
 
 HEADER_NAME = "X-Schemathesis-Probe"

schemathesis/runner/serialization.py

@@ -28,7 +28,7 @@ from ..exceptions import (
     make_unique_by_key,
 )
 from ..models import Case, Check, Interaction, Request, Response, Status, TestResult
-from ..transports import serialize_payload, deserialize_payload
+from ..transports import deserialize_payload, serialize_payload
 
 if TYPE_CHECKING:
     import hypothesis.errors

schemathesis/sanitization.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import threading
 from collections.abc import MutableMapping, MutableSequence
 from dataclasses import dataclass, replace
@@ -9,6 +10,7 @@ from .constants import NOT_SET
 
 if TYPE_CHECKING:
     from requests import PreparedRequest
+
     from .models import Case, CaseSource, Request
     from .runner.serialization import SerializedCase, SerializedCheck, SerializedInteraction
     from .transports.responses import GenericResponse

schemathesis/schemas.py

@@ -44,6 +44,7 @@ from .generation import (
     GenerationConfig,
 )
 from .hooks import HookContext, HookDispatcher, HookScope, dispatch
+from .internal.output import OutputConfig
 from .internal.result import Ok, Result
 from .models import APIOperation, Case
 from .stateful import Stateful, StatefulTest
@@ -94,6 +95,7 @@ class BaseSchema(Mapping):
         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
@@ -286,6 +288,7 @@ class BaseSchema(Mapping):
         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,
@@ -314,6 +317,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:
@@ -337,6 +342,7 @@ class BaseSchema(Mapping):
             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
@@ -397,10 +403,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]]:

schemathesis/service/ci.py

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