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

schemathesis/cli/output/short.py

@@ -1,6 +1,7 @@
 import click
 
 from ...runner import events
+from ...stateful import events as stateful_events
 from ..context import ExecutionContext
 from ..handlers import EventHandler
 from . import default
@@ -15,7 +16,13 @@ def handle_after_execution(context: ExecutionContext, event: events.AfterExecuti
     context.operations_processed += 1
     context.results.append(event.result)
     context.hypothesis_output.extend(event.hypothesis_output)
-    default.display_execution_result(context, event)
+    default.display_execution_result(context, event.status.value)
+
+
+def handle_stateful_event(context: ExecutionContext, event: events.StatefulEvent) -> None:
+    if isinstance(event.data, stateful_events.RunStarted):
+        click.echo()
+    default.handle_stateful_event(context, event)
 
 
 class ShortOutputStyleHandler(EventHandler):
@@ -26,23 +33,27 @@ class ShortOutputStyleHandler(EventHandler):
         """
         if isinstance(event, events.Initialized):
             default.handle_initialized(context, event)
-        if isinstance(event, events.BeforeProbing):
+        elif isinstance(event, events.BeforeProbing):
             default.handle_before_probing(context, event)
-        if isinstance(event, events.AfterProbing):
+        elif isinstance(event, events.AfterProbing):
             default.handle_after_probing(context, event)
-        if isinstance(event, events.BeforeAnalysis):
+        elif isinstance(event, events.BeforeAnalysis):
             default.handle_before_analysis(context, event)
-        if isinstance(event, events.AfterAnalysis):
+        elif isinstance(event, events.AfterAnalysis):
             default.handle_after_analysis(context, event)
-        if isinstance(event, events.BeforeExecution):
+        elif isinstance(event, events.BeforeExecution):
             handle_before_execution(context, event)
-        if isinstance(event, events.AfterExecution):
+        elif isinstance(event, events.AfterExecution):
             handle_after_execution(context, event)
-        if isinstance(event, events.Finished):
+        elif isinstance(event, events.Finished):
             if context.operations_count == context.operations_processed:
                 click.echo()
             default.handle_finished(context, event)
-        if isinstance(event, events.Interrupted):
+        elif isinstance(event, events.Interrupted):
             default.handle_interrupted(context, event)
-        if isinstance(event, events.InternalError):
+        elif isinstance(event, events.InternalError):
             default.handle_internal_error(context, event)
+        elif isinstance(event, events.StatefulEvent):
+            handle_stateful_event(context, event)
+        elif isinstance(event, events.AfterStatefulExecution):
+            default.handle_after_stateful_execution(context, event)

schemathesis/cli/sanitization.py

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

schemathesis/code_samples.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from enum import Enum
 from functools import lru_cache
 from shlex import quote

schemathesis/constants.py

@@ -1,4 +1,5 @@
 from importlib import metadata
+
 from .types import NotSet
 
 try:

schemathesis/contrib/openapi/__init__.py

@@ -1,4 +1,4 @@
-from . import formats, fill_missing_examples
+from . import fill_missing_examples, formats
 
 
 def install() -> None:

schemathesis/contrib/openapi/fill_missing_examples.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
+
 from typing import TYPE_CHECKING
+
 from ...hooks import HookContext, register, unregister
 
 if TYPE_CHECKING:

schemathesis/contrib/openapi/formats/uuid.py

@@ -3,9 +3,10 @@ FORMAT_NAME = "uuid"
 
 
 def install() -> None:
-    from ....specs import openapi
     from hypothesis import strategies as st
 
+    from ....specs import openapi
+
     openapi.format(FORMAT_NAME, st.uuids().map(str))
 
 

schemathesis/contrib/unique_data.py

@@ -6,9 +6,10 @@ from typing import TYPE_CHECKING
 from ..hooks import HookContext, register, unregister
 
 if TYPE_CHECKING:
-    from ..models import Case
     from hypothesis import strategies as st
 
+    from ..models import Case
+
 
 def install() -> None:
     warnings.warn(

schemathesis/exceptions.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
+
 import enum
-import json
 import re
 import traceback
 from dataclasses import dataclass, field
@@ -11,14 +11,17 @@ 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:
     import hypothesis.errors
-    from jsonschema import RefResolutionError, ValidationError, SchemaError as JsonSchemaError
-    from .transports.responses import GenericResponse
     from graphql.error import GraphQLFormattedError
+    from jsonschema import RefResolutionError, ValidationError
+    from jsonschema import SchemaError as JsonSchemaError
     from requests import RequestException
 
+    from .transports.responses import GenericResponse
+
 
 class CheckFailed(AssertionError):
     """Custom error type to distinguish from arbitrary AssertionError that may happen in the dependent libraries."""
@@ -97,52 +100,60 @@ def get_grouped_exception(prefix: str, *exceptions: AssertionError) -> type[Chec
     return _get_hashed_exception("GroupedException", f"{prefix}{message}")
 
 
-def get_server_error(status_code: int) -> type[CheckFailed]:
+def get_server_error(prefix: str, status_code: int) -> type[CheckFailed]:
     """Return new exception for the Internal Server Error cases."""
-    name = f"ServerError{status_code}"
+    name = f"ServerError{prefix}{status_code}"
     return get_exception(name)
 
 
-def get_status_code_error(status_code: int) -> type[CheckFailed]:
+def get_status_code_error(prefix: str, status_code: int) -> type[CheckFailed]:
     """Return new exception for an unexpected status code."""
-    name = f"StatusCodeError{status_code}"
+    name = f"StatusCodeError{prefix}{status_code}"
     return get_exception(name)
 
 
-def get_response_type_error(expected: str, received: str) -> type[CheckFailed]:
+def get_response_type_error(prefix: str, expected: str, received: str) -> type[CheckFailed]:
     """Return new exception for an unexpected response type."""
-    name = f"SchemaValidationError{expected}_{received}"
+    name = f"SchemaValidationError{prefix}{expected}_{received}"
     return get_exception(name)
 
 
-def get_malformed_media_type_error(media_type: str) -> type[CheckFailed]:
-    name = f"MalformedMediaType{media_type}"
+def get_malformed_media_type_error(prefix: str, media_type: str) -> type[CheckFailed]:
+    name = f"MalformedMediaType{prefix}{media_type}"
     return get_exception(name)
 
 
-def get_missing_content_type_error() -> type[CheckFailed]:
+def get_missing_content_type_error(prefix: str) -> type[CheckFailed]:
     """Return new exception for a missing Content-Type header."""
-    return get_exception("MissingContentTypeError")
+    return get_exception(f"MissingContentTypeError{prefix}")
 
 
-def get_schema_validation_error(exception: ValidationError) -> type[CheckFailed]:
+def get_schema_validation_error(prefix: str, exception: ValidationError) -> type[CheckFailed]:
     """Return new exception for schema validation error."""
-    return _get_hashed_exception("SchemaValidationError", str(exception))
+    return _get_hashed_exception(f"SchemaValidationError{prefix}", str(exception))
 
 
-def get_response_parsing_error(exception: JSONDecodeError) -> type[CheckFailed]:
+def get_response_parsing_error(prefix: str, exception: JSONDecodeError) -> type[CheckFailed]:
     """Return new exception for response parsing error."""
-    return _get_hashed_exception("ResponseParsingError", str(exception))
+    return _get_hashed_exception(f"ResponseParsingError{prefix}", str(exception))
 
 
-def get_headers_error(message: str) -> type[CheckFailed]:
+def get_headers_error(prefix: str, message: str) -> type[CheckFailed]:
     """Return new exception for missing headers."""
-    return _get_hashed_exception("MissingHeadersError", message)
+    return _get_hashed_exception(f"MissingHeadersError{prefix}", message)
+
 
+def get_negative_rejection_error(prefix: str, status: int) -> type[CheckFailed]:
+    return _get_hashed_exception(f"AcceptedNegativeDataError{prefix}", str(status))
 
-def get_timeout_error(deadline: float | int) -> type[CheckFailed]:
+
+def get_use_after_free_error(free: str) -> type[CheckFailed]:
+    return _get_hashed_exception("UseAfterFreeError", free)
+
+
+def get_timeout_error(prefix: str, deadline: float | int) -> type[CheckFailed]:
     """Request took too long."""
-    return _get_hashed_exception("TimeoutError", str(deadline))
+    return _get_hashed_exception(f"TimeoutError{prefix}", str(deadline))
 
 
 def get_unexpected_graphql_response_error(type_: type) -> type[CheckFailed]:
@@ -158,7 +169,7 @@ def get_grouped_graphql_error(errors: list[GraphQLFormattedError]) -> type[Check
         if "locations" in error:
             message += ";locations:"
             for location in sorted(error["locations"]):
-                message += f"({location['line'],location['column']})"
+                message += f"({location['line'], location['column']})"
         if "path" in error:
             message += ";path:"
             for chunk in error["path"]:
@@ -196,7 +207,7 @@ class OperationSchemaError(Exception):
             message = "Invalid schema definition"
         error_path = " -> ".join(str(entry) for entry in error.path) or "[root]"
         message += f"\n\nLocation:\n    {error_path}"
-        instance = truncated_json(error.instance)
+        instance = truncate_json(error.instance)
         message += f"\n\nProblematic definition:\n{instance}"
         message += "\n\nError details:\n    "
         # This default message contains the instance which we already printed
@@ -289,39 +300,6 @@ class InvalidHeadersExample(OperationSchemaError):
         return cls(message)
 
 
-def truncated_json(data: Any, max_lines: int = 10, max_width: int = 80) -> str:
-    # Convert JSON to string with indentation
-    indent = 4
-    serialized = json.dumps(data, indent=indent)
-
-    # Split string by lines
-
-    lines = [line[: max_width - 3] + "..." if len(line) > max_width else line for line in serialized.split("\n")]
-
-    if len(lines) <= max_lines:
-        return "\n".join(lines)
-
-    truncated_lines = lines[: max_lines - 1]
-    indentation = " " * indent
-    truncated_lines.append(f"{indentation}// Output truncated...")
-    truncated_lines.append(lines[-1])
-
-    return "\n".join(truncated_lines)
-
-
-MAX_PAYLOAD_SIZE = 512
-
-
-def prepare_response_payload(payload: str, max_size: int = MAX_PAYLOAD_SIZE) -> str:
-    if payload.endswith("\r\n"):
-        payload = payload[:-2]
-    elif payload.endswith("\n"):
-        payload = payload[:-1]
-    if len(payload) > max_size:
-        payload = payload[:max_size] + " // Output truncated..."
-    return payload
-
-
 class DeadlineExceeded(Exception):
     """Test took too long to run."""
 
@@ -541,7 +519,7 @@ def remove_ssl_line_number(text: str) -> str:
 
 
 def extract_requests_exception_details(exc: RequestException) -> tuple[str, list[str]]:
-    from requests.exceptions import SSLError, ConnectionError, ChunkedEncodingError
+    from requests.exceptions import ChunkedEncodingError, ConnectionError, SSLError
     from urllib3.exceptions import MaxRetryError
 
     if isinstance(exc, SSLError):
@@ -552,11 +530,14 @@ def extract_requests_exception_details(exc: RequestException) -> tuple[str, list
         message = "Connection failed"
         inner = exc.args[0]
         if isinstance(inner, MaxRetryError) and inner.reason is not None:
-            arg = str(inner.reason.args[0])
-            if ":" not in arg:
-                reason = arg
+            arg = inner.reason.args[0]
+            if isinstance(arg, str):
+                if ":" not in arg:
+                    reason = arg
+                else:
+                    _, reason = arg.split(":", maxsplit=1)
             else:
-                _, reason = arg.split(":", maxsplit=1)
+                reason = f"Max retries exceeded with url: {inner.url}"
             extra = [reason.strip()]
         else:
             extra = [" ".join(map(str, inner.args))]

schemathesis/experimental/__init__.py

@@ -79,3 +79,17 @@ SCHEMA_ANALYSIS = GLOBAL_EXPERIMENTS.create_experiment(
     description="Analyzing API schemas via Schemathesis.io",
     discussion_url="https://github.com/schemathesis/schemathesis/discussions/2056",
 )
+STATEFUL_TEST_RUNNER = GLOBAL_EXPERIMENTS.create_experiment(
+    name="stateful-test-runner",
+    verbose_name="New Stateful Test Runner",
+    env_var="STATEFUL_TEST_RUNNER",
+    description="State machine-based runner for stateful tests in CLI",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/2262",
+)
+STATEFUL_ONLY = GLOBAL_EXPERIMENTS.create_experiment(
+    name="stateful-only",
+    verbose_name="Stateful Only",
+    env_var="STATEFUL_ONLY",
+    description="Run only stateful tests",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/2262",
+)

schemathesis/extra/_aiohttp.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import asyncio
 
 from aiohttp import web

schemathesis/extra/_server.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import threading
 from time import sleep
 from typing import Any, Callable

schemathesis/extra/pytest_plugin.py

@@ -3,19 +3,18 @@ from __future__ import annotations
 import unittest
 from contextlib import contextmanager
 from functools import partial
-from typing import Any, Callable, Generator, Type, TypeVar, cast
+from typing import Any, Callable, Generator, Type, cast
 
 import pytest
 from _pytest import fixtures, nodes
 from _pytest.config import hookimpl
 from _pytest.fixtures import FuncFixtureInfo
-from _pytest.nodes import Node
 from _pytest.python import Class, Function, FunctionDefinition, Metafunc, Module, PyCollector
 from hypothesis import reporting
 from hypothesis.errors import InvalidArgument, Unsatisfiable
 from jsonschema.exceptions import SchemaError
 
-from .._dependency_versions import IS_PYTEST_ABOVE_7, IS_PYTEST_ABOVE_8, IS_PYTEST_ABOVE_54
+from .._dependency_versions import IS_PYTEST_ABOVE_7, IS_PYTEST_ABOVE_8
 from .._override import get_override_from_mark
 from ..constants import (
     GIVEN_AND_EXPLICIT_EXAMPLES_ERROR_MESSAGE,
@@ -43,14 +42,6 @@ from ..utils import (
     validate_given_args,
 )
 
-T = TypeVar("T", bound=Node)
-
-
-def create(cls: type[T], *args: Any, **kwargs: Any) -> T:
-    if IS_PYTEST_ABOVE_54:
-        return cls.from_parent(*args, **kwargs)  # type: ignore
-    return cls(*args, **kwargs)
-
 
 class SchemathesisFunction(Function):
     def __init__(
@@ -155,7 +146,9 @@ class SchemathesisCase(PyCollector):
                 name += f"[{error.full_path}]"
 
         cls = self._get_class_parent()
-        definition: FunctionDefinition = create(FunctionDefinition, name=self.name, parent=self.parent, callobj=funcobj)
+        definition: FunctionDefinition = FunctionDefinition.from_parent(
+            name=self.name, parent=self.parent, callobj=funcobj
+        )
         fixturemanager = self.session._fixturemanager
         fixtureinfo = fixturemanager.getfixtureinfo(definition, funcobj, cls)
 
@@ -166,8 +159,7 @@ class SchemathesisCase(PyCollector):
             funcobj = partial(funcobj, self.parent.obj)
 
         if not metafunc._calls:
-            yield create(
-                SchemathesisFunction,
+            yield SchemathesisFunction.from_parent(
                 name=name,
                 parent=self.parent,
                 callobj=funcobj,
@@ -181,10 +173,9 @@ class SchemathesisCase(PyCollector):
             fixtureinfo.prune_dependency_tree()
             for callspec in metafunc._calls:
                 subname = f"{name}[{callspec.id}]"
-                yield create(
-                    SchemathesisFunction,
+                yield SchemathesisFunction.from_parent(
+                    self.parent,
                     name=subname,
-                    parent=self.parent,
                     callspec=callspec,
                     callobj=funcobj,
                     fixtureinfo=fixtureinfo,
@@ -236,7 +227,7 @@ def pytest_pycollect_makeitem(collector: nodes.Collector, name: str, obj: Any) -
     """Switch to a different collector if the test is parametrized marked by schemathesis."""
     outcome = yield
     if is_schemathesis_test(obj):
-        outcome.force_result(create(SchemathesisCase, parent=collector, test_function=obj, name=name))
+        outcome.force_result(SchemathesisCase.from_parent(collector, test_function=obj, name=name))
     else:
         outcome.get_result()
 
@@ -261,7 +252,7 @@ def skip_unnecessary_hypothesis_output() -> Generator:
         yield
 
 
-@hookimpl(hookwrapper=True)
+@hookimpl(wrapper=True)
 def pytest_pyfunc_call(pyfuncitem):  # type:ignore
     """It is possible to have a Hypothesis exception in runtime.
 
@@ -278,10 +269,9 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
 
     __tracebackhide__ = True
     if isinstance(pyfuncitem, SchemathesisFunction):
-        with skip_unnecessary_hypothesis_output():
-            outcome = yield
         try:
-            outcome.get_result()
+            with skip_unnecessary_hypothesis_output():
+                yield
         except InvalidArgument as exc:
             if "Inconsistent args" in str(exc) and "@example()" in str(exc):
                 raise UsageError(GIVEN_AND_EXPLICIT_EXAMPLES_ERROR_MESSAGE) from None
@@ -316,5 +306,4 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
         if invalid_headers is not None:
             raise InvalidHeadersExample.from_headers(invalid_headers) from None
     else:
-        outcome = yield
-        outcome.get_result()
+        yield

schemathesis/failures.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
+
 import textwrap
 from dataclasses import dataclass
 from json import JSONDecodeError
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
+
+from schemathesis.internal.output import OutputConfig
 
 if TYPE_CHECKING:
     from graphql.error import GraphQLFormattedError
@@ -41,16 +44,27 @@ class ValidationErrorContext(FailureContext):
         return ("/".join(map(str, self.schema_path)),)
 
     @classmethod
-    def from_exception(cls, exc: ValidationError) -> ValidationErrorContext:
-        from .exceptions import truncated_json
-
-        schema = textwrap.indent(truncated_json(exc.schema, max_lines=20), prefix="    ")
-        value = textwrap.indent(truncated_json(exc.instance, max_lines=20), prefix="    ")
-        message = f"{exc.message}\n\nSchema:\n\n{schema}\n\nValue:\n\n{value}"
+    def from_exception(
+        cls, exc: ValidationError, *, output_config: OutputConfig | None = None
+    ) -> ValidationErrorContext:
+        from .internal.output import truncate_json
+
+        output_config = OutputConfig.from_parent(output_config, max_lines=20)
+        schema = textwrap.indent(truncate_json(exc.schema, config=output_config), prefix="    ")
+        value = textwrap.indent(truncate_json(exc.instance, config=output_config), prefix="    ")
+        schema_path = list(exc.absolute_schema_path)
+        if len(schema_path) > 1:
+            # Exclude the last segment, which is already in the schema
+            schema_title = "Schema at "
+            for segment in schema_path[:-1]:
+                schema_title += f"/{segment}"
+        else:
+            schema_title = "Schema"
+        message = f"{exc.message}\n\n{schema_title}:\n\n{schema}\n\nValue:\n\n{value}"
         return cls(
             message=message,
             validation_message=exc.message,
-            schema_path=list(exc.absolute_schema_path),
+            schema_path=schema_path,
             schema=exc.schema,
             instance_path=list(exc.absolute_path),
             instance=exc.instance,
@@ -117,6 +131,26 @@ class UndefinedContentType(FailureContext):
     type: str = "undefined_content_type"
 
 
+@dataclass(repr=False)
+class AcceptedNegativeData(FailureContext):
+    """Response with negative data was accepted."""
+
+    message: str
+    title: str = "Accepted negative data"
+    type: str = "accepted_negative_data"
+
+
+@dataclass(repr=False)
+class UseAfterFree(FailureContext):
+    """Resource was used after a successful DELETE operation on it."""
+
+    message: str
+    free: str
+    usage: str
+    title: str = "Use after free"
+    type: str = "use_after_free"
+
+
 @dataclass(repr=False)
 class UndefinedStatusCode(FailureContext):
     """Response has a status code that is not defined in the schema."""

schemathesis/filters.py

@@ -1,11 +1,12 @@
 """Filtering system that allows users to filter API operations based on certain criteria."""
 
 from __future__ import annotations
+
 import re
 from dataclasses import dataclass, field
 from functools import partial
 from types import SimpleNamespace
-from typing import TYPE_CHECKING, Callable, List, Union, Protocol
+from typing import TYPE_CHECKING, Callable, List, Protocol, Union
 
 from .exceptions import UsageError
 

schemathesis/fixups/__init__.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from typing import Iterable
 
 from . import fast_api, utf8_bom

schemathesis/fixups/fast_api.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
+
 from typing import Any
 
-from ..hooks import HookContext
+from ..hooks import HookContext, register, unregister
 from ..hooks import is_installed as global_is_installed
-from ..hooks import register, unregister
 from ..internal.jsonschema import traverse_schema
 
 

schemathesis/fixups/utf8_bom.py

@@ -1,9 +1,8 @@
 from typing import TYPE_CHECKING
 
 from ..constants import BOM_MARK
-from ..hooks import HookContext
+from ..hooks import HookContext, register, unregister
 from ..hooks import is_installed as global_is_installed
-from ..hooks import register, unregister
 
 if TYPE_CHECKING:
     from ..models import Case

schemathesis/generation/__init__.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
+
 import random
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Union, Iterable, TYPE_CHECKING
+from typing import TYPE_CHECKING, Iterable, Union
 
 if TYPE_CHECKING:
     from hypothesis.strategies import SearchStrategy

schemathesis/hooks.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import inspect
 from collections import defaultdict
 from copy import deepcopy
@@ -7,11 +8,12 @@ from enum import Enum, unique
 from functools import partial
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, DefaultDict, cast
 
-from .types import GenericTest
 from .internal.deprecation import deprecated_property
+from .types import GenericTest
 
 if TYPE_CHECKING:
     from hypothesis import strategies as st
+
     from .models import APIOperation, Case
     from .schemas import BaseSchema
     from .transports.responses import GenericResponse

schemathesis/internal/copy.py

@@ -2,12 +2,28 @@ from typing import Any
 
 
 def fast_deepcopy(value: Any) -> Any:
-    """A specialized version of `deepcopy` that copies only `dict` and `list`.
+    """A specialized version of `deepcopy` that copies only `dict` and `list` and does unrolling.
 
     It is on average 3x faster than `deepcopy` and given the amount of calls, it is an important optimization.
     """
     if isinstance(value, dict):
-        return {key: fast_deepcopy(v) for key, v in value.items()}
+        return {
+            k1: (
+                {k2: fast_deepcopy(v2) for k2, v2 in v1.items()}
+                if isinstance(v1, dict)
+                else [fast_deepcopy(v2) for v2 in v1]
+                if isinstance(v1, list)
+                else v1
+            )
+            for k1, v1 in value.items()
+        }
     if isinstance(value, list):
-        return [fast_deepcopy(v) for v in value]
+        return [
+            {k2: fast_deepcopy(v2) for k2, v2 in v1.items()}
+            if isinstance(v1, dict)
+            else [fast_deepcopy(v2) for v2 in v1]
+            if isinstance(v1, list)
+            else v1
+            for v1 in value
+        ]
     return value

schemathesis/internal/deprecation.py

@@ -1,5 +1,5 @@
 import warnings
-from typing import Callable, Any
+from typing import Any, Callable
 
 
 def _warn_deprecation(*, kind: str, thing: str, removed_in: str, replacement: str) -> None:

schemathesis/internal/jsonschema.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from typing import overload, Dict, Union, Any, List, Callable
+
+from typing import Any, Callable, Dict, List, Union, overload
 
 JsonValue = Union[Dict[str, Any], List, str, float, int]