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

schemathesis/specs/openapi/examples.py

@@ -4,10 +4,9 @@ from contextlib import suppress
 from dataclasses import dataclass
 from functools import lru_cache
 from itertools import chain, cycle, islice
-from typing import TYPE_CHECKING, Any, Generator, Union, cast
+from typing import TYPE_CHECKING, Any, Generator, Iterator, Union, cast
 
 import requests
-from hypothesis.strategies import SearchStrategy
 from hypothesis_jsonschema import from_schema
 
 from ...constants import DEFAULT_RESPONSE_TIMEOUT
@@ -20,6 +19,8 @@ from .formats import STRING_FORMATS
 from .parameters import OpenAPIBody, OpenAPIParameter
 
 if TYPE_CHECKING:
+    from hypothesis.strategies import SearchStrategy
+
     from ...generation import GenerationConfig
 
 
@@ -77,6 +78,7 @@ def get_strategies_from_examples(
 
 def extract_top_level(operation: APIOperation[OpenAPIParameter, Case]) -> Generator[Example, None, None]:
     """Extract top-level parameter examples from `examples` & `example` fields."""
+    responses = find_in_responses(operation)
     for parameter in operation.iter_parameters():
         if "schema" in parameter.definition:
             definitions = [parameter.definition, *_expand_subschemas(parameter.definition["schema"])]
@@ -106,6 +108,10 @@ def extract_top_level(operation: APIOperation[OpenAPIParameter, Case]) -> Genera
                         yield ParameterExample(
                             container=LOCATION_TO_CONTAINER[parameter.location], name=parameter.name, value=value
                         )
+        for value in find_matching_in_responses(responses, parameter.name):
+            yield ParameterExample(
+                container=LOCATION_TO_CONTAINER[parameter.location], name=parameter.name, value=value
+            )
     for alternative in operation.body:
         alternative = cast(OpenAPIBody, alternative)
         if "schema" in alternative.definition:
@@ -349,3 +355,87 @@ def _produce_parameter_combinations(parameters: dict[str, dict[str, list]]) -> G
             }
             for container, variants in parameters.items()
         }
+
+
+def find_in_responses(operation: APIOperation) -> dict[str, list[dict[str, Any]]]:
+    """Find schema examples in responses."""
+    output: dict[str, list[dict[str, Any]]] = {}
+    for status_code, response in operation.definition.raw.get("responses", {}).items():
+        if not str(status_code).startswith("2"):
+            # Check only 2xx responses
+            continue
+        if isinstance(response, dict) and "$ref" in response:
+            _, response = operation.schema.resolver.resolve_in_scope(response, operation.definition.scope)  # type:ignore[attr-defined]
+        for media_type, definition in response.get("content", {}).items():
+            schema_ref = definition.get("schema", {}).get("$ref")
+            if schema_ref:
+                name = schema_ref.split("/")[-1]
+            else:
+                name = f"{status_code}/{media_type}"
+            for examples_field, example_field in (
+                ("examples", "example"),
+                ("x-examples", "x-example"),
+            ):
+                examples = definition.get(examples_field, {})
+                for example in examples.values():
+                    if "value" in example:
+                        output.setdefault(name, []).append(example["value"])
+                if example_field in definition:
+                    output.setdefault(name, []).append(definition[example_field])
+    return output
+
+
+NOT_FOUND = object()
+
+
+def find_matching_in_responses(examples: dict[str, list], param: str) -> Iterator[Any]:
+    """Find matching parameter examples."""
+    normalized = param.lower()
+    is_id_param = normalized.endswith("id")
+    # Extract values from response examples that match input parameters.
+    # E.g., for `GET /orders/{id}/`, use "id" or "orderId" from `Order` response
+    # as examples for the "id" path parameter.
+    for schema_name, schema_examples in examples.items():
+        for example in schema_examples:
+            if not isinstance(example, dict):
+                continue
+            # Unwrapping example from `{"item": [{...}]}`
+            if isinstance(example, dict) and len(example) == 1 and list(example)[0].lower() == schema_name.lower():
+                inner = list(example.values())[0]
+                if isinstance(inner, list):
+                    for sub_example in inner:
+                        found = _find_matching_in_responses(sub_example, schema_name, param, normalized, is_id_param)
+                        if found is not NOT_FOUND:
+                            yield found
+                    continue
+                example = inner
+            found = _find_matching_in_responses(example, schema_name, param, normalized, is_id_param)
+            if found is not NOT_FOUND:
+                yield found
+
+
+def _find_matching_in_responses(
+    example: dict[str, Any], schema_name: str, param: str, normalized: str, is_id_param: bool
+) -> Any:
+    # Check for exact match
+    if param in example:
+        return example[param]
+
+    # Check for case-insensitive match
+    for key in example:
+        if key.lower() == normalized:
+            return example[key]
+    else:
+        # If no match found and it's an ID parameter, try additional checks
+        if is_id_param:
+            # Check for 'id' if parameter is '{something}Id'
+            if "id" in example:
+                return example["id"]
+            # Check for '{schemaName}Id' or '{schemaName}_id'
+            if normalized == "id" or normalized.startswith(schema_name.lower()):
+                for key in (schema_name, schema_name.lower()):
+                    for suffix in ("_id", "Id"):
+                        with_suffix = f"{key}{suffix}"
+                        if with_suffix in example:
+                            return example[with_suffix]
+    return NOT_FOUND

schemathesis/specs/openapi/expressions/__init__.py

@@ -11,6 +11,13 @@ from typing import Any
 from . import lexer, nodes, parser
 from .context import ExpressionContext
 
+__all__ = [
+    "lexer",
+    "nodes",
+    "parser",
+    "ExpressionContext",
+]
+
 
 def evaluate(expr: Any, context: ExpressionContext, evaluate_nested: bool = False) -> Any:
     """Evaluate runtime expression in context."""

schemathesis/specs/openapi/expressions/extractors.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
 
-import re
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import re
 
 
 @dataclass

schemathesis/specs/openapi/expressions/nodes.py

@@ -4,13 +4,15 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import Enum, unique
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from requests.structures import CaseInsensitiveDict
 
 from .. import references
-from .context import ExpressionContext
-from .extractors import Extractor
+
+if TYPE_CHECKING:
+    from .context import ExpressionContext
+    from .extractors import Extractor
 
 
 @dataclass

schemathesis/specs/openapi/links.py

@@ -10,22 +10,22 @@ from difflib import get_close_matches
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any, Generator, Literal, NoReturn, Sequence, TypedDict, Union, cast
 
-from jsonschema import RefResolver
-
 from ...constants import NOT_SET
 from ...internal.copy import fast_deepcopy
 from ...models import APIOperation, Case, TransitionId
-from ...parameters import ParameterSet
 from ...stateful import ParsedData, StatefulTest, UnresolvableLink
 from ...stateful.state_machine import Direction
-from ...types import NotSet
 from . import expressions
 from .constants import LOCATION_TO_CONTAINER
 from .parameters import OpenAPI20Body, OpenAPI30Body, OpenAPIParameter
 from .references import RECURSION_DEPTH_LIMIT, Unresolvable
 
 if TYPE_CHECKING:
+    from jsonschema import RefResolver
+
+    from ...parameters import ParameterSet
     from ...transports.responses import GenericResponse
+    from ...types import NotSet
 
 
 @dataclass(repr=False)

schemathesis/specs/openapi/loaders.py

@@ -9,7 +9,7 @@ from urllib.parse import urljoin
 
 from ... import experimental, fixups
 from ...code_samples import CodeSampleStyle
-from ...constants import NOT_SET, WAIT_FOR_SCHEMA_INTERVAL
+from ...constants import DEFAULT_RESPONSE_TIMEOUT, NOT_SET, WAIT_FOR_SCHEMA_INTERVAL
 from ...exceptions import SchemaError, SchemaErrorType
 from ...filters import filter_set_from_components
 from ...generation import (
@@ -163,6 +163,7 @@ def from_uri(
             interval=WAIT_FOR_SCHEMA_INTERVAL,
         )
         def _load_schema(_uri: str, **_kwargs: Any) -> requests.Response:
+            _kwargs.setdefault("timeout", DEFAULT_RESPONSE_TIMEOUT / 1000)
             return requests.get(_uri, **kwargs)
 
     else:
@@ -441,7 +442,7 @@ def _format_status_codes(status_codes: list[tuple[int, list[str | int]]]) -> str
     for status_code, path in status_codes:
         buffer.write(f" - {status_code} at schema['paths']")
         for chunk in path:
-            buffer.write(f"[{repr(chunk)}]")
+            buffer.write(f"[{chunk!r}]")
         buffer.write("['responses']\n")
     return buffer.getvalue().rstrip()
 
@@ -595,9 +596,9 @@ def from_wsgi(
 
 
 def get_loader_for_app(app: Any) -> Callable:
-    from starlette.applications import Starlette
+    from ...transports.asgi import is_asgi_app
 
-    if isinstance(app, Starlette):
+    if is_asgi_app(app):
         return from_asgi
     if app.__class__.__module__.startswith("aiohttp."):
         return from_aiohttp

schemathesis/specs/openapi/negative/__init__.py

@@ -2,17 +2,19 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from functools import lru_cache
-from typing import Any
+from typing import TYPE_CHECKING, Any
 from urllib.parse import urlencode
 
 import jsonschema
 from hypothesis import strategies as st
 from hypothesis_jsonschema import from_schema
 
-from ....generation import GenerationConfig
 from ..constants import ALL_KEYWORDS
 from .mutations import MutationContext
-from .types import Draw, Schema
+
+if TYPE_CHECKING:
+    from ....generation import GenerationConfig
+    from .types import Draw, Schema
 
 
 @dataclass

schemathesis/specs/openapi/negative/mutations.py

@@ -179,7 +179,7 @@ def remove_required_property(context: MutationContext, draw: Draw, schema: Schem
     else:
         candidate = draw(st.sampled_from(sorted(required)))
         enabled_properties = draw(st.shared(FeatureStrategy(), key="properties"))  # type: ignore
-        candidates = [candidate] + sorted([prop for prop in required if enabled_properties.is_enabled(prop)])
+        candidates = [candidate, *sorted([prop for prop in required if enabled_properties.is_enabled(prop)])]
         property_name = draw(st.sampled_from(candidates))
     required.remove(property_name)
     if not required:
@@ -226,9 +226,10 @@ def change_type(context: MutationContext, draw: Draw, schema: Schema) -> Mutatio
     candidate = draw(st.sampled_from(sorted(candidates)))
     candidates.remove(candidate)
     enabled_types = draw(st.shared(FeatureStrategy(), key="types"))  # type: ignore
-    remaining_candidates = [candidate] + sorted(
-        [candidate for candidate in candidates if enabled_types.is_enabled(candidate)]
-    )
+    remaining_candidates = [
+        candidate,
+        *sorted([candidate for candidate in candidates if enabled_types.is_enabled(candidate)]),
+    ]
     new_type = draw(st.sampled_from(remaining_candidates))
     schema["type"] = new_type
     prevent_unsatisfiable_schema(schema, new_type)

schemathesis/specs/openapi/parameters.py

@@ -2,13 +2,15 @@ from __future__ import annotations
 
 import json
 from dataclasses import dataclass
-from typing import Any, ClassVar, Iterable
+from typing import TYPE_CHECKING, Any, ClassVar, Iterable
 
 from ...exceptions import OperationSchemaError
-from ...models import APIOperation
 from ...parameters import Parameter
 from .converter import to_json_schema_recursive
 
+if TYPE_CHECKING:
+    from ...models import APIOperation
+
 
 @dataclass(eq=False)
 class OpenAPIParameter(Parameter):

schemathesis/specs/openapi/schemas.py

@@ -20,21 +20,18 @@ from typing import (
     Mapping,
     NoReturn,
     Sequence,
-    Type,
     TypeVar,
     cast,
 )
 from urllib.parse import urlsplit
 
 import jsonschema
-from hypothesis.strategies import SearchStrategy
 from packaging import version
 from requests.structures import CaseInsensitiveDict
 
 from ... import experimental, failures
 from ..._compat import MultipleFailures
 from ..._override import CaseOverride, check_no_override_mark, set_override_mark
-from ...auths import AuthStorage
 from ...constants import HTTP_METHODS, NOT_SET
 from ...exceptions import (
     InternalError,
@@ -54,10 +51,8 @@ from ...internal.result import Err, Ok, Result
 from ...models import APIOperation, Case, OperationDefinition
 from ...schemas import APIOperationMap, BaseSchema
 from ...stateful import Stateful, StatefulTest
-from ...stateful.state_machine import APIStateMachine
 from ...transports.content_types import is_json_media_type, parse_content_type
 from ...transports.responses import get_json
-from ...types import Body, Cookies, FormData, GenericTest, Headers, NotSet, PathParameters, Query
 from . import links, serialization
 from ._cache import OperationCache
 from ._hypothesis import get_case_strategy
@@ -83,7 +78,12 @@ from .security import BaseSecurityProcessor, OpenAPISecurityProcessor, SwaggerSe
 from .stateful import create_state_machine
 
 if TYPE_CHECKING:
+    from hypothesis.strategies import SearchStrategy
+
+    from ...auths import AuthStorage
+    from ...stateful.state_machine import APIStateMachine
     from ...transports.responses import GenericResponse
+    from ...types import Body, Cookies, FormData, GenericTest, Headers, NotSet, PathParameters, Query
 
 SCHEMA_ERROR_MESSAGE = "Ensure that the definition complies with the OpenAPI specification"
 SCHEMA_PARSING_ERRORS = (KeyError, AttributeError, jsonschema.exceptions.RefResolutionError)
@@ -626,7 +626,7 @@ class BaseOpenAPISchema(BaseSchema):
         return operation.definition.raw.get("tags")
 
     @property
-    def validator_cls(self) -> Type[jsonschema.Validator]:
+    def validator_cls(self) -> type[jsonschema.Validator]:
         if self.spec_version.startswith("3.1") and experimental.OPEN_API_3_1.is_enabled:
             return jsonschema.Draft202012Validator
         return jsonschema.Draft4Validator
@@ -791,11 +791,10 @@ class BaseOpenAPISchema(BaseSchema):
 
 def _maybe_raise_one_or_more(errors: list[Exception]) -> None:
     if not errors:
-        return None
-    elif len(errors) == 1:
+        return
+    if len(errors) == 1:
         raise errors[0]
-    else:
-        raise MultipleFailures("\n\n".join(str(error) for error in errors), errors)
+    raise MultipleFailures("\n\n".join(str(error) for error in errors), errors)
 
 
 def _make_reference_key(scopes: list[str], reference: str) -> str:

schemathesis/specs/openapi/security.py

@@ -3,13 +3,15 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, ClassVar, Generator
+from typing import TYPE_CHECKING, Any, ClassVar, Generator
 
-from jsonschema import RefResolver
-
-from ...models import APIOperation
 from .parameters import OpenAPI20Parameter, OpenAPI30Parameter, OpenAPIParameter
 
+if TYPE_CHECKING:
+    from jsonschema import RefResolver
+
+    from ...models import APIOperation
+
 
 @dataclass
 class BaseSecurityProcessor:

schemathesis/specs/openapi/stateful/__init__.py

@@ -16,11 +16,11 @@ from .. import expressions
 from ..links import get_all_links
 from ..utils import expand_status_code
 from .statistic import OpenAPILinkStats
-from .types import FilterFunction, LinkName, StatusCode, TargetName
 
 if TYPE_CHECKING:
     from ....models import Case
     from ..schemas import BaseOpenAPISchema
+    from .types import FilterFunction, LinkName, StatusCode, TargetName
 
 
 class OpenAPIStateMachine(APIStateMachine):
@@ -193,7 +193,7 @@ def make_response_matcher(matchers: list[tuple[str, FilterFunction]]) -> Callabl
     return compare
 
 
-@lru_cache()
+@lru_cache
 def make_response_filter(status_code: str, all_status_codes: Iterator[str]) -> FilterFunction:
     """Create a filter for stored responses.
 

schemathesis/specs/openapi/stateful/statistic.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Iterator, List, Union
+from typing import TYPE_CHECKING, Iterator, Union
 
 from ....internal.copy import fast_deepcopy
 from ....stateful.statistic import TransitionStats
-from .types import AggregatedResponseCounter, LinkName, ResponseCounter, SourceName, StatusCode, TargetName
 
 if TYPE_CHECKING:
     from ....stateful import events
+    from .types import AggregatedResponseCounter, LinkName, ResponseCounter, SourceName, StatusCode, TargetName
 
 
 @dataclass
@@ -136,7 +136,7 @@ class OpenAPILinkStats(TransitionStats):
     def to_formatted_table(self, width: int) -> str:
         """Format the statistic as a table."""
         entries = list(self.iter_with_format())
-        lines: List[str | list[str]] = [HEADER, ""]
+        lines: list[str | list[str]] = [HEADER, ""]
         column_widths = [len(column) for column in HEADER]
         for entry in entries:
             if isinstance(entry.entry, Link):

schemathesis/specs/openapi/stateful/types.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
-from typing import Callable, Dict, TypedDict, Union
+from typing import TYPE_CHECKING, Callable, Dict, TypedDict, Union
 
-from ....stateful.state_machine import StepResult
+if TYPE_CHECKING:
+    from ....stateful.state_machine import StepResult
 
 StatusCode = str
 LinkName = str

schemathesis/stateful/__init__.py

@@ -5,15 +5,15 @@ import json
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Callable, Generator
 
-from .. import GenerationConfig
 from ..constants import NOT_SET
-from ..exceptions import OperationSchemaError
 from ..internal.result import Ok, Result
-from ..models import APIOperation, Case
 
 if TYPE_CHECKING:
     import hypothesis
 
+    from .. import GenerationConfig
+    from ..exceptions import OperationSchemaError
+    from ..models import APIOperation, Case
     from ..transports.responses import GenericResponse
     from .state_machine import APIStateMachine
 

schemathesis/stateful/config.py

@@ -21,7 +21,7 @@ def _default_checks_factory() -> tuple[CheckFunction, ...]:
     from ..checks import ALL_CHECKS
     from ..specs.openapi.checks import ensure_resource_availability, use_after_free
 
-    return ALL_CHECKS + (use_after_free, ensure_resource_availability)
+    return (*ALL_CHECKS, use_after_free, ensure_resource_availability)
 
 
 def _get_default_hypothesis_settings_kwargs() -> dict[str, Any]:

schemathesis/stateful/context.py

@@ -57,11 +57,11 @@ class RunnerContext:
     def current_scenario_status(self) -> events.ScenarioStatus:
         if self.current_step_status == events.StepStatus.SUCCESS:
             return events.ScenarioStatus.SUCCESS
-        elif self.current_step_status == events.StepStatus.FAILURE:
+        if self.current_step_status == events.StepStatus.FAILURE:
             return events.ScenarioStatus.FAILURE
-        elif self.current_step_status == events.StepStatus.ERROR:
+        if self.current_step_status == events.StepStatus.ERROR:
             return events.ScenarioStatus.ERROR
-        elif self.current_step_status == events.StepStatus.INTERRUPTED:
+        if self.current_step_status == events.StepStatus.INTERRUPTED:
             return events.ScenarioStatus.INTERRUPTED
         return events.ScenarioStatus.REJECTED
 

schemathesis/stateful/events.py

@@ -4,7 +4,7 @@ import time
 from dataclasses import asdict as _asdict
 from dataclasses import dataclass
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Type
+from typing import TYPE_CHECKING, Any
 
 from ..exceptions import format_exception
 
@@ -40,11 +40,11 @@ class RunStarted(StatefulEvent):
     """Before executing all scenarios."""
 
     started_at: float
-    state_machine: Type[APIStateMachine]
+    state_machine: type[APIStateMachine]
 
     __slots__ = ("state_machine", "timestamp", "started_at")
 
-    def __init__(self, *, state_machine: Type[APIStateMachine]) -> None:
+    def __init__(self, *, state_machine: type[APIStateMachine]) -> None:
         self.state_machine = state_machine
         self.started_at = time.time()
         self.timestamp = time.monotonic()

schemathesis/stateful/runner.py

@@ -4,13 +4,12 @@ import queue
 import threading
 from contextlib import contextmanager
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Generator, Iterator, Type
+from typing import TYPE_CHECKING, Any, Generator, Iterator
 
 import hypothesis
 import requests
 from hypothesis.control import current_build_context
 from hypothesis.errors import Flaky, Unsatisfiable
-from hypothesis.stateful import Rule
 
 from ..exceptions import CheckFailed
 from ..targets import TargetMetricCollector
@@ -20,6 +19,8 @@ from .context import RunnerContext
 from .validation import validate_response
 
 if TYPE_CHECKING:
+    from hypothesis.stateful import Rule
+
     from ..models import Case, CheckFunction
     from ..transports.responses import GenericResponse
     from .state_machine import APIStateMachine, Direction, StepResult
@@ -36,7 +37,7 @@ class StatefulTestRunner:
     """
 
     # State machine class to use
-    state_machine: Type[APIStateMachine]
+    state_machine: type[APIStateMachine]
     # Test runner configuration that defines the runtime behavior
     config: StatefulTestRunnerConfig = field(default_factory=StatefulTestRunnerConfig)
     # Event to stop the execution
@@ -105,7 +106,7 @@ def thread_manager(thread: threading.Thread) -> Generator[None, None, None]:
 
 def _execute_state_machine_loop(
     *,
-    state_machine: Type[APIStateMachine],
+    state_machine: type[APIStateMachine],
     event_queue: queue.Queue,
     config: StatefulTestRunnerConfig,
     stop_event: threading.Event,

schemathesis/stateful/sink.py

@@ -4,10 +4,10 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
 from . import events
-from .statistic import TransitionStats
 
 if TYPE_CHECKING:
     from ..models import Check
+    from .statistic import TransitionStats
 
 
 @dataclass

schemathesis/stateful/state_machine.py

@@ -4,7 +4,7 @@ import re
 import time
 from dataclasses import dataclass
 from functools import lru_cache
-from typing import TYPE_CHECKING, Any, ClassVar, Type
+from typing import TYPE_CHECKING, Any, ClassVar
 
 from hypothesis.errors import InvalidDefinition
 from hypothesis.stateful import RuleBasedStateMachine
@@ -16,7 +16,6 @@ from ..models import APIOperation, Case, CheckFunction
 from .config import _default_hypothesis_settings_factory
 from .runner import StatefulTestRunner, StatefulTestRunnerConfig
 from .sink import StateMachineSink
-from .statistic import TransitionStats
 
 if TYPE_CHECKING:
     import hypothesis
@@ -24,6 +23,7 @@ if TYPE_CHECKING:
 
     from ..schemas import BaseSchema
     from ..transports.responses import GenericResponse
+    from .statistic import TransitionStats
 
 
 @dataclass
@@ -64,7 +64,7 @@ class APIStateMachine(RuleBasedStateMachine):
 
     @classmethod
     @lru_cache
-    def _to_test_case(cls) -> Type:
+    def _to_test_case(cls) -> type:
         from . import run_state_machine_as_test
 
         class StateMachineTestCase(RuleBasedStateMachine.TestCase):
@@ -97,7 +97,7 @@ class APIStateMachine(RuleBasedStateMachine):
 
     def _add_result_to_targets(self, targets: tuple[str, ...], result: StepResult | None) -> None:
         if result is None:
-            return None
+            return
         target = self._get_target_for_result(result)
         if target is not None:
             super()._add_result_to_targets((target,), result)
@@ -310,7 +310,7 @@ def _print_case(case: Case, kwargs: dict[str, Any]) -> str:
     headers.update(kwargs.get("headers", {}))
     case.headers = headers
     data = [
-        f"{name}={repr(getattr(case, name))}"
+        f"{name}={getattr(case, name)!r}"
         for name in ("path_parameters", "headers", "cookies", "query", "body", "media_type")
         if getattr(case, name) not in (None, NOT_SET)
     ]

schemathesis/stateful/statistic.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
-from . import events
+if TYPE_CHECKING:
+    from . import events
 
 
 @dataclass

schemathesis/stateful/validation.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from ..exceptions import CheckFailed, get_grouped_exception
-from .context import RunnerContext
 
 if TYPE_CHECKING:
     from ..failures import FailureContext
     from ..models import Case, CheckFunction
     from ..transports.responses import GenericResponse
+    from .context import RunnerContext
 
 
 def validate_response(