schemathesis 4.3.2__py3-none-any.whl → 4.3.4__py3-none-any.whl

schemathesis/checks.py

@@ -81,7 +81,7 @@ class CheckContext:
 
     def _record_case(self, *, parent_id: str, case: Case) -> None:
         if self._recorder is not None:
-            self._recorder.record_case(parent_id=parent_id, transition=None, case=case)
+            self._recorder.record_case(parent_id=parent_id, case=case, transition=None, is_transition_applied=False)
 
     def _record_response(self, *, case_id: str, response: Response) -> None:
         if self._recorder is not None:

schemathesis/cli/commands/run/context.py

@@ -112,7 +112,8 @@ class Statistic:
             if has_failures:
                 self.cases_with_failures += 1
 
-            if case.transition is None:
+            # Don't report extraction failures for inferred transitions
+            if case.transition is None or case.transition.is_inferred:
                 continue
             transition = case.transition
             parent = recorder.cases[transition.parent_id]

schemathesis/cli/commands/run/handlers/output.py

@@ -1048,7 +1048,11 @@ class OutputHandler(EventHandler):
             and event.status not in (Status.INTERRUPTED, Status.SKIP, None)
         ):
             assert self.stateful_tests_manager is not None
-            links_seen = {case.transition.id for case in event.recorder.cases.values() if case.transition is not None}
+            links_seen = {
+                case.transition.id
+                for case in event.recorder.cases.values()
+                if case.transition is not None and case.is_transition_applied
+            }
             self.stateful_tests_manager.update(links_seen, event.status)
             self._check_stateful_warnings(ctx, event)
 

schemathesis/engine/context.py

@@ -105,18 +105,7 @@ class EngineContext:
                 InferenceAlgorithm.DEPENDENCY_ANALYSIS
             )
         ):
-            graph = dependencies.analyze(self.schema)
-            for response_links in graph.iter_links():
-                operation = self.schema.get_operation_by_reference(response_links.producer_operation_ref)
-                response = operation.responses.get(response_links.status_code)
-                links = response.definition.setdefault(self.schema.adapter.links_keyword, {})
-
-                for link_name, definition in response_links.links.items():
-                    # Find unique name if collision exists
-                    final_name = _resolve_link_name_collision(link_name, links)
-                    links[final_name] = definition.to_openapi()
-                    injected += 1
-
+            injected += dependencies.inject_links(self.schema)
         return injected
 
     def stop(self) -> None:
@@ -171,16 +160,3 @@ class EngineContext:
             kwargs["proxies"] = {"all": proxy}
         self._transport_kwargs_cache[key] = kwargs
         return kwargs
-
-
-def _resolve_link_name_collision(proposed_name: str, existing_links: dict[str, Any]) -> str:
-    if proposed_name not in existing_links:
-        return proposed_name
-
-    # Name collision - find next available suffix
-    suffix = 0
-    while True:
-        candidate = f"{proposed_name}_{suffix}"
-        if candidate not in existing_links:
-            return candidate
-        suffix += 1

schemathesis/engine/phases/unit/_executor.py

@@ -385,7 +385,7 @@ def test_func(
     transport_kwargs: dict[str, Any],
     continue_on_failure: bool,
 ) -> None:
-    recorder.record_case(parent_id=None, transition=None, case=case)
+    recorder.record_case(parent_id=None, case=case, transition=None, is_transition_applied=False)
     try:
         response = case.call(**transport_kwargs)
     except (requests.Timeout, requests.ConnectionError, ChunkedEncodingError) as error:

schemathesis/engine/recorder.py

@@ -41,9 +41,16 @@ class ScenarioRecorder:
         self.checks = {}
         self.interactions = {}
 
-    def record_case(self, *, parent_id: str | None, transition: Transition | None, case: Case) -> None:
+    def record_case(
+        self, *, parent_id: str | None, case: Case, transition: Transition | None, is_transition_applied: bool
+    ) -> None:
         """Record a test case and its relationship to a parent, if applicable."""
-        self.cases[case.id] = CaseNode(value=case, parent_id=parent_id, transition=transition)
+        self.cases[case.id] = CaseNode(
+            value=case,
+            parent_id=parent_id,
+            transition=transition,
+            is_transition_applied=is_transition_applied,
+        )
 
     def record_response(self, *, case_id: str, response: Response) -> None:
         """Record the API response for a given test case."""
@@ -139,8 +146,9 @@ class CaseNode:
     # Transition may be absent if `parent_id` is present for cases when a case is derived inside a check
     # and outside of the implemented transition logic (e.g. Open API links)
     transition: Transition | None
+    is_transition_applied: bool
 
-    __slots__ = ("value", "parent_id", "transition")
+    __slots__ = ("value", "parent_id", "transition", "is_transition_applied")
 
 
 @dataclass

schemathesis/generation/stateful/state_machine.py

@@ -37,12 +37,16 @@ class StepInput:
 
     case: Case
     transition: Transition | None  # None for initial steps
+    # Whether this transition was actually applied
+    # Data extraction failures can prevent it, as well as transitions can be skipped in some cases
+    # to improve discovery of bugs triggered by non-stateful inputs during stateful testing
+    is_applied: bool
 
-    __slots__ = ("case", "transition")
+    __slots__ = ("case", "transition", "is_applied")
 
     @classmethod
     def initial(cls, case: Case) -> StepInput:
-        return cls(case=case, transition=None)
+        return cls(case=case, transition=None, is_applied=False)
 
 
 @dataclass
@@ -52,10 +56,11 @@ class Transition:
     # ID of the transition (e.g. link name)
     id: str
     parent_id: str
+    is_inferred: bool
     parameters: dict[str, dict[str, ExtractedParam]]
     request_body: ExtractedParam | None
 
-    __slots__ = ("id", "parent_id", "parameters", "request_body")
+    __slots__ = ("id", "parent_id", "is_inferred", "parameters", "request_body")
 
 
 @dataclass

schemathesis/specs/openapi/stateful/__init__.py

@@ -49,6 +49,8 @@ class OpenAPIStateMachine(APIStateMachine):
 
 # The proportion of negative tests generated for "root" transitions
 NEGATIVE_TEST_CASES_THRESHOLD = 10
+# How often some transition is skipped
+USE_TRANSITION_THRESHOLD = 85
 
 
 @dataclass
@@ -226,7 +228,7 @@ def classify_root_transitions(operations: list[APIOperation], transitions: ApiTr
         if not operation_transitions or not operation_transitions.outgoing:
             continue
 
-        if is_likely_root_transition(operation, operation_transitions):
+        if is_likely_root_transition(operation):
             roots.reliable.add(operation.label)
         else:
             roots.fallback.add(operation.label)
@@ -234,7 +236,7 @@ def classify_root_transitions(operations: list[APIOperation], transitions: ApiTr
     return roots
 
 
-def is_likely_root_transition(operation: APIOperation, transitions: OperationTransitions) -> bool:
+def is_likely_root_transition(operation: APIOperation) -> 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:
@@ -269,8 +271,12 @@ def into_step_input(
                 and isinstance(transition.request_body.value, Ok)
                 and transition.request_body.value.ok() is not UNRESOLVABLE
                 and not link.merge_body
+                and draw(st.integers(min_value=0, max_value=99)) < USE_TRANSITION_THRESHOLD
             ):
                 kwargs["body"] = transition.request_body.value.ok()
+
+            is_applied = bool(kwargs)
+
             cases = strategies.combine(
                 [target.as_strategy(generation_mode=mode, phase=TestPhase.STATEFUL, **kwargs) for mode in modes]
             )
@@ -280,24 +286,26 @@ def into_step_input(
                 and isinstance(transition.request_body.value, Ok)
                 and transition.request_body.value.ok() is not UNRESOLVABLE
                 and link.merge_body
+                and draw(st.integers(min_value=0, max_value=99)) < USE_TRANSITION_THRESHOLD
             ):
                 new = transition.request_body.value.ok()
                 if isinstance(case.body, dict) and isinstance(new, dict):
                     case.body = {**case.body, **new}
                 else:
                     case.body = new
+                is_applied = True
                 if case.meta and case.meta.generation.mode == GenerationMode.NEGATIVE:
                     # It is possible that the new body is now valid and the whole test case could be valid too
                     for alternative in case.operation.body:
                         if alternative.media_type == case.media_type:
                             schema = alternative.optimized_schema
-                            if jsonschema.validators.validator_for(schema)(schema).is_valid(new):
+                            if jsonschema.validators.validator_for(schema)(schema).is_valid(case.body):
                                 case.meta.components[ParameterLocation.BODY] = ComponentInfo(
                                     mode=GenerationMode.POSITIVE
                                 )
                                 if all(info.mode == GenerationMode.POSITIVE for info in case.meta.components.values()):
                                     case.meta.generation.mode = GenerationMode.POSITIVE
-            return StepInput(case=case, transition=transition)
+            return StepInput(case=case, transition=transition, is_applied=is_applied)
 
         return inner(output=_output)
 
@@ -322,10 +330,13 @@ def transition(*, name: str, target: Bundle, input: st.SearchStrategy[StepInput]
     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
+                parent_id=input.transition.parent_id,
+                transition=input.transition,
+                case=input.case,
+                is_transition_applied=input.is_applied,
             )
         else:
-            self.recorder.record_case(parent_id=None, transition=None, case=input.case)
+            self.recorder.record_case(parent_id=None, case=input.case, transition=None, is_transition_applied=False)
         self.control.record_step(input, self.recorder)
         return APIStateMachine._step(self, input=input)
 

schemathesis/specs/openapi/stateful/dependencies/__init__.py

@@ -5,7 +5,7 @@ Infers which operations must run before others by tracking resource creation and
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from schemathesis.core.compat import RefResolutionError
 from schemathesis.core.result import Ok
@@ -16,6 +16,7 @@ from schemathesis.specs.openapi.stateful.dependencies.models import (
     DefinitionSource,
     DependencyGraph,
     InputSlot,
+    NormalizedLink,
     OperationMap,
     OperationNode,
     OutputSlot,
@@ -25,6 +26,7 @@ from schemathesis.specs.openapi.stateful.dependencies.models import (
 from schemathesis.specs.openapi.stateful.dependencies.outputs import extract_outputs
 
 if TYPE_CHECKING:
+    from schemathesis.schemas import APIOperation
     from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
 
 __all__ = [
@@ -86,3 +88,85 @@ def analyze(schema: BaseOpenAPISchema) -> DependencyGraph:
         update_input_field_bindings(resource, operations)
 
     return DependencyGraph(operations=operations, resources=resources)
+
+
+def inject_links(schema: BaseOpenAPISchema) -> int:
+    injected = 0
+    graph = analyze(schema)
+    for response_links in graph.iter_links():
+        operation = schema.get_operation_by_reference(response_links.producer_operation_ref)
+        response = operation.responses.get(response_links.status_code)
+        links = response.definition.setdefault(schema.adapter.links_keyword, {})
+
+        # Normalize existing links once
+        if links:
+            normalized_existing = [_normalize_link(link, schema) for link in links.values()]
+        else:
+            normalized_existing = []
+
+        for link_name, definition in response_links.links.items():
+            inferred_link = definition.to_openapi()
+
+            # Check if duplicate exists
+            if normalized_existing:
+                if _normalize_link(inferred_link, schema) in normalized_existing:
+                    continue
+
+            # Find unique name if collision exists
+            final_name = _resolve_link_name_collision(link_name, links)
+            links[final_name] = inferred_link
+            injected += 1
+    return injected
+
+
+def _normalize_link(link: dict[str, Any], schema: BaseOpenAPISchema) -> NormalizedLink:
+    """Normalize a link definition for comparison."""
+    operation = _resolve_link_operation(link, schema)
+
+    normalized_params = _normalize_parameter_keys(link.get("parameters", {}), operation)
+
+    return NormalizedLink(
+        path=operation.path,
+        method=operation.method,
+        parameters=normalized_params,
+        request_body=link.get("requestBody", {}),
+    )
+
+
+def _normalize_parameter_keys(parameters: dict, operation: APIOperation) -> set[str]:
+    """Normalize parameter keys to location.name format."""
+    normalized = set()
+
+    for parameter_name in parameters.keys():
+        # If already has location prefix, use as-is
+        if "." in parameter_name:
+            normalized.add(parameter_name)
+            continue
+
+        # Find the parameter and prepend location
+        for parameter in operation.iter_parameters():
+            if parameter.name == parameter_name:
+                normalized.add(f"{parameter.location.value}.{parameter_name}")
+                break
+
+    return normalized
+
+
+def _resolve_link_operation(link: dict, schema: BaseOpenAPISchema) -> APIOperation:
+    """Resolve link to operation, handling both operationRef and operationId."""
+    if "operationRef" in link:
+        return schema.get_operation_by_reference(link["operationRef"])
+    return schema.get_operation_by_id(link["operationId"])
+
+
+def _resolve_link_name_collision(proposed_name: str, existing_links: dict[str, Any]) -> str:
+    """Find unique link name if collision exists."""
+    if proposed_name not in existing_links:
+        return proposed_name
+
+    suffix = 0
+    while True:
+        candidate = f"{proposed_name}_{suffix}"
+        if candidate not in existing_links:
+            return candidate
+        suffix += 1

schemathesis/specs/openapi/stateful/dependencies/inputs.py

@@ -2,6 +2,9 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Iterator
 
+from schemathesis.core import media_types
+from schemathesis.core.errors import MalformedMediaType
+from schemathesis.core.jsonschema.bundler import BUNDLE_STORAGE_KEY
 from schemathesis.core.parameters import ParameterLocation
 from schemathesis.specs.openapi.stateful.dependencies import naming
 from schemathesis.specs.openapi.stateful.dependencies.models import (
@@ -16,6 +19,7 @@ from schemathesis.specs.openapi.stateful.dependencies.resources import extract_r
 
 if TYPE_CHECKING:
     from schemathesis.core.compat import RefResolver
+    from schemathesis.specs.openapi.adapter.parameters import OpenApiBody
     from schemathesis.specs.openapi.schemas import APIOperation
 
 
@@ -32,7 +36,6 @@ def extract_inputs(
     Connects each parameter (e.g., `userId`) to its resource definition (`User`),
     creating placeholder resources if not yet discovered from their schemas.
     """
-    # Note: Currently limited to path parameters. Query / header / body will be supported in future releases.
     for param in operation.path_parameters:
         input_slot = _resolve_parameter_dependency(
             parameter_name=param.name,
@@ -46,6 +49,13 @@ def extract_inputs(
         if input_slot is not None:
             yield input_slot
 
+    for body in operation.body:
+        try:
+            if media_types.is_json(body.media_type):
+                yield from _resolve_body_dependencies(body=body, operation=operation, resources=resources)
+        except MalformedMediaType:
+            continue
+
 
 def _resolve_parameter_dependency(
     *,
@@ -152,6 +162,52 @@ def _find_resource_in_responses(
     return None
 
 
+def _resolve_body_dependencies(
+    *, body: OpenApiBody, operation: APIOperation, resources: ResourceMap
+) -> Iterator[InputSlot]:
+    schema = body.raw_schema
+    if not isinstance(schema, dict):
+        return
+
+    # Right now, the body schema comes bundled to dependency analysis
+    if BUNDLE_STORAGE_KEY in schema and "$ref" in schema:
+        schema_key = schema["$ref"].split("/")[-1]
+        resolved = schema[BUNDLE_STORAGE_KEY][schema_key]
+    else:
+        resolved = schema
+
+    # Inspect each property that could be a part of some other resource
+    properties = resolved.get("properties", {})
+    path = operation.path
+    for property_name in properties:
+        resource_name = naming.from_parameter(property_name, path)
+        if resource_name is None:
+            continue
+        resource = resources.get(resource_name)
+        if resource is None:
+            resource = ResourceDefinition.inferred_from_parameter(
+                name=resource_name,
+                parameter_name=property_name,
+            )
+            resources[resource_name] = resource
+            field = property_name
+        else:
+            field = (
+                naming.find_matching_field(
+                    parameter=property_name,
+                    resource=resource_name,
+                    fields=resource.fields,
+                )
+                or "id"
+            )
+        yield InputSlot(
+            resource=resource,
+            resource_field=field,
+            parameter_name=property_name,
+            parameter_location=ParameterLocation.BODY,
+        )
+
+
 def update_input_field_bindings(resource_name: str, operations: OperationMap) -> None:
     """Update input slots field bindings after resource definition was upgraded.
 

schemathesis/specs/openapi/stateful/dependencies/models.py

@@ -9,6 +9,7 @@ from typing_extensions import TypeAlias
 
 from schemathesis.core.parameters import ParameterLocation
 from schemathesis.core.transforms import encode_pointer
+from schemathesis.specs.openapi.stateful.links import SCHEMATHESIS_LINK_EXTENSION
 
 
 @dataclass
@@ -61,12 +62,21 @@ class DependencyGraph:
                                 output_slot.pointer, input_slot.resource_field, output_slot.cardinality
                             )
                             link_name = f"{consumer.method.capitalize()}{input_slot.resource.name}"
+                            parameters = {}
+                            request_body = {}
+                            # Data is extracted from response body
+                            if input_slot.parameter_location == ParameterLocation.BODY:
+                                request_body = {
+                                    input_slot.parameter_name: f"$response.body#{body_pointer}",
+                                }
+                            else:
+                                parameters = {
+                                    f"{input_slot.parameter_location.value}.{input_slot.parameter_name}": f"$response.body#{body_pointer}",
+                                }
                             links[link_name] = LinkDefinition(
                                 operation_ref=f"#/paths/{consumer_path}/{consumer.method}",
-                                parameters={
-                                    # Data is extracted from response body
-                                    f"{input_slot.parameter_location.value}.{input_slot.parameter_name}": f"$response.body#{body_pointer}",
-                                },
+                                parameters=parameters,
+                                request_body=request_body,
                             )
                     if links:
                         yield ResponseLinks(
@@ -136,14 +146,23 @@ class LinkDefinition:
     parameters: dict[str, str]
     """Parameter mappings (e.g., {'path.id': '$response.body#/id'})"""
 
-    __slots__ = ("operation_ref", "parameters")
+    request_body: dict[str, str]
+    """Request body (e.g., {'path.id': '$response.body#/id'})"""
+
+    __slots__ = ("operation_ref", "parameters", "request_body")
 
     def to_openapi(self) -> dict[str, Any]:
         """Convert to OpenAPI Links format."""
-        return {
+        links: dict[str, Any] = {
             "operationRef": self.operation_ref,
-            "parameters": self.parameters,
+            SCHEMATHESIS_LINK_EXTENSION: {"is_inferred": True},
         }
+        if self.parameters:
+            links["parameters"] = self.parameters
+        if self.request_body:
+            links["requestBody"] = self.request_body
+            links[SCHEMATHESIS_LINK_EXTENSION]["merge_body"] = True
+        return links
 
 
 @dataclass
@@ -177,6 +196,18 @@ class ResponseLinks:
         return {name: link_def.to_openapi() for name, link_def in self.links.items()}
 
 
+@dataclass
+class NormalizedLink:
+    """Normalized representation of a link."""
+
+    path: str
+    method: str
+    parameters: set[str]
+    request_body: Any
+
+    __slots__ = ("path", "method", "parameters", "request_body")
+
+
 class Cardinality(str, enum.Enum):
     """Whether there is one or many resources in a slot."""
 

schemathesis/specs/openapi/stateful/dependencies/naming.py

@@ -27,76 +27,122 @@ def from_path(path: str) -> str | None:
 
 
 IRREGULAR_TO_PLURAL = {
-    "echo": "echoes",
-    "dingo": "dingoes",
-    "volcano": "volcanoes",
-    "tornado": "tornadoes",
-    "torpedo": "torpedoes",
-    "genus": "genera",
-    "viscus": "viscera",
-    "stigma": "stigmata",
-    "stoma": "stomata",
-    "dogma": "dogmata",
-    "lemma": "lemmata",
+    "abuse": "abuses",
+    "alias": "aliases",
+    "analysis": "analyses",
     "anathema": "anathemata",
-    "ox": "oxen",
     "axe": "axes",
+    "base": "bases",
+    "bookshelf": "bookshelves",
+    "cache": "caches",
+    "canvas": "canvases",
+    "carve": "carves",
+    "case": "cases",
+    "cause": "causes",
+    "child": "children",
+    "course": "courses",
+    "criterion": "criteria",
+    "database": "databases",
+    "defense": "defenses",
+    "diagnosis": "diagnoses",
     "die": "dice",
-    "yes": "yeses",
-    "foot": "feet",
+    "dingo": "dingoes",
+    "disease": "diseases",
+    "dogma": "dogmata",
+    "dose": "doses",
     "eave": "eaves",
+    "echo": "echoes",
+    "enterprise": "enterprises",
+    "ephemeris": "ephemerides",
+    "excuse": "excuses",
+    "expense": "expenses",
+    "foot": "feet",
+    "franchise": "franchises",
+    "genus": "genera",
     "goose": "geese",
-    "tooth": "teeth",
-    "quiz": "quizzes",
-    "human": "humans",
-    "proof": "proofs",
-    "carve": "carves",
-    "valve": "valves",
-    "looey": "looies",
-    "thief": "thieves",
     "groove": "grooves",
-    "pickaxe": "pickaxes",
-    "passerby": "passersby",
-    "canvas": "canvases",
-    "use": "uses",
-    "case": "cases",
-    "vase": "vases",
+    "half": "halves",
+    "horse": "horses",
     "house": "houses",
+    "human": "humans",
+    "hypothesis": "hypotheses",
+    "index": "indices",
+    "knife": "knives",
+    "lemma": "lemmata",
+    "license": "licenses",
+    "life": "lives",
+    "loaf": "loaves",
+    "looey": "looies",
+    "man": "men",
+    "matrix": "matrices",
     "mouse": "mice",
-    "reuse": "reuses",
-    "abuse": "abuses",
-    "excuse": "excuses",
-    "cause": "causes",
+    "movie": "movies",
+    "nose": "noses",
+    "oasis": "oases",
+    "ox": "oxen",
+    "passerby": "passersby",
     "pause": "pauses",
-    "base": "bases",
+    "person": "people",
     "phase": "phases",
-    "rose": "roses",
-    "dose": "doses",
-    "nose": "noses",
-    "horse": "horses",
-    "course": "courses",
+    "phenomenon": "phenomena",
+    "pickaxe": "pickaxes",
+    "proof": "proofs",
+    "purchase": "purchases",
     "purpose": "purposes",
+    "quiz": "quizzes",
+    "radius": "radii",
+    "release": "releases",
     "response": "responses",
+    "reuse": "reuses",
+    "rose": "roses",
+    "scarf": "scarves",
+    "self": "selves",
     "sense": "senses",
+    "shelf": "shelves",
+    "size": "sizes",
+    "snooze": "snoozes",
+    "stigma": "stigmata",
+    "stoma": "stomata",
+    "synopsis": "synopses",
     "tense": "tenses",
-    "expense": "expenses",
-    "license": "licenses",
-    "defense": "defenses",
+    "thief": "thieves",
+    "tooth": "teeth",
+    "tornado": "tornadoes",
+    "torpedo": "torpedoes",
+    "use": "uses",
+    "valve": "valves",
+    "vase": "vases",
+    "verse": "verses",
+    "viscus": "viscera",
+    "volcano": "volcanoes",
+    "warehouse": "warehouses",
+    "wave": "waves",
+    "wife": "wives",
+    "wolf": "wolves",
+    "woman": "women",
+    "yes": "yeses",
+    "vie": "vies",
 }
 IRREGULAR_TO_SINGULAR = {v: k for k, v in IRREGULAR_TO_PLURAL.items()}
 UNCOUNTABLE = frozenset(
     [
+        "access",
+        "address",
         "adulthood",
         "advice",
         "agenda",
         "aid",
         "aircraft",
         "alcohol",
+        "alias",
         "ammo",
+        "analysis",
         "analytics",
         "anime",
+        "anonymous",
         "athletics",
         "audio",
+        "bias",
         "bison",
         "blood",
         "bream",
@@ -104,22 +150,31 @@ UNCOUNTABLE = frozenset(
         "butter",
         "carp",
         "cash",
+        "chaos",
         "chassis",
         "chess",
         "clothing",
         "cod",
         "commerce",
+        "compass",
+        "consensus",
         "cooperation",
         "corps",
+        "data",
         "debris",
+        "deer",
         "diabetes",
+        "diagnosis",
         "digestion",
         "elk",
         "energy",
+        "ephemeris",
         "equipment",
+        "eries",
         "excretion",
         "expertise",
         "firmware",
+        "fish",
         "flounder",
         "fun",
         "gallows",
@@ -141,12 +196,15 @@ UNCOUNTABLE = frozenset(
         "machinery",
         "mackerel",
         "mail",
+        "manga",
+        "means",
         "media",
+        "metadata",
         "mews",
+        "money",
         "moose",
-        "music",
         "mud",
-        "manga",
+        "music",
         "news",
         "only",
         "personnel",
@@ -156,6 +214,9 @@ UNCOUNTABLE = frozenset(
         "police",
         "pollution",
         "premises",
+        "progress",
+        "prometheus",
+        "radius",
         "rain",
         "research",
         "rice",
@@ -164,10 +225,13 @@ UNCOUNTABLE = frozenset(
         "series",
         "sewage",
         "shambles",
+        "sheep",
         "shrimp",
         "software",
+        "species",
         "staff",
         "swine",
+        "synopsis",
         "tennis",
         "traffic",
         "transportation",
@@ -178,22 +242,37 @@ UNCOUNTABLE = frozenset(
         "whiting",
         "wildebeest",
         "wildlife",
+        "wireless",
         "you",
-        "sheep",
-        "deer",
-        "species",
-        "series",
-        "means",
     ]
 )
 
 
+def _is_word_like(s: str) -> bool:
+    """Check if string looks like a word (not a path, technical term, etc)."""
+    # Skip empty or very short
+    if not s or len(s) < 2:
+        return False
+    # Skip if contains non-word characters (except underscore and hyphen)
+    if not all(c.isalpha() or c in ("_", "-") for c in s):
+        return False
+    # Skip if has numbers
+    return not any(c.isdigit() for c in s)
+
+
 def to_singular(word: str) -> str:
-    if word in UNCOUNTABLE:
+    if not _is_word_like(word):
+        return word
+    if word.lower() in UNCOUNTABLE:
+        return word
+    known_lower = IRREGULAR_TO_SINGULAR.get(word.lower())
+    if known_lower is not None:
+        # Preserve case: if input was capitalized, capitalize result
+        if word[0].isupper():
+            return known_lower.capitalize()
+        return known_lower
+    if word.endswith(("ss", "us")):
         return word
-    known = IRREGULAR_TO_SINGULAR.get(word)
-    if known is not None:
-        return known
     if word.endswith("ies") and len(word) > 3 and word[-4] not in "aeiou":
         return word[:-3] + "y"
     if word.endswith("sses"):
@@ -211,11 +290,18 @@ def to_singular(word: str) -> str:
 
 
 def to_plural(word: str) -> str:
-    if word in UNCOUNTABLE:
+    if not _is_word_like(word):
+        return word
+    if word.lower() in UNCOUNTABLE:
         return word
     known = IRREGULAR_TO_PLURAL.get(word)
     if known is not None:
         return known
+    known_lower = IRREGULAR_TO_PLURAL.get(word.lower())
+    if known_lower is not None:
+        if word[0].isupper():
+            return known_lower.capitalize()
+        return known_lower
     # Only change y -> ies after consonants (party -> parties, not day -> days)
     if word.endswith("y") and len(word) > 1 and word[-2] not in "aeiou":
         return word[:-1] + "ies"

schemathesis/specs/openapi/stateful/dependencies/schemas.py

@@ -3,14 +3,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Callable, Mapping
 
-from hypothesis_jsonschema._canonicalise import (
-    SCHEMA_KEYS as SCHEMA_KEYS_TUPLE,
-)
-from hypothesis_jsonschema._canonicalise import (
-    SCHEMA_OBJECT_KEYS as SCHEMA_OBJECT_KEYS_TUPLE,
-)
-from hypothesis_jsonschema._canonicalise import canonicalish, merged
-
 from schemathesis.core.jsonschema import ALL_KEYWORDS
 from schemathesis.core.jsonschema.bundler import BUNDLE_STORAGE_KEY, bundle
 from schemathesis.core.jsonschema.types import JsonSchema, JsonSchemaObject
@@ -23,8 +15,23 @@ if TYPE_CHECKING:
     from schemathesis.core.compat import RefResolver
 
 ROOT_POINTER = "/"
-SCHEMA_KEYS = frozenset(SCHEMA_KEYS_TUPLE)
-SCHEMA_OBJECT_KEYS = frozenset(SCHEMA_OBJECT_KEYS_TUPLE)
+SCHEMA_KEYS = frozenset(
+    {
+        "propertyNames",
+        "contains",
+        "if",
+        "items",
+        "oneOf",
+        "anyOf",
+        "additionalProperties",
+        "then",
+        "else",
+        "not",
+        "additionalItems",
+        "allOf",
+    }
+)
+SCHEMA_OBJECT_KEYS = frozenset({"dependencies", "properties", "patternProperties"})
 
 
 def resolve_all_refs(schema: JsonSchemaObject) -> dict[str, Any]:
@@ -48,6 +55,8 @@ def resolve_all_refs(schema: JsonSchemaObject) -> dict[str, Any]:
 
 
 def resolve_all_refs_inner(schema: JsonSchema, *, resolve: Callable[[str], dict[str, Any]]) -> dict[str, Any]:
+    from hypothesis_jsonschema._canonicalise import merged
+
     if schema is True:
         return {}
     if schema is False:
@@ -80,6 +89,8 @@ def resolve_all_refs_inner(schema: JsonSchema, *, resolve: Callable[[str], dict[
 
 def canonicalize(schema: dict[str, Any], resolver: RefResolver) -> Mapping[str, Any]:
     """Transform the input schema into its canonical-ish form."""
+    from hypothesis_jsonschema._canonicalise import canonicalish
+
     # Canonicalisation in `hypothesis_jsonschema` requires all references to be resovable and non-recursive
     # On the Schemathesis side bundling solves this problem
     bundled = bundle(schema, resolver, inline_recursive=True)

schemathesis/specs/openapi/stateful/inference.py

@@ -22,6 +22,7 @@ from werkzeug.routing import Map, MapAdapter, Rule
 
 from schemathesis.core.adapter import ResponsesContainer
 from schemathesis.core.transforms import encode_pointer
+from schemathesis.specs.openapi.stateful.links import SCHEMATHESIS_LINK_EXTENSION
 
 if TYPE_CHECKING:
     from schemathesis.engine.observations import LocationHeaderEntry
@@ -39,7 +40,7 @@ class OperationById:
     __slots__ = ("value", "method", "path")
 
     def to_link_base(self) -> dict[str, Any]:
-        return {"operationId": self.value, "x-inferred": True}
+        return {"operationId": self.value, SCHEMATHESIS_LINK_EXTENSION: {"is_inferred": True}}
 
 
 @dataclass(unsafe_hash=True)
@@ -53,7 +54,7 @@ class OperationByRef:
     __slots__ = ("value", "method", "path")
 
     def to_link_base(self) -> dict[str, Any]:
-        return {"operationRef": self.value, "x-inferred": True}
+        return {"operationRef": self.value, SCHEMATHESIS_LINK_EXTENSION: {"is_inferred": True}}
 
 
 OperationReference = Union[OperationById, OperationByRef]

schemathesis/specs/openapi/stateful/links.py

@@ -38,8 +38,19 @@ class OpenApiLink:
     parameters: list[NormalizedParameter]
     body: dict[str, Any] | NotSet
     merge_body: bool
-
-    __slots__ = ("name", "status_code", "source", "target", "parameters", "body", "merge_body", "_cached_extract")
+    is_inferred: bool
+
+    __slots__ = (
+        "name",
+        "status_code",
+        "source",
+        "target",
+        "parameters",
+        "body",
+        "merge_body",
+        "is_inferred",
+        "_cached_extract",
+    )
 
     def __init__(self, name: str, status_code: str, definition: dict[str, Any], source: APIOperation):
         from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
@@ -69,6 +80,7 @@ class OpenApiLink:
         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
+        self.is_inferred = extension.get("is_inferred", False) if extension else False
 
         if errors:
             raise InvalidTransition(
@@ -148,6 +160,7 @@ class OpenApiLink:
         return Transition(
             id=f"{self.source.label} -> [{self.status_code}] {self.name} -> {self.target.label}",
             parent_id=output.case.id,
+            is_inferred=self.is_inferred,
             parameters=self.extract_parameters(output),
             request_body=self.extract_body(output),
         )

{schemathesis-4.3.2.dist-info → schemathesis-4.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.3.2
+Version: 4.3.4
 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://github.com/schemathesis/schemathesis/blob/master/CHANGELOG.md

{schemathesis-4.3.2.dist-info → schemathesis-4.3.4.dist-info}/RECORD

@@ -1,6 +1,6 @@
 schemathesis/__init__.py,sha256=QqVUCBQr-RDEstgCZLsxzIa9HJslVSeijrm9gES4b_0,1423
 schemathesis/auths.py,sha256=JdEwPRS9WKmPcxzGXYYz9pjlIUMQYCfif7ZJU0Kde-I,16400
-schemathesis/checks.py,sha256=GTdejjXDooAOuq66nvCK3i-AMPBuU-_-aNeSeL9JIlc,6561
+schemathesis/checks.py,sha256=yyR219TQjLAieop5O2waEVLILF6_i10B8mkutd6QaCs,6590
 schemathesis/errors.py,sha256=K3irHIZkrBH2-9LIjlgXlm8RNC41Nffd39ncfwagUvw,1053
 schemathesis/filters.py,sha256=IevPA5A04GfRLLjmkFLZ0CLhjNO3RmpZq_yw6MqjLIA,13515
 schemathesis/hooks.py,sha256=q2wqYNgpMCO8ImSBkbrWDSwN0BSELelqJMgAAgGvv2M,14836
@@ -13,7 +13,7 @@ schemathesis/cli/core.py,sha256=ue7YUdVo3YvuzGL4s6i62NL6YqNDeVPBSnQ1znrvG2w,480
 schemathesis/cli/commands/__init__.py,sha256=DNzKEnXu7GjGSVe0244ZErmygUBA3nGSyVY6JP3ixD0,3740
 schemathesis/cli/commands/data.py,sha256=_ALywjIeCZjuaoDQFy-Kj8RZkEGqXd-Y95O47h8Jszs,171
 schemathesis/cli/commands/run/__init__.py,sha256=_ApiSVh9q-TsJQ_-IiVBNnLCtTCDMTnOLwuJhOvbCp4,18925
-schemathesis/cli/commands/run/context.py,sha256=taegOHWc_B-HDwiU1R9Oi4q57mdfLXc-B954QUj8t7A,7984
+schemathesis/cli/commands/run/context.py,sha256=Usa89aSPf8Uv-2m-nWr0ghvTKM1ZZehALBI0m_lFHv4,8087
 schemathesis/cli/commands/run/events.py,sha256=ew0TQOc9T2YBZynYWv95k9yfAk8-hGuZDLMxjT8EhvY,1595
 schemathesis/cli/commands/run/executor.py,sha256=_koznTX0DoELPN_1mxr9K_Qg7-9MPXWdld1MFn3YG_Y,5329
 schemathesis/cli/commands/run/filters.py,sha256=pzkNRcf5vLPSsMfnvt711GNzRSBK5iZIFjPA0fiH1N4,1701
@@ -23,7 +23,7 @@ schemathesis/cli/commands/run/handlers/__init__.py,sha256=TPZ3KdGi8m0fjlN0GjA31M
 schemathesis/cli/commands/run/handlers/base.py,sha256=qUtDvtr3F6were_BznfnaPpMibGJMnQ5CA9aEzcIUBc,1306
 schemathesis/cli/commands/run/handlers/cassettes.py,sha256=LzvQp--Ub5MXF7etet7fQD0Ufloh1R0j2X1o9dT8Z4k,19253
 schemathesis/cli/commands/run/handlers/junitxml.py,sha256=qiFvM4-SlM67sep003SkLqPslzaEb4nOm3bkzw-DO-Q,2602
-schemathesis/cli/commands/run/handlers/output.py,sha256=TwK82zNpIZ7Q76ggTp8gcW2clzrw0WBmHFJMcvYL1nE,63927
+schemathesis/cli/commands/run/handlers/output.py,sha256=jWrqEkEQPO2kgzxOffZacqxH6r7dkDmAx0ep9GA3NU8,64020
 schemathesis/cli/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/cli/ext/fs.py,sha256=dHQYBjQozQmuSSfXVp-2KWFK0ESOb_w-lV2SptfMfco,461
 schemathesis/cli/ext/groups.py,sha256=kQ37t6qeArcKaY2y5VxyK3_KwAkBKCVm58IYV8gewds,2720
@@ -76,20 +76,20 @@ schemathesis/core/jsonschema/types.py,sha256=C7f9g8yKFuoxC5_0YNIh8QAyGU0-tj8pzTM
 schemathesis/core/output/__init__.py,sha256=SiHqONFskXl73AtP5dV29L14nZoKo7B-IeG52KZB32M,1446
 schemathesis/core/output/sanitization.py,sha256=Ev3tae8dVwsYd7yVb2_1VBFYs92WFsQ4Eu1fGaymItE,2013
 schemathesis/engine/__init__.py,sha256=QaFE-FinaTAaarteADo2RRMJ-Sz6hZB9TzD5KjMinIA,706
-schemathesis/engine/context.py,sha256=iMyyum60AmZlX1reghxzCW6A_dDA43RA3NXJZqruHv8,6821
+schemathesis/engine/context.py,sha256=YaBfwTUyTCZaMq7-jtAKFQj-Eh1aQdbZ0UNcC5d_epU,5792
 schemathesis/engine/control.py,sha256=FXzP8dxL47j1Giqpy2-Bsr_MdMw9YiATSK_UfpFwDtk,1348
 schemathesis/engine/core.py,sha256=qlPHnZVq2RrUe93fOciXd1hC3E1gVyF2BIWMPMeLIj8,6655
 schemathesis/engine/errors.py,sha256=FlpEk44WRLzRkdK9m37z93EQuY3kbeMIQRGwU5e3Qm4,19005
 schemathesis/engine/events.py,sha256=jpCtMkWWfNe2jUeZh_Ly_wfZEF44EOodL-I_W4C9rgg,6594
 schemathesis/engine/observations.py,sha256=T-5R8GeVIqvxpCMxc6vZ04UUxUTx3w7689r3Dc6bIcE,1416
-schemathesis/engine/recorder.py,sha256=K3HfMARrT5mPWXPnYebjjcq5CcsBRhMrtZwEL9_Lvtg,8432
+schemathesis/engine/recorder.py,sha256=KWyWkGkZxIwSDU92jNWCJXU4G4E5WqfhLM6G1Yi7Jyo,8636
 schemathesis/engine/phases/__init__.py,sha256=7Yp7dQbd6-K9pavIJeURg6jiNeMpW8UU-Iiikr668ts,3278
 schemathesis/engine/phases/probes.py,sha256=YogjJcZJcTMS8sMdGnG4oXKmMUj_4r_J7MY-BBJtCRU,5690
 schemathesis/engine/phases/stateful/__init__.py,sha256=Lz1rgNqCfUSIz173XqCGsiMuUI5bh4L-RIFexU1-c_Q,2461
 schemathesis/engine/phases/stateful/_executor.py,sha256=yRpUJqKLTKMVRy7hEXPwmI23CtgGIprz341lCJwvTrU,15613
 schemathesis/engine/phases/stateful/context.py,sha256=A7X1SLDOWFpCvFN9IiIeNVZM0emjqatmJL_k9UsO7vM,2946
 schemathesis/engine/phases/unit/__init__.py,sha256=9dDcxyj887pktnE9YDIPNaR-vc7iqKQWIrFr77SbUTQ,8786
-schemathesis/engine/phases/unit/_executor.py,sha256=UkOcmR23rl5PSIuNMjthZxadbAOHYSmTWft7Wa91yLs,17206
+schemathesis/engine/phases/unit/_executor.py,sha256=YDibV3lkC2UMHLvh1FSmnlaQ-SJS-R0MU2qEF4NBbf0,17235
 schemathesis/engine/phases/unit/_pool.py,sha256=iU0hdHDmohPnEv7_S1emcabuzbTf-Cznqwn0pGQ5wNQ,2480
 schemathesis/generation/__init__.py,sha256=tvNO2FLiY8z3fZ_kL_QJhSgzXfnT4UqwSXMHCwfLI0g,645
 schemathesis/generation/case.py,sha256=Qc2_5JrWuUkCzAFTTgnVqNUJ2sioslmINTXiY7nHHgA,12326
@@ -105,7 +105,7 @@ schemathesis/generation/hypothesis/given.py,sha256=sTZR1of6XaHAPWtHx2_WLlZ50M8D5
 schemathesis/generation/hypothesis/reporting.py,sha256=uDVow6Ya8YFkqQuOqRsjbzsbyP4KKfr3jA7ZaY4FuKY,279
 schemathesis/generation/hypothesis/strategies.py,sha256=RurE81E06d99YKG48dizy9346ayfNswYTt38zewmGgw,483
 schemathesis/generation/stateful/__init__.py,sha256=s7jiJEnguIj44IsRyMi8afs-8yjIUuBbzW58bH5CHjs,1042
-schemathesis/generation/stateful/state_machine.py,sha256=3oAGpn46adNJx3sp5ym9e30SyYOjJGiEqenDZ5gWtBY,8803
+schemathesis/generation/stateful/state_machine.py,sha256=25kkYImw5byNwuTtt97aNE3kTHAF8rZ-p3ax_bmd3JI,9135
 schemathesis/graphql/__init__.py,sha256=_eO6MAPHGgiADVGRntnwtPxmuvk666sAh-FAU4cG9-0,326
 schemathesis/graphql/checks.py,sha256=IADbxiZjgkBWrC5yzHDtohRABX6zKXk5w_zpWNwdzYo,3186
 schemathesis/graphql/loaders.py,sha256=2tgG4HIvFmjHLr_KexVXnT8hSBM-dKG_fuXTZgE97So,9445
@@ -160,17 +160,17 @@ schemathesis/specs/openapi/negative/__init__.py,sha256=B78vps314fJOMZwlPdv7vUHo7
 schemathesis/specs/openapi/negative/mutations.py,sha256=9U352xJsdZBR-Zfy1V7_X3a5i91LIUS9Zqotrzp3BLA,21000
 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=nD5f9pP2Rx2DKIeXtbc_KqUukC4Nf2834cHeOp52byM,16247
+schemathesis/specs/openapi/stateful/__init__.py,sha256=CQx2WJ3mKn5qmYRc90DqsG9w3Gx7DrB60S9HFz81STY,16663
 schemathesis/specs/openapi/stateful/control.py,sha256=QaXLSbwQWtai5lxvvVtQV3BLJ8n5ePqSKB00XFxp-MA,3695
-schemathesis/specs/openapi/stateful/inference.py,sha256=9o9V-UUpphW7u_Kqz5MCp1_JXS2H_rcAZwz0bwJnmbI,9637
-schemathesis/specs/openapi/stateful/links.py,sha256=G6vqW6JFOdhF044ZjG6PsSwAHU1yP4E3FolcNFE55NM,7918
-schemathesis/specs/openapi/stateful/dependencies/__init__.py,sha256=epBYtVw7q9mkV-UtlJNbfJQgwAs9d5jkOJYkyEeUMvE,3348
-schemathesis/specs/openapi/stateful/dependencies/inputs.py,sha256=5niLSz7-wl-sP9cJdnYBItwEeLuzJr3nw4XIMT3yt98,6764
-schemathesis/specs/openapi/stateful/dependencies/models.py,sha256=4MXJzCat1bU-tmwAM7OH2dFBys_YHCJw9wTgd9Hib3c,9728
-schemathesis/specs/openapi/stateful/dependencies/naming.py,sha256=1aaa8vc56tsyOAKAvD8oPk55S-qbzrCBYe1kCk3Y9VY,9052
+schemathesis/specs/openapi/stateful/inference.py,sha256=B99jSTDVi2yKxU7-raIb91xpacOrr0nZkEZY5Ej3eCY,9783
+schemathesis/specs/openapi/stateful/links.py,sha256=SSA66mU50FFBz7e6sA37CfL-Vt0OY3gont72oFSvZYU,8163
+schemathesis/specs/openapi/stateful/dependencies/__init__.py,sha256=IE8WIeWNhQoNCwiivQKoDe3GD_aobxmjQYvarwxp_1M,6379
+schemathesis/specs/openapi/stateful/dependencies/inputs.py,sha256=DJDDCq73OYvCIPMxLKXJGTQGloNf6z6mgxjzjD0kJHA,8739
+schemathesis/specs/openapi/stateful/dependencies/models.py,sha256=s8_RBwpciAmPMISp5WDabqEuX7dXW84S-QWnhkodz6g,10938
+schemathesis/specs/openapi/stateful/dependencies/naming.py,sha256=MGoyh1bfw2SoKzdbzpHxed9LHMjokPJTU_YErZaF-Ls,11396
 schemathesis/specs/openapi/stateful/dependencies/outputs.py,sha256=zvVUfQWNIuhMkKDpz5hsVGkkvkefLt1EswpJAnHajOw,1186
 schemathesis/specs/openapi/stateful/dependencies/resources.py,sha256=7E2Z6LvomSRrp_0vCD_adzoux0wBLEjKi_EiSqiN43U,9664
-schemathesis/specs/openapi/stateful/dependencies/schemas.py,sha256=pNV2GibNW8042KrdfUQBdJEkGj_dd84bTHbqunba48k,13976
+schemathesis/specs/openapi/stateful/dependencies/schemas.py,sha256=yMu13RsXIPDeZT1tATTxI1vkpYhjs-XFSFEvx3_Xh_Q,14094
 schemathesis/specs/openapi/types/__init__.py,sha256=VPsWtLJle__Kodw_QqtQ3OuvBzBcCIKsTOrXy3eA7OU,66
 schemathesis/specs/openapi/types/v3.py,sha256=Vondr9Amk6JKCIM6i6RGcmTUjFfPgOOqzBXqerccLpo,1468
 schemathesis/transport/__init__.py,sha256=6yg_RfV_9L0cpA6qpbH-SL9_3ggtHQji9CZrpIkbA6s,5321
@@ -179,8 +179,8 @@ schemathesis/transport/prepare.py,sha256=erYXRaxpQokIDzaIuvt_csHcw72iHfCyNq8VNEz
 schemathesis/transport/requests.py,sha256=wriRI9fprTplE_qEZLEz1TerX6GwkE3pwr6ZnU2o6vQ,10648
 schemathesis/transport/serialization.py,sha256=GwO6OAVTmL1JyKw7HiZ256tjV4CbrRbhQN0ep1uaZwI,11157
 schemathesis/transport/wsgi.py,sha256=kQtasFre6pjdJWRKwLA_Qb-RyQHCFNpaey9ubzlFWKI,5907
-schemathesis-4.3.2.dist-info/METADATA,sha256=t4XVoDj7Tst0-FT19wxnLdQ3wVtaveCp18GMoa1ZzU4,8540
-schemathesis-4.3.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.3.2.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.3.2.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.3.2.dist-info/RECORD,,
+schemathesis-4.3.4.dist-info/METADATA,sha256=Su_dAAs7RpHERfreFwrore0Nx6LqQJQB60HlC-C8TAQ,8540
+schemathesis-4.3.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.3.4.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.3.4.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.3.4.dist-info/RECORD,,