schemathesis 3.35.4__py3-none-any.whl → 3.36.0__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/checks.py

@@ -15,11 +15,12 @@ from .specs.openapi.checks import (
 )
 
 if TYPE_CHECKING:
-    from .models import Case, CheckFunction
+    from .internal.checks import CheckContext, CheckFunction
+    from .models import Case
     from .transports.responses import GenericResponse
 
 
-def not_a_server_error(response: GenericResponse, case: Case) -> bool | None:
+def not_a_server_error(ctx: CheckContext, response: GenericResponse, case: Case) -> bool | None:
     """A check to verify that the response is not a server-side error."""
     from .specs.graphql.schemas import GraphQLCase
     from .specs.graphql.validation import validate_graphql_response
@@ -64,14 +65,16 @@ def register(check: CheckFunction) -> CheckFunction:
     .. code-block:: python
 
         @schemathesis.check
-        def new_check(response, case):
+        def new_check(ctx, response, case):
             # some awesome assertions!
             ...
     """
     from . import cli
+    from .internal.checks import wrap_check
 
+    _check = wrap_check(check)
     global ALL_CHECKS
 
-    ALL_CHECKS += (check,)
-    cli.CHECKS_TYPE.choices += (check.__name__,)  # type: ignore
+    ALL_CHECKS += (_check,)
+    cli.CHECKS_TYPE.choices += (_check.__name__,)  # type: ignore
     return check

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)
@@ -98,13 +104,6 @@ DEPRECATED_SHOW_ERROR_TRACEBACKS_OPTION_WARNING = (
     "Warning: Option `--show-errors-tracebacks` is deprecated and will be removed in Schemathesis 4.0. "
     "Use `--show-trace` instead"
 )
-DEPRECATED_CONTRIB_UNIQUE_DATA_OPTION_WARNING = (
-    "The `--contrib-unique-data` CLI option and the corresponding `schemathesis.contrib.unique_data` hook "
-    "are **DEPRECATED**. The concept of this feature does not fit the core principles of Hypothesis where "
-    "strategies are configurable on a per-example basis but this feature implies uniqueness across examples. "
-    "This leads to cryptic error messages about external state and flaky test runs, "
-    "therefore it will be removed in Schemathesis 4.0"
-)
 CASSETTES_PATH_INVALID_USAGE_MESSAGE = "Can't use `--store-network-log` and `--cassette-path` simultaneously"
 COLOR_OPTIONS_INVALID_USAGE_MESSAGE = "Can't use `--no-color` and `--force-color` simultaneously"
 PHASES_INVALID_USAGE_MESSAGE = "Can't use `--hypothesis-phases` and `--hypothesis-no-phases` simultaneously"
@@ -114,14 +113,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 +281,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 +317,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")
@@ -433,7 +432,7 @@ REPORT_TO_SERVICE = ReportToService()
     "-A",
     type=click.Choice(["basic", "digest"], case_sensitive=False),
     default="basic",
-    help="Specify the authentication method",
+    help="Specify the authentication method. For custom authentication methods, see our Authentication documentation: https://schemathesis.readthedocs.io/en/stable/auth.html#custom-auth",
     show_default=True,
     metavar="",
 )
@@ -943,9 +942,6 @@ def run(
             entry for health_check in hypothesis_suppress_health_check for entry in health_check.as_hypothesis()
         ]
 
-    if contrib_unique_data:
-        click.secho(DEPRECATED_CONTRIB_UNIQUE_DATA_OPTION_WARNING, fg="yellow")
-
     if show_errors_tracebacks:
         click.secho(DEPRECATED_SHOW_ERROR_TRACEBACKS_OPTION_WARNING, fg="yellow")
         show_trace = show_errors_tracebacks
@@ -1154,8 +1150,6 @@ def run(
         else:
             _fixups.install(fixups)
 
-    if contrib_unique_data:
-        contrib.unique_data.install()
     if contrib_openapi_formats_uuid:
         contrib.openapi.formats.uuid.install()
     if contrib_openapi_fill_missing_examples:
@@ -1191,6 +1185,7 @@ def run(
         seed=hypothesis_seed,
         exit_first=exit_first,
         max_failures=max_failures,
+        unique_data=contrib_unique_data,
         dry_run=dry_run,
         store_interactions=cassette_path is not None,
         checks=selected_checks,
@@ -1315,6 +1310,7 @@ def into_event_stream(
     exit_first: bool,
     max_failures: int | None,
     rate_limit: str | None,
+    unique_data: bool,
     dry_run: bool,
     store_interactions: bool,
     stateful: Stateful | None,
@@ -1358,6 +1354,7 @@ def into_event_stream(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             checks=checks,
@@ -2000,7 +1997,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 +2021,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)