schemathesis 4.0.0a2__py3-none-any.whl → 4.0.0a3__py3-none-any.whl

schemathesis/specs/openapi/schemas.py

@@ -66,8 +66,8 @@ 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 schemathesis.auths import AuthStorage
+    from schemathesis.generation.stateful import APIStateMachine
 
 HTTP_METHODS = frozenset({"get", "put", "post", "delete", "options", "head", "patch", "trace"})
 SCHEMA_ERROR_MESSAGE = "Ensure that the definition complies with the OpenAPI specification"
@@ -174,30 +174,64 @@ class BaseOpenAPISchema(BaseSchema):
             return statistic
 
         resolve = self.resolver.resolve
+        resolve_path_item = self._resolve_path_item
         should_skip = self._should_skip
         links_field = self.links_field
 
+        # For operationId lookup
+        selected_operations_by_id: set[str] = set()
+        # Tuples of (method, path)
+        selected_operations_by_path: set[tuple[str, str]] = set()
+        collected_links: list[dict] = []
+
         for path, path_item in paths.items():
             try:
-                if "$ref" in path_item:
-                    _, path_item = resolve(path_item["$ref"])
-                for method, definition in path_item.items():
-                    if method not in HTTP_METHODS:
-                        continue
-                    statistic.operations.total += 1
-                    is_selected = not should_skip(path, method, definition)
-                    if is_selected:
-                        statistic.operations.selected += 1
-                    for response in definition.get("responses", {}).values():
-                        if "$ref" in response:
-                            _, response = resolve(response["$ref"])
-                        defined_links = response.get(links_field)
-                        if defined_links is not None:
-                            statistic.links.total += len(defined_links)
-                            if is_selected:
-                                statistic.links.selected = len(defined_links)
+                scope, path_item = resolve_path_item(path_item)
+                self.resolver.push_scope(scope)
+                try:
+                    for method, definition in path_item.items():
+                        if method not in HTTP_METHODS:
+                            continue
+                        statistic.operations.total += 1
+                        is_selected = not should_skip(path, method, definition)
+                        if is_selected:
+                            statistic.operations.selected += 1
+                            # Store both identifiers
+                            if "operationId" in definition:
+                                selected_operations_by_id.add(definition["operationId"])
+                            selected_operations_by_path.add((method, path))
+                        for response in definition.get("responses", {}).values():
+                            if "$ref" in response:
+                                _, response = resolve(response["$ref"])
+                            defined_links = response.get(links_field)
+                            if defined_links is not None:
+                                statistic.links.total += len(defined_links)
+                                if is_selected:
+                                    collected_links.extend(defined_links.values())
+                finally:
+                    self.resolver.pop_scope()
             except SCHEMA_PARSING_ERRORS:
                 continue
+
+        def is_link_selected(link: dict) -> bool:
+            if "$ref" in link:
+                _, link = resolve(link["$ref"])
+
+            if "operationId" in link:
+                return link["operationId"] in selected_operations_by_id
+            else:
+                try:
+                    scope, _ = resolve(link["operationRef"])
+                    path, method = scope.rsplit("/", maxsplit=2)[-2:]
+                    path = path.replace("~1", "/").replace("~0", "~")
+                    return (method, path) in selected_operations_by_path
+                except Exception:
+                    return False
+
+        for link in collected_links:
+            if is_link_selected(link):
+                statistic.links.selected += 1
+
         return statistic
 
     def _operation_iter(self) -> Generator[dict[str, Any], None, None]:
@@ -569,13 +603,7 @@ class BaseOpenAPISchema(BaseSchema):
         return scopes, definitions.get("headers")
 
     def as_state_machine(self) -> type[APIStateMachine]:
-        try:
-            return create_state_machine(self)
-        except OperationNotFound as exc:
-            raise LoaderError(
-                kind=LoaderErrorKind.OPEN_API_INVALID_SCHEMA,
-                message=f"Invalid Open API link definition: Operation `{exc.item}` not found",
-            ) from exc
+        return create_state_machine(self)
 
     def add_link(
         self,

schemathesis/specs/openapi/stateful/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from collections import defaultdict
+from dataclasses import dataclass
 from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Callable, Iterator
 
@@ -8,25 +8,31 @@ from hypothesis import strategies as st
 from hypothesis.stateful import Bundle, Rule, precondition, rule
 
 from schemathesis.core.result import Ok
+from schemathesis.engine.recorder import ScenarioRecorder
+from schemathesis.generation import GenerationMode
 from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis import strategies
 from schemathesis.generation.stateful.state_machine import APIStateMachine, StepInput, StepOutput, _normalize_name
 from schemathesis.schemas import APIOperation
-
-from ....generation import GenerationMode
-from ..links import OpenApiLink, get_all_links
-from ..utils import expand_status_code
+from schemathesis.specs.openapi.links import OpenApiLink, get_all_links
+from schemathesis.specs.openapi.stateful.control import TransitionController
+from schemathesis.specs.openapi.utils import expand_status_code
 
 if TYPE_CHECKING:
     from schemathesis.generation.stateful.state_machine import StepOutput
-
-    from ..schemas import BaseOpenAPISchema
+    from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
 
 FilterFunction = Callable[["StepOutput"], bool]
 
 
 class OpenAPIStateMachine(APIStateMachine):
     _response_matchers: dict[str, Callable[[StepOutput], str | None]]
+    _transitions: ApiTransitions
+
+    def __init__(self) -> None:
+        self.recorder = ScenarioRecorder(label="Stateful tests")
+        self.control = TransitionController(self._transitions)
+        super().__init__()
 
     def _get_target_for_result(self, result: StepOutput) -> str | None:
         matcher = self._response_matchers.get(result.case.operation.label)
@@ -36,81 +42,118 @@ class OpenAPIStateMachine(APIStateMachine):
 
 
 # The proportion of negative tests generated for "root" transitions
-NEGATIVE_TEST_CASES_THRESHOLD = 20
+NEGATIVE_TEST_CASES_THRESHOLD = 10
 
 
-def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
-    """Create a state machine class.
+@dataclass
+class OperationTransitions:
+    """Transitions for a single operation."""
 
-    It aims to avoid making calls that are not likely to lead to a stateful call later. For example:
-      1. POST /users/
-      2. GET /users/{id}/
+    __slots__ = ("incoming", "outgoing")
 
-    This state machine won't make calls to (2) without having a proper response from (1) first.
-    """
+    def __init__(self) -> None:
+        self.incoming: list[OpenApiLink] = []
+        self.outgoing: list[OpenApiLink] = []
+
+
+@dataclass
+class ApiTransitions:
+    """Stores all transitions grouped by operation."""
+
+    __slots__ = ("operations",)
+
+    def __init__(self) -> None:
+        # operation label -> its transitions
+        self.operations: dict[str, OperationTransitions] = {}
+
+    def add_outgoing(self, source: str, link: OpenApiLink) -> None:
+        """Record an outgoing transition from source operation."""
+        self.operations.setdefault(source, OperationTransitions()).outgoing.append(link)
+        self.operations.setdefault(link.target.label, OperationTransitions()).incoming.append(link)
+
+
+def collect_transitions(operations: list[APIOperation]) -> ApiTransitions:
+    """Collect all transitions between operations."""
+    transitions = ApiTransitions()
+
+    selected_labels = {operation.label for operation in operations}
+    for operation in operations:
+        for _, link in get_all_links(operation):
+            if link.target.label in selected_labels:
+                transitions.add_outgoing(operation.label, link)
+
+    return transitions
+
+
+def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
     operations = [result.ok() for result in schema.get_all_operations() if isinstance(result, Ok)]
     bundles = {}
-    incoming_transitions = defaultdict(list)
+    transitions = collect_transitions(operations)
     _response_matchers: dict[str, Callable[[StepOutput], str | None]] = {}
-    # Statistic structure follows the links and count for each response status code
+
+    # Create bundles and matchers
     for operation in operations:
         all_status_codes = tuple(operation.definition.raw["responses"])
         bundle_matchers = []
-        for _, link in get_all_links(operation):
-            bundle_name = f"{operation.label} -> {link.status_code}"
-            bundles[bundle_name] = Bundle(bundle_name)
-            incoming_transitions[link.target.label].append(link)
-            bundle_matchers.append((bundle_name, make_response_filter(link.status_code, all_status_codes)))
+
+        if operation.label in transitions.operations:
+            # Use outgoing transitions
+            for link in transitions.operations[operation.label].outgoing:
+                bundle_name = f"{operation.label} -> {link.status_code}"
+                bundles[bundle_name] = Bundle(bundle_name)
+                bundle_matchers.append((bundle_name, make_response_filter(link.status_code, all_status_codes)))
+
         if bundle_matchers:
             _response_matchers[operation.label] = make_response_matcher(bundle_matchers)
+
     rules = {}
     catch_all = Bundle("catch_all")
 
     for target in operations:
-        incoming = incoming_transitions.get(target.label)
-        if incoming is not None:
-            for link in incoming:
-                bundle_name = f"{link.source.label} -> {link.status_code}"
-                name = _normalize_name(f"{link.status_code} -> {target.label}")
-                rules[name] = precondition(ensure_non_empty_bundle(bundle_name))(
-                    transition(
-                        name=name,
-                        target=catch_all,
-                        input=bundles[bundle_name].flatmap(
-                            into_step_input(target=target, link=link, modes=schema.generation_config.modes)
-                        ),
+        if target.label in transitions.operations:
+            incoming = transitions.operations[target.label].incoming
+            if incoming:
+                for link in incoming:
+                    bundle_name = f"{link.source.label} -> {link.status_code}"
+                    name = _normalize_name(f"{link.status_code} -> {target.label}")
+                    name = _normalize_name(f"{link.source.label} -> {link.status_code} -> {target.label}")
+                    assert name not in rules
+                    rules[name] = precondition(is_transition_allowed(bundle_name, link.source.label, target.label))(
+                        transition(
+                            name=name,
+                            target=catch_all,
+                            input=bundles[bundle_name].flatmap(
+                                into_step_input(target=target, link=link, modes=schema.generation_config.modes)
+                            ),
+                        )
                     )
+            if transitions.operations[target.label].outgoing and target.method == "post":
+                # Allow POST methods for operations with outgoing transitions.
+                # This approach also includes cases when there is an incoming transition back to POST
+                # For example, POST /users/ -> GET /users/{id}/
+                # The source operation has no prerequisite, but we need to allow this rule to be executed
+                # in order to reach other transitions
+                name = _normalize_name(f"{target.label} -> X")
+                if len(schema.generation_config.modes) == 1:
+                    case_strategy = target.as_strategy(generation_mode=schema.generation_config.modes[0])
+                else:
+                    _strategies = {
+                        method: target.as_strategy(generation_mode=method) for method in schema.generation_config.modes
+                    }
+
+                    @st.composite  # type: ignore[misc]
+                    def case_strategy_factory(
+                        draw: st.DrawFn, strategies: dict[GenerationMode, st.SearchStrategy] = _strategies
+                    ) -> Case:
+                        if draw(st.integers(min_value=0, max_value=99)) < NEGATIVE_TEST_CASES_THRESHOLD:
+                            return draw(strategies[GenerationMode.NEGATIVE])
+                        return draw(strategies[GenerationMode.POSITIVE])
+
+                    case_strategy = case_strategy_factory()
+
+                rules[name] = precondition(is_root_allowed(target.label))(
+                    transition(name=name, target=catch_all, input=case_strategy.map(StepInput.initial))
                 )
-        elif any(
-            incoming.source.label == target.label
-            for transitions in incoming_transitions.values()
-            for incoming in transitions
-        ):
-            # No incoming transitions, but has at least one outgoing transition
-            # For example, POST /users/ -> GET /users/{id}/
-            # The source operation has no prerequisite, but we need to allow this rule to be executed
-            # in order to reach other transitions
-            name = _normalize_name(f"{target.label} -> X")
-            if len(schema.generation_config.modes) == 1:
-                case_strategy = target.as_strategy(generation_mode=schema.generation_config.modes[0])
-            else:
-                _strategies = {
-                    method: target.as_strategy(generation_mode=method) for method in schema.generation_config.modes
-                }
-
-                @st.composite  # type: ignore[misc]
-                def case_strategy_factory(
-                    draw: st.DrawFn, strategies: dict[GenerationMode, st.SearchStrategy] = _strategies
-                ) -> Case:
-                    if draw(st.integers(min_value=0, max_value=99)) < NEGATIVE_TEST_CASES_THRESHOLD:
-                        return draw(strategies[GenerationMode.NEGATIVE])
-                    return draw(strategies[GenerationMode.POSITIVE])
-
-                case_strategy = case_strategy_factory()
-
-            rules[name] = precondition(ensure_links_followed)(
-                transition(name=name, target=catch_all, input=case_strategy.map(StepInput.initial))
-            )
 
     return type(
         "APIWorkflow",
@@ -119,6 +162,7 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
             "schema": schema,
             "bundles": bundles,
             "_response_matchers": _response_matchers,
+            "_transitions": transitions,
             **rules,
         },
     )
@@ -165,23 +209,29 @@ def into_step_input(
     return builder
 
 
-def ensure_non_empty_bundle(bundle_name: str) -> Callable[[APIStateMachine], bool]:
-    def inner(machine: APIStateMachine) -> bool:
-        return bool(machine.bundles.get(bundle_name))
+def is_transition_allowed(bundle_name: str, source: str, target: str) -> Callable[[OpenAPIStateMachine], bool]:
+    def inner(machine: OpenAPIStateMachine) -> bool:
+        return bool(machine.bundles.get(bundle_name)) and machine.control.allow_transition(source, target)
 
     return inner
 
 
-def ensure_links_followed(machine: APIStateMachine) -> bool:
-    # If there are responses that have links to follow, reject any rule without incoming transitions
-    for bundle in machine.bundles.values():
-        if bundle:
-            return False
-    return True
+def is_root_allowed(label: str) -> Callable[[OpenAPIStateMachine], bool]:
+    def inner(machine: OpenAPIStateMachine) -> bool:
+        return machine.control.allow_root_transition(label, machine.bundles)
+
+    return inner
 
 
 def transition(*, name: str, target: Bundle, input: st.SearchStrategy[StepInput]) -> Callable[[Callable], Rule]:
-    def step_function(self: APIStateMachine, input: StepInput) -> StepOutput | None:
+    def step_function(self: OpenAPIStateMachine, input: StepInput) -> StepOutput | None:
+        if input.transition is not None:
+            self.recorder.record_case(
+                parent_id=input.transition.parent_id, transition=input.transition, case=input.case
+            )
+        else:
+            self.recorder.record_case(parent_id=None, transition=None, case=input.case)
+        self.control.record_step(input, self.recorder)
         return APIStateMachine._step(self, input=input)
 
     step_function.__name__ = name

schemathesis/specs/openapi/stateful/control.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from schemathesis.engine.recorder import ScenarioRecorder
+from schemathesis.generation.stateful.state_machine import DEFAULT_STATEFUL_STEP_COUNT
+
+if TYPE_CHECKING:
+    from requests.structures import CaseInsensitiveDict
+
+    from schemathesis.generation.stateful.state_machine import StepInput
+    from schemathesis.specs.openapi.stateful import ApiTransitions
+
+
+# It is enough to be able to catch double-click type of issues
+MAX_OPERATIONS_PER_SOURCE_CAP = 2
+# Maximum number of concurrent root sources (e.g., active users in the system)
+MAX_ROOT_SOURCES = 2
+
+
+def _get_max_operations_per_source(transitions: ApiTransitions) -> int:
+    """Calculate global limit based on number of sources to maximize diversity of used API calls."""
+    sources = len(transitions.operations)
+
+    if sources == 0:
+        return MAX_OPERATIONS_PER_SOURCE_CAP
+
+    # Total steps divided by number of sources, but never below the cap
+    return max(MAX_OPERATIONS_PER_SOURCE_CAP, DEFAULT_STATEFUL_STEP_COUNT // sources)
+
+
+@dataclass
+class TransitionController:
+    """Controls which transitions can be executed in a state machine."""
+
+    __slots__ = ("transitions", "max_operations_per_source", "statistic")
+
+    def __init__(self, transitions: ApiTransitions) -> None:
+        # Incoming & outgoing transitions available in the state machine
+        self.transitions = transitions
+        self.max_operations_per_source = _get_max_operations_per_source(transitions)
+        # source -> derived API calls
+        self.statistic: dict[str, dict[str, Counter[str]]] = {}
+
+    def record_step(self, input: StepInput, recorder: ScenarioRecorder) -> None:
+        """Record API call input."""
+        case = input.case
+
+        if (
+            case.operation.label in self.transitions.operations
+            and self.transitions.operations[case.operation.label].outgoing
+        ):
+            # This API operation has outgoing transitions, hence record it as a source
+            entry = self.statistic.setdefault(input.case.operation.label, {})
+            entry[input.case.id] = Counter()
+
+        if input.transition is not None:
+            # Find immediate parent and record as derived operation
+            parent = recorder.cases[input.transition.parent_id]
+            source = parent.value.operation.label
+            case_id = parent.value.id
+
+            if source in self.statistic and case_id in self.statistic[source]:
+                self.statistic[source][case_id][case.operation.label] += 1
+
+    def allow_root_transition(self, source: str, bundles: dict[str, CaseInsensitiveDict]) -> bool:
+        """Decide if this root transition should be allowed now."""
+        if len(self.statistic.get(source, {})) < MAX_ROOT_SOURCES:
+            return True
+
+        # If all non-root operations are blocked, then allow root ones to make progress
+        history = {name.split("->")[0].strip() for name, values in bundles.items() if values}
+        return all(
+            incoming.source.label not in history
+            or not self.allow_transition(incoming.source.label, incoming.target.label)
+            for transitions in self.transitions.operations.values()
+            for incoming in transitions.incoming
+            if transitions.incoming
+        )
+
+    def allow_transition(self, source: str, target: str) -> bool:
+        """Decide if this transition should be allowed now."""
+        existing = self.statistic.get(source, {})
+        total = sum(metric.get(target, 0) for metric in existing.values())
+        return total < self.max_operations_per_source

{schemathesis-4.0.0a2.dist-info → schemathesis-4.0.0a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.0.0a2
+Version: 4.0.0a3
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://schemathesis.readthedocs.io/en/stable/changelog.html

{schemathesis-4.0.0a2.dist-info → schemathesis-4.0.0a3.dist-info}/RECORD

@@ -1,12 +1,12 @@
 schemathesis/__init__.py,sha256=ggp1CxctLo__wwFwlDhvtrexxDXGSbRjFKzXw_Twi7k,1139
 schemathesis/auths.py,sha256=t-YuPyoLqL7jlRUH-45JxO7Ir3pYxpe31CRmNIJh7rI,15423
 schemathesis/checks.py,sha256=B5-ROnjvvwpaqgj_iQ7eCjGqvRRVT30eWNPLKmwdrM8,5084
-schemathesis/errors.py,sha256=v5LpP5Yv78E96HoMJCsiKT_epDjkzLYMT0TtkarqomY,1336
+schemathesis/errors.py,sha256=R_GkKg9o-XYWsU4f-Devn_clIrhMi5ZXpiAjqi5Tupw,791
 schemathesis/filters.py,sha256=6kffe_Xbi7-xThsUciWfmy1IU-LBgSYkXROUJJONJ48,13311
 schemathesis/hooks.py,sha256=jTdN5GJbxHRMshxgcuI_th9ouuL32CN4m2Jt0pmT_bs,13148
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/schemas.py,sha256=wQqKfZIaPgfAzLVUOxkgW7LqwBdWtLJeryeouytUlTw,27412
-schemathesis/cli/__init__.py,sha256=Fxsopap2Mw6mYh27l6xMRJ5PhUsCJ19pDxDj2hCc2wg,582
+schemathesis/cli/__init__.py,sha256=cT8DmZYudre1a0cX2KOBytquJ85CMdmMnqqMZsIATJU,822
 schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
 schemathesis/cli/constants.py,sha256=rUixnqorraUFDtOu3Nmm1x_k0qbgmW9xW96kQB_fBCQ,338
 schemathesis/cli/core.py,sha256=Qm5xvpIIMwJDTeR3N3TjKhMCHV5d5Rp0UstVS2GjWgw,459
@@ -15,8 +15,8 @@ schemathesis/cli/commands/__init__.py,sha256=FFalEss3D7mnCRO0udtYb65onXSjQCCOv8s
 schemathesis/cli/commands/run/__init__.py,sha256=mpXoFTAuyaBjTQiusLVfzU9BXwcNN84vcmll22bQ-18,22651
 schemathesis/cli/commands/run/checks.py,sha256=-p6bzuc98kNR1VhkTI2s4xaJx-b5zYSMwdlhONwUhRM,3337
 schemathesis/cli/commands/run/context.py,sha256=o_lUkR2bpsxO4oMB7eJVCMIR9jmfS0nLZCd_LdOluF4,3906
-schemathesis/cli/commands/run/events.py,sha256=rGR0Gm2Vw8YZGz7w2buj8Gck_UO9TDl1oSLLoEitDz8,960
-schemathesis/cli/commands/run/executor.py,sha256=vTqr4eq88d3Q0pIh14wgkO6B6N6r-uEP0hdUG7gemqg,4699
+schemathesis/cli/commands/run/events.py,sha256=Dj-xvIr-Hkms8kvh4whNwKSk1Q2Hx4NIENi_4A8nQO8,1224
+schemathesis/cli/commands/run/executor.py,sha256=pozPf5kzizsQtCzssE_5M8AV2lgzPcE3o9xxoOA1n78,4816
 schemathesis/cli/commands/run/filters.py,sha256=vBYH_Q1Gc2yjo4pysd1nSKfNVQADh5POFoAExvUPmqQ,7390
 schemathesis/cli/commands/run/hypothesis.py,sha256=3PkcUSe-P6zgkhPJbN8RstjGNzgcY76AVlJ7ayu44Eg,3582
 schemathesis/cli/commands/run/loaders.py,sha256=VedoeIE1tgFBqVokWxOoUReAjBl-Zhx87RjCEBtCVfs,4840
@@ -25,7 +25,7 @@ schemathesis/cli/commands/run/handlers/__init__.py,sha256=TPZ3KdGi8m0fjlN0GjA31M
 schemathesis/cli/commands/run/handlers/base.py,sha256=yDsTtCiztLksfk7cRzg8JlaAVOfS-zwK3tsJMOXAFyc,530
 schemathesis/cli/commands/run/handlers/cassettes.py,sha256=y4gtGnAfhE9dskhXPnDAQSx3kY4R2a1hvAiE3o8AsUA,19001
 schemathesis/cli/commands/run/handlers/junitxml.py,sha256=MkFq_DyMWves4Ytj72-4secMTlBOt7Gs9W3nfBzknIA,2316
-schemathesis/cli/commands/run/handlers/output.py,sha256=l6Q_UZk_Fd3EzLQHU2TgaXvcn9M-ASLfjT4Y9wx9PyU,50197
+schemathesis/cli/commands/run/handlers/output.py,sha256=KlT_omUWRWzygvqz_nwRvXJXjtbmzTYhfWqPCLOQTBw,51917
 schemathesis/cli/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/cli/ext/fs.py,sha256=OA3mRzra4rq3NyDTcBvlRh0WJrh4ByN-QQ8loI04m88,408
 schemathesis/cli/ext/groups.py,sha256=9mIZUnQasUxGz6gZA0IoGVGKtSQuVNl8w2pwX_a1nBk,1796
@@ -38,7 +38,7 @@ schemathesis/core/compat.py,sha256=Lflo6z-nQ6S4uKZINc4Fr90pd3LTN6cIG9HJJmmaHeY,7
 schemathesis/core/control.py,sha256=IzwIc8HIAEMtZWW0Q0iXI7T1niBpjvcLlbuwOSmy5O8,130
 schemathesis/core/curl.py,sha256=yuaCe_zHLGwUjEeloQi6W3tOA3cGdnHDNI17-5jia0o,1723
 schemathesis/core/deserialization.py,sha256=ygIj4fNaOd0mJ2IvTsn6bsabBt_2AbSLCz-z9UqfpdQ,2406
-schemathesis/core/errors.py,sha256=Euy3YfF49dAH70KgMz4uFO5eRRX485RkT8v4go0TxOc,13423
+schemathesis/core/errors.py,sha256=ocwWs8xtoiTtzGn8eCdCtb_Hrdn-jHi_d_TNl29UIkI,13656
 schemathesis/core/failures.py,sha256=4ftUsY0q1QqqfWpYkl5lWCZVBUAMy8VP9pXsyDZ8Q3o,8723
 schemathesis/core/fs.py,sha256=ItQT0_cVwjDdJX9IiI7EnU75NI2H3_DCEyyUjzg_BgI,472
 schemathesis/core/lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
@@ -58,14 +58,14 @@ schemathesis/engine/__init__.py,sha256=xncZMXY8S-v4mrfnW4CK6-RQ0S0bigfLDJScpQysb
 schemathesis/engine/config.py,sha256=vWwtaWuSLvE-w0S9n4_MlJADjN58zlgSp84ZQS2z0ls,1919
 schemathesis/engine/context.py,sha256=HeLX-0aqSAbXJe_ZlkqVfg3QlhmbCrazbb9-ZPbi0h0,3723
 schemathesis/engine/control.py,sha256=QKUOs5VMphe7EcAIro_DDo9ZqdOU6ZVwTU1gMNndHWw,1006
-schemathesis/engine/core.py,sha256=Q7fkHlGJdMDTt4PBFp53rWJbyQdNOMgn1QIt2nI74KQ,5088
-schemathesis/engine/errors.py,sha256=nvl-2DKQSBAbas1MpEveUGLb_DL-LtMkcg9LijmctPM,16179
+schemathesis/engine/core.py,sha256=_Z89tc_aWQ0kHajVXmoTaEbIRYeERvb1s0rD82XpYxg,5085
+schemathesis/engine/errors.py,sha256=EtgqS-6ngtFg6TtloN_g07t3wYPMF6JOSesZ3C2VyXY,16576
 schemathesis/engine/events.py,sha256=7tpxCxptKx_WvcFgv9_6v0E-5wiQfDs1O5bsOH46xb8,5989
-schemathesis/engine/recorder.py,sha256=jmYhsk-RCIXvUyOqmSTL2shMBFepL58s0r1z2Ydg1YE,8428
+schemathesis/engine/recorder.py,sha256=K3HfMARrT5mPWXPnYebjjcq5CcsBRhMrtZwEL9_Lvtg,8432
 schemathesis/engine/phases/__init__.py,sha256=HZmlOjGvtDkfTwAw2rJFcfsJ2qg2h973l4zDy3AzsQg,2034
 schemathesis/engine/phases/probes.py,sha256=3M9g3E7CXbDDK_8inuvkRZibCCcoO2Ce5U3lnyTeWXQ,5131
-schemathesis/engine/phases/stateful/__init__.py,sha256=_m0gx9ASfAKawAlHtI5hnWdMJs5QFUw1jd8VlxjETJo,2308
-schemathesis/engine/phases/stateful/_executor.py,sha256=V_nJJDaDSOEGH2hcoCyZH4xz_57Vqu8k4XpNd53znSg,12640
+schemathesis/engine/phases/stateful/__init__.py,sha256=lWo2RLrutNblHvohTzofQqL22GORwBRA8bf6jvLuGPg,2391
+schemathesis/engine/phases/stateful/_executor.py,sha256=oZSfgvGUmiyjVDGpTeZCRv8KLjesYXJeE3cs0OTkQ1E,12428
 schemathesis/engine/phases/stateful/context.py,sha256=SKWsok-tlWbUDagiUmP7cLNW6DsgFDc_Afv0vQfWv6c,2964
 schemathesis/engine/phases/unit/__init__.py,sha256=XgLGwkVemmobLP6cyfAGYLu8RFRCrv6osfB3BD6OAS0,7537
 schemathesis/engine/phases/unit/_executor.py,sha256=X8hziN6rAd9vRTkbiMKcZWN6ujj4pUEiVdm6OmFsniI,12931
@@ -73,19 +73,19 @@ schemathesis/engine/phases/unit/_pool.py,sha256=01xRGJnmfLqGBH-f3nQEDv7vOufmen5Z
 schemathesis/experimental/__init__.py,sha256=36H1vLQhrw4SMD_jx76Wt07PHneELRDY1jfBSh7VxU0,2257
 schemathesis/generation/__init__.py,sha256=2htA0TlQee6AvQmLl1VNxEptRDqvPjksXKJLMVLAJng,1580
 schemathesis/generation/case.py,sha256=Rt5MCUtPVYVQzNyjUx8magocPJpHV1svyuqQSTwUE-I,7306
-schemathesis/generation/coverage.py,sha256=u6VjUUQq3nNFOaJingO8CR-e_qL5BqQrUJRU5MZNzDQ,39149
+schemathesis/generation/coverage.py,sha256=yQwazaxhKacHU3sA8shMPWQ1JhLE_90YgIZjvAymsG8,39133
 schemathesis/generation/meta.py,sha256=36h6m4E7jzLGa8TCvl7eBl_xUWLiRul3qxzexl5cB58,2515
 schemathesis/generation/modes.py,sha256=t_EvKr2aOXYMsEfdMu4lLF4KCGcX1LVVyvzTkcpJqhk,663
 schemathesis/generation/overrides.py,sha256=FhqcFoliEvgW6MZyFPYemfLgzKt3Miy8Cud7OMOCb7g,3045
 schemathesis/generation/targets.py,sha256=_rN2qgxTE2EfvygiN-Fy3WmDnRH0ERohdx3sKRDaYhU,2120
 schemathesis/generation/hypothesis/__init__.py,sha256=Rl7QwvMBMJI7pBqTydplX6bXC420n0EGQHVm-vZgaYQ,1204
-schemathesis/generation/hypothesis/builder.py,sha256=s1JHSL0ATNk8u-dli1a-LQzjhyiIgUBfUuJCwp-rt8g,24401
+schemathesis/generation/hypothesis/builder.py,sha256=K8pA5hFkx7sXSFIR8zX7ltYCwJHx3CFcq4Rm12ou1wk,24650
 schemathesis/generation/hypothesis/examples.py,sha256=6eGaKUEC3elmKsaqfKj1sLvM8EHc-PWT4NRBq4NI0Rs,1409
 schemathesis/generation/hypothesis/given.py,sha256=sTZR1of6XaHAPWtHx2_WLlZ50M8D5Rjux0GmWkWjDq4,2337
 schemathesis/generation/hypothesis/reporting.py,sha256=uDVow6Ya8YFkqQuOqRsjbzsbyP4KKfr3jA7ZaY4FuKY,279
 schemathesis/generation/hypothesis/strategies.py,sha256=RurE81E06d99YKG48dizy9346ayfNswYTt38zewmGgw,483
 schemathesis/generation/stateful/__init__.py,sha256=kXpCGbo1-QqfR2N0Z07tLw0Z5_tvbuG3Tk-WI_I1doI,653
-schemathesis/generation/stateful/state_machine.py,sha256=hV-npuzfvp0cxT6SBxAYoseuxmTdbChGnDZ3Wf7nL9o,10962
+schemathesis/generation/stateful/state_machine.py,sha256=S-mTOyLEeiO3PMv9LfSxQWSi8KxD5URptDxRpkO5Fmw,10947
 schemathesis/graphql/__init__.py,sha256=_eO6MAPHGgiADVGRntnwtPxmuvk666sAh-FAU4cG9-0,326
 schemathesis/graphql/checks.py,sha256=IADbxiZjgkBWrC5yzHDtohRABX6zKXk5w_zpWNwdzYo,3186
 schemathesis/graphql/loaders.py,sha256=96R_On1jFvsNuLwqXnO3_TTpsYhdCv0LAmR5jWRXXnY,4756
@@ -112,18 +112,18 @@ schemathesis/specs/graphql/validation.py,sha256=-W1Noc1MQmTb4RX-gNXMeU2qkgso4mzV
 schemathesis/specs/openapi/__init__.py,sha256=C5HOsfuDJGq_3mv8CRBvRvb0Diy1p0BFdqyEXMS-loE,238
 schemathesis/specs/openapi/_cache.py,sha256=HpglmETmZU0RCHxp3DO_sg5_B_nzi54Zuw9vGzzYCxY,4295
 schemathesis/specs/openapi/_hypothesis.py,sha256=n_39iyz1rt2EdSe-Lyr-3sOIEyJIthnCVR4tGUUvH1c,21328
-schemathesis/specs/openapi/checks.py,sha256=bgThVKGwmxDLnAxH8B96t0Qn-hNkpE0DrZ1B7GvTXJM,26236
+schemathesis/specs/openapi/checks.py,sha256=R-vehTWC6ZcVYVfKiXVdYHnZBTosMpZQzPPBsJ2dt-Y,26909
 schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnKDwCwPLhID4,783
 schemathesis/specs/openapi/converter.py,sha256=lil8IewM5j8tvt4lpA9g_KITvIwx1M96i45DNSHNjoc,3505
 schemathesis/specs/openapi/definitions.py,sha256=8htclglV3fW6JPBqs59lgM4LnA25Mm9IptXBPb_qUT0,93949
 schemathesis/specs/openapi/examples.py,sha256=Uy6naFBq-m1vo_18j4KuZBUYc9qKrBk19jBCWT7tnRg,20464
 schemathesis/specs/openapi/formats.py,sha256=ViVF3aFeFI1ctwGQbiRDXhU3so82P0BCaF2aDDbUUm8,2816
-schemathesis/specs/openapi/links.py,sha256=c3ko0jrASbqpo7JaD22DKtlZaUvGUTG51jHvEJPzDpQ,8802
+schemathesis/specs/openapi/links.py,sha256=eVlZVnlIcBUSSnYEEb_Bes3tfY5F_BNsOo0IZCBb-io,9452
 schemathesis/specs/openapi/media_types.py,sha256=ADedOaNWjbAtAekyaKmNj9fY6zBTeqcNqBEjN0EWNhI,1014
 schemathesis/specs/openapi/parameters.py,sha256=fmOkH-KhMVzWmE6eSw2pw2hernril5MDL7DwwEG4344,14655
-schemathesis/specs/openapi/patterns.py,sha256=RpvsAfpcm2dAcFYj-N6w0iQ1VdCT9h8BLdS1mrso6II,5518
+schemathesis/specs/openapi/patterns.py,sha256=6qNZRYQkHtJ98_JMjwhqIGpeR4aR7rlxcCmr1nOHMzk,11258
 schemathesis/specs/openapi/references.py,sha256=YjD1xMlaYS7xLt6PrrVS20R72ZWHuFZFTa8Llzf54Rg,8808
-schemathesis/specs/openapi/schemas.py,sha256=kFihC15IMAMce_o1VtHGhZawjmczFlMkbKUj9sbnmbk,53692
+schemathesis/specs/openapi/schemas.py,sha256=UAukxlH2bVlpZNnx_4EzhDefPpsEtC2ieWz_x336-SQ,54906
 schemathesis/specs/openapi/security.py,sha256=6UWYMhL-dPtkTineqqBFNKca1i4EuoTduw-EOLeE0aQ,7149
 schemathesis/specs/openapi/serialization.py,sha256=JFxMqCr8YWwPT4BVrbvVytcAmkzGXyL1_Q1xR1JKBPs,11464
 schemathesis/specs/openapi/utils.py,sha256=ER4vJkdFVDIE7aKyxyYatuuHVRNutytezgE52pqZNE8,900
@@ -137,15 +137,16 @@ schemathesis/specs/openapi/negative/__init__.py,sha256=60QqVBTXPTsAojcf7GDs7v8Wb
 schemathesis/specs/openapi/negative/mutations.py,sha256=7jTjD9rt5vxWSVBL5Hx8Avj4WhTA63frDQiFMKysrUU,19248
 schemathesis/specs/openapi/negative/types.py,sha256=a7buCcVxNBG6ILBM3A7oNTAX0lyDseEtZndBuej8MbI,174
 schemathesis/specs/openapi/negative/utils.py,sha256=ozcOIuASufLqZSgnKUACjX-EOZrrkuNdXX0SDnLoGYA,168
-schemathesis/specs/openapi/stateful/__init__.py,sha256=W1CwDtYYiy4hwpMFEqD6Ya9Sif_shQo7mbeWgo-XJXA,9728
+schemathesis/specs/openapi/stateful/__init__.py,sha256=Tk9ahg6VVXwVw8yfFmrz9xhDWskBUaKEeBobdtd44HU,12020
+schemathesis/specs/openapi/stateful/control.py,sha256=QaXLSbwQWtai5lxvvVtQV3BLJ8n5ePqSKB00XFxp-MA,3695
 schemathesis/transport/__init__.py,sha256=z-mRNSOlMBKwQyaEIhpmYv0plWTmK5dJqc9UmQOry80,3949
 schemathesis/transport/asgi.py,sha256=qTClt6oT_xUEWnRHokACN_uqCNNUZrRPT6YG0PjbElY,926
 schemathesis/transport/prepare.py,sha256=qQ6zXBw5NN2AIM0bzLAc5Ryc3dmMb0R6xN14lnR49pU,3826
 schemathesis/transport/requests.py,sha256=OObRvcTL72-BZ7AfuDUrZZU9nZtfBqr22oF8nkzaOLE,8389
 schemathesis/transport/serialization.py,sha256=jIMra1LqRGav0OX3Hx7mvORt38ll4cd2DKit2D58FN0,10531
 schemathesis/transport/wsgi.py,sha256=RWSuUXPrl91GxAy8a4jyNNozOWVMRBxKx_tljlWA_Lo,5697
-schemathesis-4.0.0a2.dist-info/METADATA,sha256=IcvZ7pOCr48wivV_O6DKm6HGqsXvZzkMpYVkM_lv88M,12292
-schemathesis-4.0.0a2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.0.0a2.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.0.0a2.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-4.0.0a2.dist-info/RECORD,,
+schemathesis-4.0.0a3.dist-info/METADATA,sha256=80kE1Tg6m91KKgpuMEUsuPEPYJzCxeXcGthSlW1_BYs,12292
+schemathesis-4.0.0a3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.0.0a3.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.0.0a3.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-4.0.0a3.dist-info/RECORD,,