schemathesis 3.35.4__py3-none-any.whl → 3.35.5__py3-none-any.whl

schemathesis/__init__.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 from typing import Any
 
-from . import auths, checks, contrib, experimental, fixups, graphql, hooks, runner, serializers, targets  # noqa: E402
+from . import auths, checks, contrib, experimental, fixups, graphql, hooks, runner, serializers, targets
 from ._lazy_import import lazy_import
-from .constants import SCHEMATHESIS_VERSION  # noqa: E402
-from .generation import DataGenerationMethod, GenerationConfig, HeaderConfig  # noqa: E402
-from .models import Case  # noqa: E402
-from .specs import openapi  # noqa: E402
+from .constants import SCHEMATHESIS_VERSION
+from .generation import DataGenerationMethod, GenerationConfig, HeaderConfig
+from .models import Case
+from .specs import openapi
 
 __version__ = SCHEMATHESIS_VERSION
 

schemathesis/_hypothesis.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 import json
 import warnings
-from typing import Any, Callable, Generator, Mapping, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Callable, Generator, Mapping
 
 import hypothesis
 from hypothesis import Phase
@@ -24,7 +24,9 @@ from .models import APIOperation, Case, GenerationMetadata, TestPhase
 from .transports.content_types import parse_content_type
 from .transports.headers import has_invalid_characters, is_latin_1_encodable
 from .types import NotSet
-from .utils import GivenInput
+
+if TYPE_CHECKING:
+    from .utils import GivenInput
 
 # Forcefully initializes Hypothesis' global PRNG to avoid races that initilize it
 # if e.g. Schemathesis CLI is used with multiple workers
@@ -215,6 +217,7 @@ def _iter_coverage_cases(
     operation: APIOperation, data_generation_methods: list[DataGenerationMethod]
 ) -> Generator[Case, None, None]:
     from .specs.openapi.constants import LOCATION_TO_CONTAINER
+    from .specs.openapi.examples import find_in_responses, find_matching_in_responses
 
     ctx = coverage.CoverageContext(data_generation_methods=data_generation_methods)
     meta = GenerationMetadata(
@@ -222,8 +225,11 @@ def _iter_coverage_cases(
     )
     generators: dict[tuple[str, str], Generator[coverage.GeneratedValue, None, None]] = {}
     template: dict[str, Any] = {}
+    responses = find_in_responses(operation)
     for parameter in operation.iter_parameters():
         schema = parameter.as_json_schema(operation)
+        for value in find_matching_in_responses(responses, parameter.name):
+            schema.setdefault("examples", []).append(value)
         gen = coverage.cover_schema_iter(ctx, schema)
         value = next(gen, NOT_SET)
         if isinstance(value, NotSet):
@@ -274,7 +280,7 @@ def _iter_coverage_cases(
             yield case
 
 
-def find_invalid_headers(headers: Mapping) -> Generator[Tuple[str, str], None, None]:
+def find_invalid_headers(headers: Mapping) -> Generator[tuple[str, str], None, None]:
     for name, value in headers.items():
         if not is_latin_1_encodable(value) or has_invalid_characters(name, value):
             yield name, value
@@ -305,11 +311,11 @@ def add_non_serializable_mark(test: Callable, exc: SerializationNotPossible) ->
     test._schemathesis_non_serializable = exc  # type: ignore
 
 
-def get_non_serializable_mark(test: Callable) -> Optional[SerializationNotPossible]:
+def get_non_serializable_mark(test: Callable) -> SerializationNotPossible | None:
     return getattr(test, "_schemathesis_non_serializable", None)
 
 
-def get_invalid_regex_mark(test: Callable) -> Optional[SchemaError]:
+def get_invalid_regex_mark(test: Callable) -> SchemaError | None:
     return getattr(test, "_schemathesis_invalid_regex", None)
 
 
@@ -317,7 +323,7 @@ def add_invalid_regex_mark(test: Callable, exc: SchemaError) -> None:
     test._schemathesis_invalid_regex = exc  # type: ignore
 
 
-def get_invalid_example_headers_mark(test: Callable) -> Optional[dict[str, str]]:
+def get_invalid_example_headers_mark(test: Callable) -> dict[str, str] | None:
     return getattr(test, "_schemathesis_invalid_example_headers", None)
 
 

schemathesis/_override.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from .exceptions import UsageError
-from .parameters import ParameterSet
-from .types import GenericTest
 
 if TYPE_CHECKING:
     from .models import APIOperation
+    from .parameters import ParameterSet
+    from .types import GenericTest
 
 
 @dataclass
@@ -37,7 +37,7 @@ def _for_parameters(overridden: dict[str, str], defined: ParameterSet) -> dict[s
     return output
 
 
-def get_override_from_mark(test: GenericTest) -> Optional[CaseOverride]:
+def get_override_from_mark(test: GenericTest) -> CaseOverride | None:
     return getattr(test, "_schemathesis_override", None)
 
 

schemathesis/auths.py

@@ -21,12 +21,12 @@ from typing import (
 
 from .exceptions import UsageError
 from .filters import FilterSet, FilterValue, MatcherFunc, attach_filter_chain
-from .types import GenericTest
 
 if TYPE_CHECKING:
     import requests.auth
 
     from .models import APIOperation, Case
+    from .types import GenericTest
 
 DEFAULT_REFRESH_INTERVAL = 300
 AUTH_STORAGE_ATTRIBUTE_NAME = "_schemathesis_auth"

schemathesis/cli/__init__.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import base64
-import io
 import os
 import sys
 import traceback
@@ -41,38 +40,45 @@ from ..internal.datetime import current_datetime
 from ..internal.output import OutputConfig
 from ..internal.validation import file_exists
 from ..loaders import load_app, load_yaml
-from ..models import Case, CheckFunction
 from ..runner import events, prepare_hypothesis_settings, probes
 from ..specs.graphql import loaders as gql_loaders
 from ..specs.openapi import loaders as oas_loaders
 from ..stateful import Stateful
-from ..targets import Target
 from ..transports import RequestConfig
 from ..transports.auth import get_requests_auth
-from ..types import PathLike, RequestCert
 from . import callbacks, cassettes, output
 from .constants import DEFAULT_WORKERS, MAX_WORKERS, MIN_WORKERS, HealthCheck, Phase, Verbosity
 from .context import ExecutionContext, FileReportContext, ServiceReportContext
 from .debug import DebugOutputHandler
 from .handlers import EventHandler
 from .junitxml import JunitXMLHandler
-from .options import CsvChoice, CsvEnumChoice, CustomHelpMessageChoice, NotSet, OptionalInt
+from .options import CsvChoice, CsvEnumChoice, CustomHelpMessageChoice, OptionalInt
 from .sanitization import SanitizationHandler
 
 if TYPE_CHECKING:
+    import io
+
     import hypothesis
     import requests
 
+    from ..models import Case, CheckFunction
     from ..schemas import BaseSchema
     from ..service.client import ServiceClient
     from ..specs.graphql.schemas import GraphQLSchema
+    from ..targets import Target
+    from ..types import NotSet, PathLike, RequestCert
+
+
+__all__ = [
+    "EventHandler",
+]
 
 
 def _get_callable_names(items: tuple[Callable, ...]) -> tuple[str, ...]:
     return tuple(item.__name__ for item in items)
 
 
-CUSTOM_HANDLERS: list[Type[EventHandler]] = []
+CUSTOM_HANDLERS: list[type[EventHandler]] = []
 CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
 
 DEFAULT_CHECKS_NAMES = _get_callable_names(checks_module.DEFAULT_CHECKS)
@@ -114,14 +120,14 @@ def reset_checks() -> None:
     """Get checks list to their default state."""
     # Useful in tests
     checks_module.ALL_CHECKS = checks_module.DEFAULT_CHECKS + checks_module.OPTIONAL_CHECKS
-    CHECKS_TYPE.choices = _get_callable_names(checks_module.ALL_CHECKS) + ("all",)
+    CHECKS_TYPE.choices = (*_get_callable_names(checks_module.ALL_CHECKS), "all")
 
 
 def reset_targets() -> None:
     """Get targets list to their default state."""
     # Useful in tests
     targets_module.ALL_TARGETS = targets_module.DEFAULT_TARGETS + targets_module.OPTIONAL_TARGETS
-    TARGETS_TYPE.choices = _get_callable_names(targets_module.ALL_TARGETS) + ("all",)
+    TARGETS_TYPE.choices = (*_get_callable_names(targets_module.ALL_TARGETS), "all")
 
 
 @click.group(context_settings=CONTEXT_SETTINGS)
@@ -282,7 +288,7 @@ REPORT_TO_SERVICE = ReportToService()
     "workers_num",
     help="Number of concurrent workers for testing. Auto-adjusts if 'auto' is specified",
     type=CustomHelpMessageChoice(
-        ["auto"] + list(map(str, range(MIN_WORKERS, MAX_WORKERS + 1))),
+        ["auto", *list(map(str, range(MIN_WORKERS, MAX_WORKERS + 1)))],
         choices_repr=f"[auto, {MIN_WORKERS}-{MAX_WORKERS}]",
     ),
     default=str(DEFAULT_WORKERS),
@@ -318,7 +324,7 @@ REPORT_TO_SERVICE = ReportToService()
     "--fixups",
     help="Apply compatibility adjustments",
     multiple=True,
-    type=click.Choice(list(ALL_FIXUPS) + ["all"]),
+    type=click.Choice([*ALL_FIXUPS, "all"]),
     metavar="",
 )
 @group("API validation options")
@@ -2000,7 +2006,7 @@ def decide_color_output(ctx: click.Context, no_color: bool, force_color: bool) -
         ctx.color = False
 
 
-def add_option(*args: Any, cls: Type = click.Option, **kwargs: Any) -> None:
+def add_option(*args: Any, cls: type = click.Option, **kwargs: Any) -> None:
     """Add a new CLI option to `st run`."""
     run.params.append(cls(args, **kwargs))
 
@@ -2024,10 +2030,10 @@ def add_group(name: str, *, index: int | None = None) -> Group:
     return Group(name)
 
 
-def handler() -> Callable[[Type], None]:
+def handler() -> Callable[[type], None]:
     """Register a new CLI event handler."""
 
-    def _wrapper(cls: Type) -> None:
+    def _wrapper(cls: type) -> None:
         CUSTOM_HANDLERS.append(cls)
 
     return _wrapper

schemathesis/cli/callbacks.py

@@ -2,16 +2,16 @@ from __future__ import annotations
 
 import codecs
 import enum
+import operator
 import os
 import re
 import traceback
 from contextlib import contextmanager
-from functools import partial
+from functools import partial, reduce
 from typing import TYPE_CHECKING, Callable, Generator
 from urllib.parse import urlparse
 
 import click
-from click.types import LazyFile  # type: ignore
 
 from .. import exceptions, experimental, throttling
 from ..code_samples import CodeSampleStyle
@@ -24,12 +24,14 @@ from ..loaders import load_app
 from ..service.hosts import get_temporary_hosts_file
 from ..stateful import Stateful
 from ..transports.headers import has_invalid_characters, is_latin_1_encodable
-from ..types import PathLike
 from .cassettes import CassetteFormat
 from .constants import DEFAULT_WORKERS
 
 if TYPE_CHECKING:
     import hypothesis
+    from click.types import LazyFile  # type: ignore[attr-defined]
+
+    from ..types import PathLike
 
 INVALID_DERANDOMIZE_MESSAGE = (
     "`--hypothesis-derandomize` implies no database, so passing `--hypothesis-database` too is invalid."
@@ -339,7 +341,7 @@ def convert_experimental(
 
 
 def convert_checks(ctx: click.core.Context, param: click.core.Parameter, value: tuple[list[str]]) -> list[str]:
-    return sum(value, [])
+    return reduce(operator.iadd, value, [])
 
 
 def convert_code_sample_style(ctx: click.core.Context, param: click.core.Parameter, value: str) -> CodeSampleStyle:

schemathesis/cli/cassettes.py

@@ -16,7 +16,6 @@ import harfile
 
 from ..constants import SCHEMATHESIS_VERSION
 from ..runner import events
-from ..types import RequestCert
 from .handlers import EventHandler
 
 if TYPE_CHECKING:
@@ -25,6 +24,7 @@ if TYPE_CHECKING:
 
     from ..models import Request, Response
     from ..runner.serialization import SerializedCheck, SerializedInteraction
+    from ..types import RequestCert
     from .context import ExecutionContext
 
 # Wait until the worker terminates
@@ -163,13 +163,18 @@ def vcr_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: boo
         return "\n".join(f'      "{name}":\n{format_header_values(values)}' for name, values in headers.items())
 
     def format_check_message(message: str | None) -> str:
-        return "~" if message is None else f"{repr(message)}"
+        return "~" if message is None else f"{message!r}"
 
     def format_checks(checks: list[SerializedCheck]) -> str:
-        return "\n".join(
+        if not checks:
+            return "  checks: []"
+        items = "\n".join(
             f"    - name: '{check.name}'\n      status: '{check.value.name.upper()}'\n      message: {format_check_message(check.message)}"
             for check in checks
         )
+        return f"""
+  checks:
+{items}"""
 
     if preserve_exact_body_bytes:
 
@@ -235,9 +240,8 @@ http_interactions:"""
   correlation_id: '{item.correlation_id}'
   data_generation_method: '{interaction.data_generation_method.value}'
   phase: {phase}
-  elapsed: '{interaction.response.elapsed}'
+  elapsed: '{interaction.response.elapsed if interaction.response else 0}'
   recorded_at: '{interaction.recorded_at}'
-  checks:
 {format_checks(interaction.checks)}
   request:
     uri: '{interaction.request.uri}'
@@ -246,8 +250,9 @@ http_interactions:"""
 {format_headers(interaction.request.headers)}"""
                 )
                 format_request_body(stream, interaction.request)
-                stream.write(
-                    f"""
+                if interaction.response is not None:
+                    stream.write(
+                        f"""
   response:
     status:
       code: '{interaction.response.status_code}'
@@ -255,12 +260,16 @@ http_interactions:"""
     headers:
 {format_headers(interaction.response.headers)}
 """
-                )
-                format_response_body(stream, interaction.response)
-                stream.write(
-                    f"""
+                    )
+                    format_response_body(stream, interaction.response)
+                    stream.write(
+                        f"""
     http_version: '{interaction.response.http_version}'"""
-                )
+                    )
+                else:
+                    stream.write("""
+  response: null
+""")
                 current_id += 1
         else:
             break
@@ -300,11 +309,11 @@ def write_double_quoted(stream: IO, text: str) -> None:
                 if ch in Emitter.ESCAPE_REPLACEMENTS:
                     data = "\\" + Emitter.ESCAPE_REPLACEMENTS[ch]
                 elif ch <= "\xff":
-                    data = "\\x%02X" % ord(ch)
+                    data = f"\\x{ord(ch):02X}"
                 elif ch <= "\uffff":
-                    data = "\\u%04X" % ord(ch)
+                    data = f"\\u{ord(ch):04X}"
                 else:
-                    data = "\\U%08X" % ord(ch)
+                    data = f"\\U{ord(ch):08X}"
                 stream.write(data)
                 start = end + 1
         end += 1
@@ -326,25 +335,45 @@ def har_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: boo
             item = queue.get()
             if isinstance(item, Process):
                 for interaction in item.interactions:
-                    time = round(interaction.response.elapsed * 1000, 2)
-                    content_type = interaction.response.headers.get("Content-Type", [""])[0]
-                    content = harfile.Content(
-                        size=interaction.response.body_size or 0,
-                        mimeType=content_type,
-                        text=get_body(interaction.response.body) if interaction.response.body is not None else None,
-                        encoding="base64"
-                        if interaction.response.body is not None and preserve_exact_body_bytes
-                        else None,
-                    )
-                    http_version = f"HTTP/{interaction.response.http_version}"
                     query_params = urlparse(interaction.request.uri).query
                     if interaction.request.body is not None:
                         post_data = harfile.PostData(
-                            mimeType=content_type,
+                            mimeType=interaction.request.headers.get("Content-Type", [""])[0],
                             text=get_body(interaction.request.body),
                         )
                     else:
                         post_data = None
+                    if interaction.response is not None:
+                        content_type = interaction.response.headers.get("Content-Type", [""])[0]
+                        content = harfile.Content(
+                            size=interaction.response.body_size or 0,
+                            mimeType=content_type,
+                            text=get_body(interaction.response.body) if interaction.response.body is not None else None,
+                            encoding="base64"
+                            if interaction.response.body is not None and preserve_exact_body_bytes
+                            else None,
+                        )
+                        http_version = f"HTTP/{interaction.response.http_version}"
+                        response = harfile.Response(
+                            status=interaction.response.status_code,
+                            httpVersion=http_version,
+                            statusText=interaction.response.message,
+                            headers=[
+                                harfile.Record(name=name, value=values[0])
+                                for name, values in interaction.response.headers.items()
+                            ],
+                            cookies=_extract_cookies(interaction.response.headers.get("Set-Cookie", [])),
+                            content=content,
+                            headersSize=_headers_size(interaction.response.headers),
+                            bodySize=interaction.response.body_size or 0,
+                            redirectURL=interaction.response.headers.get("Location", [""])[0],
+                        )
+                        time = round(interaction.response.elapsed * 1000, 2)
+                    else:
+                        response = HARFILE_NO_RESPONSE
+                        time = 0
+                        http_version = ""
+
                     har.add_entry(
                         startedDateTime=interaction.recorded_at,
                         time=time,
@@ -365,26 +394,23 @@ def har_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: boo
                             bodySize=interaction.request.body_size or 0,
                             postData=post_data,
                         ),
-                        response=harfile.Response(
-                            status=interaction.response.status_code,
-                            httpVersion=http_version,
-                            statusText=interaction.response.message,
-                            headers=[
-                                harfile.Record(name=name, value=values[0])
-                                for name, values in interaction.response.headers.items()
-                            ],
-                            cookies=_extract_cookies(interaction.response.headers.get("Set-Cookie", [])),
-                            content=content,
-                            headersSize=_headers_size(interaction.response.headers),
-                            bodySize=interaction.response.body_size or 0,
-                            redirectURL=interaction.response.headers.get("Location", [""])[0],
-                        ),
+                        response=response,
                         timings=harfile.Timings(send=0, wait=0, receive=time, blocked=0, dns=0, connect=0, ssl=0),
                     )
             elif isinstance(item, Finalize):
                 break
 
 
+HARFILE_NO_RESPONSE = harfile.Response(
+    status=0,
+    httpVersion="",
+    statusText="",
+    headers=[],
+    cookies=[],
+    content=harfile.Content(),
+)
+
+
 def _headers_size(headers: dict[str, list[str]]) -> int:
     size = 0
     for name, values in headers.items():

schemathesis/cli/context.py

@@ -1,22 +1,23 @@
 from __future__ import annotations
 
-import os
 import shutil
 from dataclasses import dataclass, field
-from queue import Queue
 from typing import TYPE_CHECKING, Generator
 
 from ..code_samples import CodeSampleStyle
 from ..internal.deprecation import deprecated_property
 from ..internal.output import OutputConfig
-from ..internal.result import Result
-from ..runner.probes import ProbeRun
-from ..runner.serialization import SerializedTestResult
-from ..service.models import AnalysisResult
 
 if TYPE_CHECKING:
+    import os
+    from queue import Queue
+
     import hypothesis
 
+    from ..internal.result import Result
+    from ..runner.probes import ProbeRun
+    from ..runner.serialization import SerializedTestResult
+    from ..service.models import AnalysisResult
     from ..stateful.sink import StateMachineSink
 
 

schemathesis/cli/junitxml.py

@@ -11,13 +11,13 @@ from ..exceptions import RuntimeErrorType
 from ..internal.output import prepare_response_payload
 from ..models import Status
 from ..runner import events
-from ..runner.serialization import SerializedCheck, SerializedError
 from .handlers import EventHandler
 from .reporting import TEST_CASE_ID_TITLE, get_runtime_error_suggestion, group_by_case, split_traceback
 
 if TYPE_CHECKING:
     from click.utils import LazyFile
 
+    from ..runner.serialization import SerializedCheck, SerializedError
     from .context import ExecutionContext
 
 

schemathesis/cli/options.py

@@ -1,12 +1,15 @@
 from __future__ import annotations
 
-from enum import Enum
-from typing import Any, NoReturn
+from typing import TYPE_CHECKING, Any, NoReturn
 
 import click
 
 from ..constants import NOT_SET
-from ..types import NotSet
+
+if TYPE_CHECKING:
+    from enum import Enum
+
+    from ..types import NotSet
 
 
 class CustomHelpMessageChoice(click.Choice):
@@ -65,4 +68,4 @@ class OptionalInt(click.types.IntRange):
             int(value)
             return super().convert(value, param, ctx)
         except ValueError:
-            self.fail("%s is not a valid integer or None." % value, param, ctx)
+            self.fail(f"{value} is not a valid integer or None.", param, ctx)

schemathesis/cli/output/default.py

@@ -6,7 +6,6 @@ import shutil
 import textwrap
 import time
 from importlib import metadata
-from queue import Queue
 from types import GeneratorType
 from typing import TYPE_CHECKING, Any, Generator, Literal, cast
 
@@ -44,6 +43,8 @@ from ..handlers import EventHandler
 from ..reporting import TEST_CASE_ID_TITLE, get_runtime_error_suggestion, group_by_case, split_traceback
 
 if TYPE_CHECKING:
+    from queue import Queue
+
     import requests
 
 SPINNER_REPETITION_NUMBER = 10
@@ -372,7 +373,7 @@ def display_analysis(context: ExecutionContext) -> None:
         click.echo()
         if isinstance(analysis, AnalysisSuccess):
             click.secho(analysis.message, bold=True)
-            click.echo("\nAnalysis took: {:.2f}ms".format(analysis.elapsed))
+            click.echo(f"\nAnalysis took: {analysis.elapsed:.2f}ms")
             if analysis.extensions:
                 known = []
                 failed = []
@@ -417,8 +418,8 @@ def display_analysis(context: ExecutionContext) -> None:
             click.secho("Error\n", fg="red", bold=True)
             _display_service_network_error(response)
             click.echo()
-            return None
-        elif isinstance(exception, requests.RequestException):
+            return
+        if isinstance(exception, requests.RequestException):
             message, extras = extract_requests_exception_details(exception)
             suggestion = "Please check your network connection and try again."
             title = "Network Error"
@@ -649,7 +650,6 @@ def wait_for_report_handler(queue: Queue, title: str, timeout: float = service.W
 
 def create_spinner(repetitions: int) -> Generator[str, None, None]:
     """A simple spinner that yields its individual characters."""
-    assert repetitions > 0, "The number of repetitions should be greater than zero"
     while True:
         for ch in "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏":
             # Skip branch coverage, as it is not possible because of the assertion above

schemathesis/cli/reporting.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
 from itertools import groupby
-from typing import Callable, Generator, Iterator
+from typing import TYPE_CHECKING, Callable, Generator, Iterator
 
 import click
 
-from ..code_samples import CodeSampleStyle
 from ..exceptions import RuntimeErrorType
 from ..runner.serialization import SerializedCheck, deduplicate_failures
 
+if TYPE_CHECKING:
+    from ..code_samples import CodeSampleStyle
+
 TEST_CASE_ID_TITLE = "Test Case ID"
 
 

schemathesis/code_samples.py

@@ -6,11 +6,12 @@ from shlex import quote
 from typing import TYPE_CHECKING
 
 from .constants import SCHEMATHESIS_TEST_CASE_HEADER
-from .types import Headers
 
 if TYPE_CHECKING:
     from requests.structures import CaseInsensitiveDict
 
+    from .types import Headers
+
 
 @lru_cache
 def get_excluded_headers() -> CaseInsensitiveDict:
@@ -120,9 +121,9 @@ def _generate_requests(
     url = _escape_single_quotes(url)
     command = f"requests.{method.lower()}('{url}'"
     if body:
-        command += f", data={repr(body)}"
+        command += f", data={body!r}"
     if headers:
-        command += f", headers={repr(headers)}"
+        command += f", headers={headers!r}"
     if not verify:
         command += ", verify=False"
     command += ")"

schemathesis/exceptions.py

@@ -5,21 +5,22 @@ import re
 import traceback
 from dataclasses import dataclass, field
 from hashlib import sha1
-from json import JSONDecodeError
-from types import TracebackType
 from typing import TYPE_CHECKING, Any, Callable, Generator, NoReturn
 
 from .constants import SERIALIZERS_SUGGESTION_MESSAGE
-from .failures import FailureContext
 from .internal.output import truncate_json
 
 if TYPE_CHECKING:
+    from json import JSONDecodeError
+    from types import TracebackType
+
     import hypothesis.errors
     from graphql.error import GraphQLFormattedError
     from jsonschema import RefResolutionError, ValidationError
     from jsonschema import SchemaError as JsonSchemaError
     from requests import RequestException
 
+    from .failures import FailureContext
     from .transports.responses import GenericResponse