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

schemathesis/specs/openapi/stateful/__init__.py

@@ -7,15 +7,17 @@ from typing import TYPE_CHECKING, Any, Callable, Iterator
 from hypothesis import strategies as st
 from hypothesis.stateful import Bundle, Rule, precondition, rule
 
+from schemathesis.core.errors import InvalidStateMachine
 from schemathesis.core.result import Ok
+from schemathesis.core.transforms import UNRESOLVABLE
 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 schemathesis.specs.openapi.links import OpenApiLink, get_all_links
 from schemathesis.specs.openapi.stateful.control import TransitionController
+from schemathesis.specs.openapi.stateful.links import OpenApiLink, get_all_links
 from schemathesis.specs.openapi.utils import expand_status_code
 
 if TYPE_CHECKING:
@@ -72,15 +74,35 @@ class ApiTransitions:
         self.operations.setdefault(link.target.label, OperationTransitions()).incoming.append(link)
 
 
+@dataclass
+class RootTransitions:
+    """Classification of API operations that can serve as entry points."""
+
+    __slots__ = ("reliable", "fallback")
+
+    def __init__(self) -> None:
+        # Operations likely to succeed and provide data for other transitions
+        self.reliable: set[str] = set()
+        # Operations that might work but are less reliable
+        self.fallback: set[str] = set()
+
+
 def collect_transitions(operations: list[APIOperation]) -> ApiTransitions:
     """Collect all transitions between operations."""
     transitions = ApiTransitions()
 
     selected_labels = {operation.label for operation in operations}
+    errors = []
     for operation in operations:
         for _, link in get_all_links(operation):
-            if link.target.label in selected_labels:
-                transitions.add_outgoing(operation.label, link)
+            if isinstance(link, Ok):
+                if link.ok().target.label in selected_labels:
+                    transitions.add_outgoing(operation.label, link.ok())
+            else:
+                errors.append(link.err())
+
+    if errors:
+        raise InvalidStateMachine(errors)
 
     return transitions
 
@@ -109,15 +131,37 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
     rules = {}
     catch_all = Bundle("catch_all")
 
+    # We want stateful testing to be effective and focus on meaningful transitions.
+    # An operation is considered as a "root" transition (entry point) if it satisfies certain criteria
+    # that indicate it's likely to succeed and provide data for other transitions.
+    # For example:
+    #   - POST operations that create resources
+    #   - GET operations without path parameters (e.g., GET /users/ to list all users)
+    #
+    # We avoid adding operations as roots if they:
+    #   1. Have incoming transitions that will provide proper data
+    #      Example: If POST /users/ -> GET /users/{id} exists, we don't need
+    #      to generate random user IDs for GET /users/{id}
+    #   2. Are unlikely to succeed with random data
+    #      Example: GET /users/{id} with random ID is likely to return 404
+    #
+    # This way we:
+    #   1. Maximize the chance of successful transitions
+    #   2. Don't waste the test budget (limited number of steps) on likely-to-fail operations
+    #   3. Focus on transitions that are designed to work together via links
+
+    roots = classify_root_transitions(operations, transitions)
+
     for target in operations:
         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
+                    name = _normalize_name(
+                        f"{link.source.label} -> {link.status_code} -> {link.name} -> {target.label}"
+                    )
+                    assert name not in rules, name
                     rules[name] = precondition(is_transition_allowed(bundle_name, link.source.label, target.label))(
                         transition(
                             name=name,
@@ -127,13 +171,8 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
                             ),
                         )
                     )
-            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 target.label in roots.reliable or (not roots.reliable and target.label in roots.fallback):
+                name = _normalize_name(f"RANDOM -> {target.label}")
                 if len(schema.generation_config.modes) == 1:
                     case_strategy = target.as_strategy(generation_mode=schema.generation_config.modes[0])
                 else:
@@ -168,41 +207,75 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
     )
 
 
+def classify_root_transitions(operations: list[APIOperation], transitions: ApiTransitions) -> RootTransitions:
+    """Find operations that can serve as root transitions."""
+    roots = RootTransitions()
+
+    for operation in operations:
+        # Skip if operation has no outgoing transitions
+        operation_transitions = transitions.operations.get(operation.label)
+        if not operation_transitions or not operation_transitions.outgoing:
+            continue
+
+        if is_likely_root_transition(operation, operation_transitions):
+            roots.reliable.add(operation.label)
+        else:
+            roots.fallback.add(operation.label)
+
+    return roots
+
+
+def is_likely_root_transition(operation: APIOperation, transitions: OperationTransitions) -> bool:
+    """Check if operation is likely to succeed as a root transition."""
+    # POST operations with request bodies are likely to create resources
+    if operation.method == "post" and operation.body:
+        return True
+
+    # GET operations without path parameters are likely to return lists
+    if operation.method == "get" and not operation.path_parameters:
+        return True
+
+    return False
+
+
 def into_step_input(
     target: APIOperation, link: OpenApiLink, modes: list[GenerationMode]
 ) -> Callable[[StepOutput], st.SearchStrategy[StepInput]]:
     def builder(_output: StepOutput) -> st.SearchStrategy[StepInput]:
         @st.composite  # type: ignore[misc]
         def inner(draw: st.DrawFn, output: StepOutput) -> StepInput:
-            transition_data = link.extract(output)
+            transition = link.extract(output)
 
             kwargs: dict[str, Any] = {
                 container: {
                     name: extracted.value.ok()
                     for name, extracted in data.items()
-                    if isinstance(extracted.value, Ok) and extracted.value.ok() is not None
+                    if isinstance(extracted.value, Ok) and extracted.value.ok() not in (None, UNRESOLVABLE)
                 }
-                for container, data in transition_data.parameters.items()
+                for container, data in transition.parameters.items()
             }
+
             if (
-                transition_data.request_body is not None
-                and isinstance(transition_data.request_body.value, Ok)
+                transition.request_body is not None
+                and isinstance(transition.request_body.value, Ok)
+                and transition.request_body.value.ok() is not UNRESOLVABLE
                 and not link.merge_body
             ):
-                kwargs["body"] = transition_data.request_body.value.ok()
+                kwargs["body"] = transition.request_body.value.ok()
             cases = strategies.combine([target.as_strategy(generation_mode=mode, **kwargs) for mode in modes])
             case = draw(cases)
             if (
-                transition_data.request_body is not None
-                and isinstance(transition_data.request_body.value, Ok)
+                transition.request_body is not None
+                and isinstance(transition.request_body.value, Ok)
+                and transition.request_body.value.ok() is not UNRESOLVABLE
                 and link.merge_body
             ):
-                new = transition_data.request_body.value.ok()
+                new = transition.request_body.value.ok()
                 if isinstance(case.body, dict) and isinstance(new, dict):
                     case.body = {**case.body, **new}
                 else:
                     case.body = new
-            return StepInput(case=case, transition=transition_data)
+            return StepInput(case=case, transition=transition)
 
         return inner(output=_output)
 

schemathesis/specs/openapi/{links.py → stateful/links.py}

@@ -5,14 +5,13 @@ from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Callable, Generator, Literal, Union, cast
 
 from schemathesis.core import NOT_SET, NotSet
-from schemathesis.core.errors import InvalidLinkDefinition, InvalidSchema, OperationNotFound
+from schemathesis.core.errors import InvalidTransition, OperationNotFound, TransitionValidationError
 from schemathesis.core.result import Err, Ok, Result
 from schemathesis.generation.stateful.state_machine import ExtractedParam, StepOutput, Transition
 from schemathesis.schemas import APIOperation
-
-from . import expressions
-from .constants import LOCATION_TO_CONTAINER
-from .references import RECURSION_DEPTH_LIMIT
+from schemathesis.specs.openapi import expressions
+from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
+from schemathesis.specs.openapi.references import RECURSION_DEPTH_LIMIT
 
 if TYPE_CHECKING:
     from jsonschema import RefResolver
@@ -55,6 +54,7 @@ class OpenApiLink:
         self.status_code = status_code
         self.source = source
         assert isinstance(source.schema, BaseOpenAPISchema)
+        errors = []
 
         get_operation: Callable[[str], APIOperation]
         if "operationId" in definition:
@@ -66,19 +66,30 @@ class OpenApiLink:
 
         try:
             self.target = get_operation(operation_reference)
-        except OperationNotFound as exc:
-            raise InvalidLinkDefinition(
-                f"Link '{name}' references non-existent operation '{operation_reference}' from {status_code} response of '{source.label}'"
-            ) from exc
+            target = self.target.label
+        except OperationNotFound:
+            target = operation_reference
+            errors.append(TransitionValidationError(f"Operation '{operation_reference}' not found"))
 
         extension = definition.get(SCHEMATHESIS_LINK_EXTENSION)
-        self.parameters = self._normalize_parameters(definition.get("parameters", {}))
+        self.parameters = self._normalize_parameters(definition.get("parameters", {}), errors)
         self.body = definition.get("requestBody", NOT_SET)
         self.merge_body = extension.get("merge_body", True) if extension else True
 
+        if errors:
+            raise InvalidTransition(
+                name=self.name,
+                source=self.source.label,
+                target=target,
+                status_code=self.status_code,
+                errors=errors,
+            )
+
         self._cached_extract = lru_cache(8)(self._extract_impl)
 
-    def _normalize_parameters(self, parameters: dict[str, str]) -> list[NormalizedParameter]:
+    def _normalize_parameters(
+        self, parameters: dict[str, str], errors: list[TransitionValidationError]
+    ) -> list[NormalizedParameter]:
         """Process link parameters and resolve their container locations.
 
         Handles both explicit locations (e.g., "path.id") and implicit ones resolved from target operation.
@@ -94,7 +105,34 @@ class OpenApiLink:
                 location = None
                 name = parameter
 
-            container_name = self._get_parameter_container(location, name)
+            if isinstance(expression, str):
+                try:
+                    parsed = expressions.parser.parse(expression)
+                    # Find NonBodyRequest nodes that reference source parameters
+                    for node in parsed:
+                        if isinstance(node, expressions.nodes.NonBodyRequest):
+                            # Check if parameter exists in source operation
+                            if not any(
+                                p.name == node.parameter and p.location == node.location
+                                for p in self.source.iter_parameters()
+                            ):
+                                errors.append(
+                                    TransitionValidationError(
+                                        f"Expression `{expression}` references non-existent {node.location} parameter "
+                                        f"`{node.parameter}` in `{self.source.label}`"
+                                    )
+                                )
+                except Exception as exc:
+                    errors.append(TransitionValidationError(str(exc)))
+
+            if hasattr(self, "target"):
+                try:
+                    container_name = self._get_parameter_container(location, name)
+                except TransitionValidationError as exc:
+                    errors.append(exc)
+                    continue
+            else:
+                continue
             result.append(NormalizedParameter(location, name, expression, container_name))
         return result
 
@@ -106,7 +144,7 @@ class OpenApiLink:
         for param in self.target.iter_parameters():
             if param.name == name:
                 return LOCATION_TO_CONTAINER[param.location]
-        raise InvalidSchema(f"Parameter `{name}` is not defined in API operation `{self.target.label}`")
+        raise TransitionValidationError(f"Parameter `{name}` is not defined in API operation `{self.target.label}`")
 
     def extract(self, output: StepOutput) -> Transition:
         return self._cached_extract(StepOutputWrapper(output))
@@ -114,7 +152,7 @@ class OpenApiLink:
     def _extract_impl(self, wrapper: StepOutputWrapper) -> Transition:
         output = wrapper.output
         return Transition(
-            id=f"{self.source.label} - {self.status_code} - {self.name}",
+            id=f"{self.source.label} -> [{self.status_code}] {self.name} -> {self.target.label}",
             parent_id=output.case.id,
             parameters=self.extract_parameters(output),
             request_body=self.extract_body(output),
@@ -162,11 +200,17 @@ class StepOutputWrapper:
         return self.output.case.id == other.output.case.id
 
 
-def get_all_links(operation: APIOperation) -> Generator[tuple[str, OpenApiLink], None, None]:
+def get_all_links(
+    operation: APIOperation,
+) -> Generator[tuple[str, Result[OpenApiLink, InvalidTransition]], None, None]:
     for status_code, definition in operation.definition.raw["responses"].items():
         definition = operation.schema.resolver.resolve_all(definition, RECURSION_DEPTH_LIMIT - 8)  # type: ignore[attr-defined]
         for name, link_definition in definition.get(operation.schema.links_field, {}).items():  # type: ignore
-            yield status_code, OpenApiLink(name, status_code, link_definition, operation)
+            try:
+                link = OpenApiLink(name, status_code, link_definition, operation)
+                yield status_code, Ok(link)
+            except InvalidTransition as exc:
+                yield status_code, Err(exc)
 
 
 StatusCode = Union[str, int]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.0.0a3
+Version: 4.0.0a5
 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
@@ -137,36 +137,17 @@ Schemathesis is an API testing tool that automatically finds crashes and validat
 
 ### Highlights
 
-🎯 **Catches Hard-to-Find Bugs**
+- 🎯 **Catches Hard-to-Find Bugs**: Automatically uncover crashes and spec violations that manual testing might miss.
 
-- Uncover hidden crashes and edge cases that manual testing might miss
-- Identify spec violations and ensure your API adheres to its contract
+- ⚡ **Accelerates Testing**: Generate a wide range of test cases directly from your API schema.
 
-⚡ **Accelerates Testing Cycles**
+- 🧩 **Integrates Seamlessly**: Works with popular API formats such as OpenAPI and GraphQL, and easily integrates into your existing CI/CD workflows.
 
-- Automatically generate a wide range of test cases based on your API schema
-- Save time by reducing the need for manual test case creation
+- 🔧 **Customizable and Extendable**: Leverage Python extensions to configure and extend your test generation.
 
-🧩 **Integrates Seamlessly**
+- 🐞 **Simplifies Debugging**: Detailed reports and reproducible test cases with cURL commands streamline troubleshooting.
 
-- Works with popular API formats such as OpenAPI, GraphQL.
-- Easily integrate into your existing CI/CD workflows.
-
-🔧 **Customizable and Extendable**
-
-- Tune the testing process using Python extensions.
-- Adjust the testing flow to suit your needs with rich configuration options.
-
-🐞 **Simplifies Debugging**
-
-- Get detailed reports to identify and fix issues quickly.
-- Reproduce failing test cases with cURL commands.
-
-🔬 **Proven by Research**
-
-- Validated through academic studies on API testing automation
-- Featured in [ICSE 2022 paper](https://ieeexplore.ieee.org/document/9793781) on semantics-aware fuzzing
-- Recognized in [ACM survey](https://dl.acm.org/doi/10.1145/3617175) as state-of-the-art RESTful API testing tool
+- 🔬 **Proven by Research**: Validated through academic studies on API testing automation, featured in the [ICSE 2022 paper](https://ieeexplore.ieee.org/document/9793781) on semantics-aware fuzzing, and recognized in an [ACM survey](https://dl.acm.org/doi/10.1145/3617175) as a state-of-the-art RESTful API testing tool.
 
 ## Installation
 

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

@@ -1,45 +1,46 @@
 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=R_GkKg9o-XYWsU4f-Devn_clIrhMi5ZXpiAjqi5Tupw,791
-schemathesis/filters.py,sha256=6kffe_Xbi7-xThsUciWfmy1IU-LBgSYkXROUJJONJ48,13311
+schemathesis/errors.py,sha256=VSZ-h9Bt7QvrvywOGB-MoHCshR8OWJegYlBxfVh5Vuw,899
+schemathesis/filters.py,sha256=CzVPnNSRLNgvLlU5_WssPEC0wpdQi0dMvDpHSQbAlkE,13577
 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=cT8DmZYudre1a0cX2KOBytquJ85CMdmMnqqMZsIATJU,822
+schemathesis/schemas.py,sha256=Hs2pJTUa2Od3x5YRprrKYIfE7ndpKbAqeDylAWkB6yM,27407
+schemathesis/cli/__init__.py,sha256=U9gjzWWpiFhaqevPjZbwyTNjABdpvXETI4HgwdGKnvs,877
 schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
 schemathesis/cli/constants.py,sha256=rUixnqorraUFDtOu3Nmm1x_k0qbgmW9xW96kQB_fBCQ,338
 schemathesis/cli/core.py,sha256=Qm5xvpIIMwJDTeR3N3TjKhMCHV5d5Rp0UstVS2GjWgw,459
 schemathesis/cli/hooks.py,sha256=vTrA8EN99whRns5K5AnExViQ6WL9cak5RGsC-ZBEiJM,1458
 schemathesis/cli/commands/__init__.py,sha256=FFalEss3D7mnCRO0udtYb65onXSjQCCOv8sOSjqvTTM,1059
-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/__init__.py,sha256=ToPLYJrLcan5-fVqo-xs8peVy7O51fQMXxu1y5K2Ei4,23112
+schemathesis/cli/commands/run/checks.py,sha256=lLtBCt6NhhQisrWo8aC6i0M3dSXlbjGWTTlOyjzatks,3278
+schemathesis/cli/commands/run/context.py,sha256=pUwSlS7UwW2cq1nJXfKZFEaWDipsQAElCO4tdv1qYJA,7739
 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/executor.py,sha256=lKQZswH7vLsKCUNdDL8IOwJYsUicyPxRJ3vXOi1pwAk,5446
+schemathesis/cli/commands/run/filters.py,sha256=MdymOZtzOolvXCNBIdfHbBbWEXVF7Se0mmDpy3sVWu4,7411
+schemathesis/cli/commands/run/hypothesis.py,sha256=hdEHim_Hc2HwCGxAiRTf4t2OfQf0IeCUhyjNT_btB1o,2553
 schemathesis/cli/commands/run/loaders.py,sha256=VedoeIE1tgFBqVokWxOoUReAjBl-Zhx87RjCEBtCVfs,4840
-schemathesis/cli/commands/run/validation.py,sha256=zeMQ2QAlVTwxUriRJjo9AQbQRXqm41F7YMP3JysY6vQ,12667
+schemathesis/cli/commands/run/reports.py,sha256=OjyakiV0lpNDBZb1xsb_2HmLtcqhTThPYMpJGXyNNO8,2147
+schemathesis/cli/commands/run/validation.py,sha256=7fvLeDREQ9FTV8ZMJRnCdycD858j21k7j56ow4_iIcY,12789
 schemathesis/cli/commands/run/handlers/__init__.py,sha256=TPZ3KdGi8m0fjlN0GjA31MAXXn1qI7uU4FtiDwroXZI,1915
 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=KlT_omUWRWzygvqz_nwRvXJXjtbmzTYhfWqPCLOQTBw,51917
+schemathesis/cli/commands/run/handlers/cassettes.py,sha256=SVk13xPhsQduCpgvvBwzEMDNTju-SHQCW90xTQ6iL1U,18525
+schemathesis/cli/commands/run/handlers/junitxml.py,sha256=c24UiwXqRCnv2eWQWEaNXLOghMI9JtGoZ9RTJY4ao6M,2350
+schemathesis/cli/commands/run/handlers/output.py,sha256=AcnFAOm03QR4eKNQcQV2EZFV-YUcRaL4rKvMrmOyCuM,58806
 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
-schemathesis/cli/ext/options.py,sha256=Cm56WoktqBjKb8uDf063XT1der7lWOnTd81Y56PjoIg,3657
+schemathesis/cli/ext/groups.py,sha256=kQ37t6qeArcKaY2y5VxyK3_KwAkBKCVm58IYV8gewds,2720
+schemathesis/cli/ext/options.py,sha256=gBjfYPoiSoxCymWq41x0oKcQ2frv1fQnweETVpYiIsA,4096
 schemathesis/contrib/__init__.py,sha256=wxpX86xrEGRAS3f7eugQfKVbnqV6ZfOqFBS_DmWxOok,120
 schemathesis/contrib/openapi/__init__.py,sha256=-7mBZ9RQj0EGzzmC-HKiT5ZslwHcoWFqCVpRG0GHO_o,162
 schemathesis/contrib/openapi/fill_missing_examples.py,sha256=BfBpuy3vCKbE_uILqPXnm7kxEDopAr5tNQwP5E9xX8A,585
-schemathesis/core/__init__.py,sha256=Lag-8jUqWpcRdiTUtKS3v9HJZgwRy_JS854ZA7wh0W4,1573
+schemathesis/core/__init__.py,sha256=4SLVPpUZgZYABL6QPVRtanMemibKxTQEYcp4LFu4Jco,1761
 schemathesis/core/compat.py,sha256=Lflo6z-nQ6S4uKZINc4Fr90pd3LTN6cIG9HJJmmaHeY,754
 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=ocwWs8xtoiTtzGn8eCdCtb_Hrdn-jHi_d_TNl29UIkI,13656
-schemathesis/core/failures.py,sha256=4ftUsY0q1QqqfWpYkl5lWCZVBUAMy8VP9pXsyDZ8Q3o,8723
+schemathesis/core/errors.py,sha256=97Fk3udsMaS5xZrco7ZaShqe4W6g2aZ55J7d58HPRac,15881
+schemathesis/core/failures.py,sha256=jbbxOXB8LDYoLI97YrLCKi9XLuSqVqFJSLeeixVJPRU,8828
 schemathesis/core/fs.py,sha256=ItQT0_cVwjDdJX9IiI7EnU75NI2H3_DCEyyUjzg_BgI,472
 schemathesis/core/lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
 schemathesis/core/loaders.py,sha256=SQQ-8m64-D2FaOgvwKZLyTtLJuzP3RPo7Ud2BERK1c0,3404
@@ -48,57 +49,57 @@ schemathesis/core/media_types.py,sha256=vV0CEu34sDoZWXvu4R1Y1HosxVS4YXZV8iTov8fU
 schemathesis/core/rate_limit.py,sha256=7tg9Znk11erTfw8-ANutjEmu7hbfUHZx_iEdkoaP174,1757
 schemathesis/core/registries.py,sha256=T4jZB4y3zBHdeSgQc0pRbgSeMblvO-6z4I3zmzIfTi0,811
 schemathesis/core/result.py,sha256=d449YvyONjqjDs-A5DAPgtAI96iT753K8sU6_1HLo2Q,461
-schemathesis/core/transforms.py,sha256=oFyUcGILC_bUrPShKKS0C2KyROJLWQnCirbdElHuQSI,3521
+schemathesis/core/transforms.py,sha256=63aeLkR93r3krq4CwYtDcoS_pFBky4L16c9DcFsBHuE,3535
 schemathesis/core/transport.py,sha256=VqtVF4JxMuPXSBORzS8SOSLUnCEZL6gPOr0kuymMCAk,3249
 schemathesis/core/validation.py,sha256=JJbSymYUKKcbkY2L3nECKrbIVUb9PRyUsTqa-aeDEAw,1153
 schemathesis/core/version.py,sha256=O-6yFbNocbD4RDwiBZLborxTp54htyKxBWTqpZDnPvg,202
 schemathesis/core/output/__init__.py,sha256=lhVc4OzzxCsmvEPPvg1k8x19iPf_HF-9YonTaqsxvx8,2015
 schemathesis/core/output/sanitization.py,sha256=EODHJMHD8gqlIA0Yqs1OnElZ2JyNxjvQ0WWErZV1K3s,6210
 schemathesis/engine/__init__.py,sha256=xncZMXY8S-v4mrfnW4CK6-RQ0S0bigfLDJScpQysblE,831
-schemathesis/engine/config.py,sha256=vWwtaWuSLvE-w0S9n4_MlJADjN58zlgSp84ZQS2z0ls,1919
+schemathesis/engine/config.py,sha256=92Ud_aSTj-xi4Mwf8gej_gcvzjemH_ISjHQiXGGKskA,1885
 schemathesis/engine/context.py,sha256=HeLX-0aqSAbXJe_ZlkqVfg3QlhmbCrazbb9-ZPbi0h0,3723
 schemathesis/engine/control.py,sha256=QKUOs5VMphe7EcAIro_DDo9ZqdOU6ZVwTU1gMNndHWw,1006
-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/core.py,sha256=DfulRMVTivmZj-wwLekIhuSzLsFnuVPtSg7j9HyWdz0,5536
+schemathesis/engine/errors.py,sha256=8PHYsuq2qIEJHm2FDf_UnWa4IDc-DRFTPckLAr22yhE,16895
+schemathesis/engine/events.py,sha256=gslRAWQKMPqBCQzLDS4wAbsKcVuONSy5SPqimJJJYT4,6250
 schemathesis/engine/recorder.py,sha256=K3HfMARrT5mPWXPnYebjjcq5CcsBRhMrtZwEL9_Lvtg,8432
-schemathesis/engine/phases/__init__.py,sha256=HZmlOjGvtDkfTwAw2rJFcfsJ2qg2h973l4zDy3AzsQg,2034
+schemathesis/engine/phases/__init__.py,sha256=3p_T3JYBFOtrwtgmMM7J-6a41QJgk83dUtm7NKcVl3o,2490
 schemathesis/engine/phases/probes.py,sha256=3M9g3E7CXbDDK_8inuvkRZibCCcoO2Ce5U3lnyTeWXQ,5131
 schemathesis/engine/phases/stateful/__init__.py,sha256=lWo2RLrutNblHvohTzofQqL22GORwBRA8bf6jvLuGPg,2391
-schemathesis/engine/phases/stateful/_executor.py,sha256=oZSfgvGUmiyjVDGpTeZCRv8KLjesYXJeE3cs0OTkQ1E,12428
+schemathesis/engine/phases/stateful/_executor.py,sha256=m1ZMqFUPc4Hdql10l0gF3tpP4JOImSA-XeBd4jg3Ll8,12443
 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
-schemathesis/engine/phases/unit/_pool.py,sha256=01xRGJnmfLqGBH-f3nQEDv7vOufmen5ZCiXwNLpkxOw,2210
-schemathesis/experimental/__init__.py,sha256=36H1vLQhrw4SMD_jx76Wt07PHneELRDY1jfBSh7VxU0,2257
+schemathesis/engine/phases/unit/__init__.py,sha256=LcBQpGNPeEFB9XPGpcHBcH-C7nF-e8bZNPop9PIfiKA,7861
+schemathesis/engine/phases/unit/_executor.py,sha256=buMEr7e01SFSeNuEQNGMf4hoiLxX9_sp0JhH4LBAk9M,12928
+schemathesis/engine/phases/unit/_pool.py,sha256=9OgmFd-ov1AAvcZGquK40PXkGLp7f2qCjZoPZuoZl4A,2529
+schemathesis/experimental/__init__.py,sha256=jYY3Mq6okqTRTMudPzcaT0JVjzJW5IN_ZVJdGU0stBs,2011
 schemathesis/generation/__init__.py,sha256=2htA0TlQee6AvQmLl1VNxEptRDqvPjksXKJLMVLAJng,1580
 schemathesis/generation/case.py,sha256=Rt5MCUtPVYVQzNyjUx8magocPJpHV1svyuqQSTwUE-I,7306
-schemathesis/generation/coverage.py,sha256=yQwazaxhKacHU3sA8shMPWQ1JhLE_90YgIZjvAymsG8,39133
+schemathesis/generation/coverage.py,sha256=hyDb465tBoCWE7nI-ZJjhTUzk7f2WDufaadWdSAkdr0,39276
 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=K8pA5hFkx7sXSFIR8zX7ltYCwJHx3CFcq4Rm12ou1wk,24650
+schemathesis/generation/hypothesis/builder.py,sha256=lAxBePbfqGsp6iPjjXeDL-X8RnOgUhsgpYQpeKc1VKg,29292
 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=S-mTOyLEeiO3PMv9LfSxQWSi8KxD5URptDxRpkO5Fmw,10947
+schemathesis/generation/stateful/state_machine.py,sha256=3NoB3pYd3BZ0XzlQlhCf8WBCMGttJw25DWCTDsuulGc,12306
 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
 schemathesis/openapi/__init__.py,sha256=-KcsSAM19uOM0N5J4s-yTnQ1BFsptYhW1E51cEf6kVM,311
-schemathesis/openapi/checks.py,sha256=Rt6uX0yEVIG30YJdQeQKLu-9XZ1Bx-In1LCautTcghg,10760
+schemathesis/openapi/checks.py,sha256=i26qtVqsNUb46Aqu191qWK5lVC51KK6ezbhm1rSSyr4,10781
 schemathesis/openapi/loaders.py,sha256=jskoCnMgpjg_cpn17FRI4oDUpMdsMYjxfXdRPHYnPqs,6472
 schemathesis/openapi/generation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/openapi/generation/filters.py,sha256=MB2t_k6OVc2Rt6qXUrV-u-3sDg5wX6c0Mli9WgfMUF4,2001
 schemathesis/pytest/__init__.py,sha256=7W0q-Thcw03IAQfXE_Mo8JPZpUdHJzfu85fjK1ZdfQM,88
 schemathesis/pytest/control_flow.py,sha256=F8rAPsPeNv_sJiJgbZYtTpwKWjauZmqFUaKroY2GmQI,217
-schemathesis/pytest/lazy.py,sha256=FK_fVndvGn02wuVDMwaGfl2NlbVbQWEmCgMjRxeOmRk,10541
+schemathesis/pytest/lazy.py,sha256=g7DpOeQNsjXC03FCG5e1L65iz3zE48qAyaqG81HzCZY,12028
 schemathesis/pytest/loaders.py,sha256=oQJ78yyuIm3Ye9X7giVjDB1vYfaW5UY5YuhaTLm_ZFU,266
-schemathesis/pytest/plugin.py,sha256=ZIF75b4G81IGtGle0c8PHYeWcR_pHGC2NoSlijsznCQ,12372
+schemathesis/pytest/plugin.py,sha256=RDOuT25Uotese7W-SD3Pu-nb7zdnaPbyPOoJSkJKSoQ,12379
 schemathesis/python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/python/asgi.py,sha256=5PyvuTBaivvyPUEi3pwJni91K1kX5Zc0u9c6c1D8a1Q,287
 schemathesis/python/wsgi.py,sha256=uShAgo_NChbfYaV1117e6UHp0MTg7jaR0Sy_to3Jmf8,219
@@ -112,41 +113,41 @@ 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=R-vehTWC6ZcVYVfKiXVdYHnZBTosMpZQzPPBsJ2dt-Y,26909
+schemathesis/specs/openapi/checks.py,sha256=m3n5N3_iZcS7inJojW47FF6dfbUQzrBH-bXwsCAOyhM,27737
 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/examples.py,sha256=aURgeCsQrpsdWEAhjmW6BiRFabuSf5TeRlZBd4ltgNw,20381
 schemathesis/specs/openapi/formats.py,sha256=ViVF3aFeFI1ctwGQbiRDXhU3so82P0BCaF2aDDbUUm8,2816
-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=6qNZRYQkHtJ98_JMjwhqIGpeR4aR7rlxcCmr1nOHMzk,11258
+schemathesis/specs/openapi/parameters.py,sha256=hv1reNpSjVuzFbtMpSTwWZ75zcWTOy5ZE0ah6AVEqAo,14565
+schemathesis/specs/openapi/patterns.py,sha256=-1_0twbsyAiSbm0uTFipcXZTYgBY8UK6PriJkzhdET0,12038
 schemathesis/specs/openapi/references.py,sha256=YjD1xMlaYS7xLt6PrrVS20R72ZWHuFZFTa8Llzf54Rg,8808
-schemathesis/specs/openapi/schemas.py,sha256=UAukxlH2bVlpZNnx_4EzhDefPpsEtC2ieWz_x336-SQ,54906
+schemathesis/specs/openapi/schemas.py,sha256=VSeacEAVJJ6EKJ-llwOaX4aalzUTXyWP8s4wbxTqtWc,54720
 schemathesis/specs/openapi/security.py,sha256=6UWYMhL-dPtkTineqqBFNKca1i4EuoTduw-EOLeE0aQ,7149
-schemathesis/specs/openapi/serialization.py,sha256=JFxMqCr8YWwPT4BVrbvVytcAmkzGXyL1_Q1xR1JKBPs,11464
+schemathesis/specs/openapi/serialization.py,sha256=VdDLmeHqxlWM4cxQQcCkvrU6XurivolwEEaT13ohelA,11972
 schemathesis/specs/openapi/utils.py,sha256=ER4vJkdFVDIE7aKyxyYatuuHVRNutytezgE52pqZNE8,900
-schemathesis/specs/openapi/expressions/__init__.py,sha256=7W6Nv6sWusiBr7MxEhG_MoTKimuY6B7vJMGB80FPzV0,1691
+schemathesis/specs/openapi/expressions/__init__.py,sha256=hfuRtXD75tQFhzSo6QgDZ3zByyWeZRKevB8edszAVj4,2272
 schemathesis/specs/openapi/expressions/errors.py,sha256=YLVhps-sYcslgVaahfcUYxUSHlIfWL-rQMeT5PZSMZ8,219
 schemathesis/specs/openapi/expressions/extractors.py,sha256=Py3of3_vBACP4ljiZIcgd-xQCrWIpcMsfQFc0EtAUoA,470
 schemathesis/specs/openapi/expressions/lexer.py,sha256=LeVE6fgYT9-fIsXrv0-YrRHnI4VPisbwsexyh9Q5YU0,3982
-schemathesis/specs/openapi/expressions/nodes.py,sha256=Lfy1CcSSoYUnX-C_S5T-IqQOszRCteallLBaMnsNwVs,4076
-schemathesis/specs/openapi/expressions/parser.py,sha256=gM_Ob-TlTGxpgjZGRHNyPhBj1YAvRgRoSlNCrE7-djk,4452
+schemathesis/specs/openapi/expressions/nodes.py,sha256=YvpbAi8OFdb6RqqrqReGBeADpAmFaoyWN-lGiyYOXTc,4072
+schemathesis/specs/openapi/expressions/parser.py,sha256=e-ZxshrGE_5CVbgcZLYgdGSjdifgyzgKkLQp0dI0cJY,4503
 schemathesis/specs/openapi/negative/__init__.py,sha256=60QqVBTXPTsAojcf7GDs7v8WbOE_k3g_VC_DBeQUqBw,3749
 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=Tk9ahg6VVXwVw8yfFmrz9xhDWskBUaKEeBobdtd44HU,12020
+schemathesis/specs/openapi/stateful/__init__.py,sha256=0pu_iGjRiKuqUDN3ewz1zUOt6f1SdvSxVtHC5uK-CYw,14750
 schemathesis/specs/openapi/stateful/control.py,sha256=QaXLSbwQWtai5lxvvVtQV3BLJ8n5ePqSKB00XFxp-MA,3695
+schemathesis/specs/openapi/stateful/links.py,sha256=8oHpmb-yBa3kZKoCv9ytndpOp80dG1vVis2-EpbkeVA,11432
 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.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,,
+schemathesis-4.0.0a5.dist-info/METADATA,sha256=uftZyIy9oqwJ76F5tKRz5tMu-jlUwK2pg-JHxKxiUeg,12103
+schemathesis-4.0.0a5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.0.0a5.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.0.0a5.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-4.0.0a5.dist-info/RECORD,,