schemathesis 4.2.2__py3-none-any.whl → 4.3.1__py3-none-any.whl

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

@@ -0,0 +1,420 @@
+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
+from schemathesis.core.transforms import encode_pointer
+from schemathesis.specs.openapi.adapter.parameters import resource_name_from_ref
+from schemathesis.specs.openapi.adapter.references import maybe_resolve
+from schemathesis.specs.openapi.stateful.dependencies import naming
+
+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)
+
+
+def resolve_all_refs(schema: JsonSchemaObject) -> dict[str, Any]:
+    if not schema:
+        return schema
+    bundled = schema.get(BUNDLE_STORAGE_KEY, {})
+
+    resolved_cache: dict[str, dict[str, Any]] = {}
+
+    def resolve(ref: str) -> dict[str, Any]:
+        # All references here are bundled, therefore it is safe to avoid full reference resolving
+        if ref in resolved_cache:
+            return resolved_cache[ref]
+        key = ref.split("/")[-1]
+        # No clone needed, as it will be cloned inside `merged`
+        result = resolve_all_refs_inner(bundled[key], resolve=resolve)
+        resolved_cache[ref] = result
+        return result
+
+    return resolve_all_refs_inner(schema, resolve=resolve)
+
+
+def resolve_all_refs_inner(schema: JsonSchema, *, resolve: Callable[[str], dict[str, Any]]) -> dict[str, Any]:
+    if schema is True:
+        return {}
+    if schema is False:
+        return {"not": {}}
+    if not schema:
+        return schema
+
+    reference = schema.get("$ref")
+    if reference is not None:
+        resolved = resolve(reference)
+        if len(schema) == 1 or (len(schema) == 2 and BUNDLE_STORAGE_KEY in schema):
+            return resolved
+        del schema["$ref"]
+        schema.pop(BUNDLE_STORAGE_KEY, None)
+        schema.pop("example", None)
+        return merged([resolve_all_refs_inner(schema, resolve=resolve), resolved])  # type: ignore
+
+    for key, value in schema.items():
+        if key in SCHEMA_KEYS:
+            if isinstance(value, list):
+                schema[key] = [resolve_all_refs_inner(v, resolve=resolve) if isinstance(v, dict) else v for v in value]
+            elif isinstance(value, dict):
+                schema[key] = resolve_all_refs_inner(value, resolve=resolve)
+        if key in SCHEMA_OBJECT_KEYS:
+            schema[key] = {
+                k: resolve_all_refs_inner(v, resolve=resolve) if isinstance(v, dict) else v for k, v in value.items()
+            }
+    return schema
+
+
+def canonicalize(schema: dict[str, Any], resolver: RefResolver) -> Mapping[str, Any]:
+    """Transform the input schema into its canonical-ish form."""
+    # 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)
+    canonicalized = canonicalish(bundled)
+    resolved = resolve_all_refs(canonicalized)
+    resolved.pop(BUNDLE_STORAGE_KEY, None)
+    if "allOf" in resolved or "anyOf" in resolved or "oneOf" in resolved:
+        return canonicalish(resolved)
+    return resolved
+
+
+def try_unwrap_composition(schema: Mapping[str, Any], resolver: RefResolver) -> Mapping[str, Any]:
+    """Unwrap oneOf/anyOf if we can safely extract a single schema."""
+    keys = ("anyOf", "oneOf")
+    composition_key = None
+    for key in keys:
+        if key in schema:
+            composition_key = key
+            break
+
+    if composition_key is None:
+        return schema
+
+    alternatives = schema[composition_key]
+
+    if not isinstance(alternatives, list):
+        return schema
+
+    # Filter to interesting alternatives
+    interesting = _filter_composition_alternatives(alternatives, resolver)
+
+    # If no interesting alternatives, return original
+    if not interesting:
+        return schema
+
+    # If exactly one interesting alternative, unwrap it
+    if len(interesting) == 1:
+        return interesting[0]
+
+    # Pick the first one
+    # TODO: Support multiple alternatives
+    return interesting[0]
+
+
+def try_unwrap_all_of(schema: Mapping[str, Any]) -> Mapping[str, Any]:
+    alternatives = schema.get("allOf")
+    if not isinstance(alternatives, list):
+        return schema
+
+    interesting = []
+
+    for subschema in alternatives:
+        if isinstance(subschema, dict) and _is_interesting_schema(subschema):
+            interesting.append(subschema)
+
+    if len(interesting) == 1:
+        return interesting[0]
+    return schema
+
+
+def _filter_composition_alternatives(alternatives: list[dict], resolver: RefResolver) -> list[dict]:
+    """Filter oneOf/anyOf alternatives to keep only interesting schemas."""
+    interesting = []
+
+    for alt_schema in alternatives:
+        _, resolved = maybe_resolve(alt_schema, resolver, "")
+
+        if _is_interesting_schema(resolved):
+            # Keep original (with $ref)
+            interesting.append(alt_schema)
+
+    return interesting
+
+
+def _is_interesting_schema(schema: Mapping[str, Any]) -> bool:
+    """Check if a schema represents interesting structured data."""
+    # Has $ref - definitely interesting (references a named schema)
+    if "$ref" in schema:
+        return True
+
+    ty = schema.get("type")
+
+    # Primitives are not interesting
+    if ty in {"string", "number", "integer", "boolean", "null"}:
+        return False
+
+    # Arrays - check items
+    if ty == "array":
+        items = schema.get("items")
+        if not isinstance(items, dict):
+            return False
+        # Recursively check if items are interesting
+        return _is_interesting_schema(items)
+
+    # allOf/anyOf/oneOf - interesting (composition)
+    if any(key in schema for key in ["allOf", "anyOf", "oneOf"]):
+        return True
+
+    # Objects (or untyped) - check if they have any keywords
+    return bool(set(schema).intersection(ALL_KEYWORDS))
+
+
+@dataclass
+class UnwrappedSchema:
+    """Result of wrapper pattern detection."""
+
+    pointer: str
+    schema: Mapping[str, Any]
+    ref: str | None
+
+    __slots__ = ("pointer", "schema", "ref")
+
+
+def unwrap_schema(
+    schema: Mapping[str, Any], path: str, parent_ref: str | None, resolver: RefResolver
+) -> UnwrappedSchema:
+    # Array at root
+    if schema.get("type") == "array":
+        return UnwrappedSchema(pointer="/", schema=schema, ref=None)
+
+    properties = schema.get("properties", {})
+
+    # HAL _embedded (Spring-specific)
+    hal_field = _detect_hal_embedded(schema)
+    if hal_field:
+        embedded_schema = properties["_embedded"]
+        _, resolved_embedded = maybe_resolve(embedded_schema, resolver, "")
+        resource_schema = resolved_embedded.get("properties", {}).get(hal_field, {})
+        _, resolved_resource = maybe_resolve(resource_schema, resolver, "")
+
+        return UnwrappedSchema(
+            pointer=f"/_embedded/{encode_pointer(hal_field)}", schema=resolved_resource, ref=resource_schema.get("$ref")
+        )
+
+    # Pagination wrapper
+    array_field = _is_pagination_wrapper(schema=schema, path=path, parent_ref=parent_ref, resolver=resolver)
+    if array_field:
+        array_schema = properties[array_field]
+        _, resolved = maybe_resolve(array_schema, resolver, "")
+        pointer = f"/{encode_pointer(array_field)}"
+
+        # Try to unwrap one more time
+        if resolved.get("type") == "array" or "items" in resolved:
+            nested_items = resolved.get("items")
+            if isinstance(nested_items, dict):
+                _, resolved_items = maybe_resolve(nested_items, resolver, "")
+                external_tag = _detect_externally_tagged_pattern(resolved_items, path)
+                if external_tag:
+                    nested_properties = resolved_items["properties"][external_tag]
+                    _, resolved = maybe_resolve(nested_properties, resolver, "")
+                    pointer += f"/{encode_pointer(external_tag)}"
+
+        return UnwrappedSchema(pointer=pointer, schema=resolved, ref=array_schema.get("$ref"))
+
+    # External tag
+    external_tag = _detect_externally_tagged_pattern(schema, path)
+    if external_tag:
+        tagged_schema = properties[external_tag]
+        _, resolved_tagged = maybe_resolve(tagged_schema, resolver, "")
+
+        resolved = try_unwrap_all_of(resolved_tagged)
+        ref = resolved.get("$ref") or resolved_tagged.get("$ref") or tagged_schema.get("$ref")
+
+        _, resolved = maybe_resolve(resolved, resolver, "")
+        return UnwrappedSchema(pointer=f"/{encode_pointer(external_tag)}", schema=resolved, ref=ref)
+
+    # No wrapper - single object at root
+    return UnwrappedSchema(pointer="/", schema=schema, ref=schema.get("$ref"))
+
+
+def _detect_hal_embedded(schema: Mapping[str, Any]) -> str | None:
+    """Detect HAL _embedded pattern.
+
+    Spring Data REST uses: {_embedded: {users: [...]}}
+    """
+    properties = schema.get("properties", {})
+    embedded = properties.get("_embedded")
+
+    if not isinstance(embedded, dict):
+        return None
+
+    embedded_properties = embedded.get("properties", {})
+
+    # Find array properties in _embedded
+    for name, subschema in embedded_properties.items():
+        if isinstance(subschema, dict) and subschema.get("type") == "array":
+            # Found array in _embedded
+            return name
+
+    return None
+
+
+def _is_pagination_wrapper(
+    schema: Mapping[str, Any], path: str, parent_ref: str | None, resolver: RefResolver
+) -> str | None:
+    """Detect if schema is a pagination wrapper."""
+    properties = schema.get("properties", {})
+
+    if not properties:
+        return None
+
+    metadata_fields = frozenset(["links", "errors"])
+
+    # Find array properties
+    arrays = []
+    for name, subschema in properties.items():
+        if name in metadata_fields:
+            continue
+        if isinstance(subschema, dict):
+            _, subschema = maybe_resolve(subschema, resolver, "")
+            if subschema.get("type") == "array":
+                arrays.append(name)
+
+    # Must have exactly one array property
+    if len(arrays) != 1:
+        return None
+
+    array_field = arrays[0]
+
+    # Check if array field name matches common patterns
+    common_data_fields = {"data", "items", "results", "value", "content", "elements", "records", "list"}
+
+    if parent_ref:
+        resource_name = resource_name_from_ref(parent_ref)
+        resource_name = naming.strip_affixes(resource_name, ["get", "create", "list", "delete"], ["response"])
+        common_data_fields.add(resource_name.lower())
+
+    if array_field.lower() not in common_data_fields:
+        # Check if field name matches resource-specific pattern
+        # Example: path="/items/runner-groups" -> resource="RunnerGroup" -> "runner_groups"
+        resource_name_from_path = naming.from_path(path)
+        if resource_name_from_path is None:
+            return None
+
+        candidate = naming.to_plural(naming.to_snake_case(resource_name_from_path))
+        if array_field.lower() != candidate:
+            # Field name doesn't match resource pattern
+            return None
+
+    # Check for pagination metadata indicators
+    others = [p for p in properties if p != array_field]
+
+    pagination_indicators = {
+        "count",
+        "total",
+        "totalcount",
+        "total_count",
+        "totalelements",
+        "total_elements",
+        "page",
+        "pagenumber",
+        "page_number",
+        "currentpage",
+        "current_page",
+        "next",
+        "previous",
+        "prev",
+        "nextpage",
+        "prevpage",
+        "nextpageurl",
+        "prevpageurl",
+        "next_page_url",
+        "prev_page_url",
+        "next_page_token",
+        "nextpagetoken",
+        "cursor",
+        "nextcursor",
+        "next_cursor",
+        "nextlink",
+        "next_link",
+        "endcursor",
+        "hasmore",
+        "has_more",
+        "hasnextpage",
+        "haspreviouspage",
+        "pagesize",
+        "page_size",
+        "perpage",
+        "per_page",
+        "limit",
+        "size",
+        "pageinfo",
+        "page_info",
+        "pagination",
+        "links",
+        "meta",
+    }
+
+    # Check if any other property looks like pagination metadata
+    has_pagination_metadata = any(
+        prop.lower().replace("_", "").replace("-", "") in pagination_indicators for prop in others
+    )
+
+    # Either there is pagination metadata or the wrapper has just items + some other field which is likely an unrecognized metadata
+    if has_pagination_metadata or len(properties) <= 2:
+        return array_field
+
+    return None
+
+
+def _detect_externally_tagged_pattern(schema: Mapping[str, Any], path: str) -> str | None:
+    """Detect externally tagged resource pattern.
+
+    Pattern: {ResourceName: [...]} or {resourceName: [...]}
+
+    Examples:
+        - GET /merchants -> {"Merchants": [...]}
+        - GET /users -> {"Users": [...]} or {"users": [...]}
+
+    """
+    properties = schema.get("properties", {})
+
+    if not properties:
+        return None
+
+    resource_name = naming.from_path(path)
+
+    if not resource_name:
+        return None
+
+    # For example, for `DataRequest`:
+    possible_names = {
+        # `datarequest`
+        resource_name.lower(),
+        # `datarequests`
+        naming.to_plural(resource_name.lower()),
+        # `data_request`
+        naming.to_snake_case(resource_name),
+    }
+
+    for name, subschema in properties.items():
+        if name.lower() not in possible_names:
+            continue
+
+        if isinstance(subschema, dict):
+            return name
+
+    return None

schemathesis/specs/openapi/stateful/inference.py

@@ -21,6 +21,7 @@ from werkzeug.exceptions import MethodNotAllowed, NotFound
 from werkzeug.routing import Map, MapAdapter, Rule
 
 from schemathesis.core.adapter import ResponsesContainer
+from schemathesis.core.transforms import encode_pointer
 
 if TYPE_CHECKING:
     from schemathesis.engine.observations import LocationHeaderEntry
@@ -95,7 +96,7 @@ class LinkInferencer:
             if operation_id:
                 operation = OperationById(operation_id, method=method, path=path)
             else:
-                encoded_path = path.replace("~", "~0").replace("/", "~1")
+                encoded_path = encode_pointer(path)
                 operation = OperationByRef(f"#/paths/{encoded_path}/{method}", method=method, path=path)
 
             operations.append(operation)

{schemathesis-4.2.2.dist-info → schemathesis-4.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.2.2
+Version: 4.3.1
 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.2.2.dist-info → schemathesis-4.3.1.dist-info}/RECORD

@@ -28,7 +28,7 @@ schemathesis/cli/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 schemathesis/cli/ext/fs.py,sha256=dHQYBjQozQmuSSfXVp-2KWFK0ESOb_w-lV2SptfMfco,461
 schemathesis/cli/ext/groups.py,sha256=kQ37t6qeArcKaY2y5VxyK3_KwAkBKCVm58IYV8gewds,2720
 schemathesis/cli/ext/options.py,sha256=6yYwZNJL__FCEEL7kI3r5MbVmbp3ZeQjm7DrZ6J_h7s,3347
-schemathesis/config/__init__.py,sha256=Ff-mcdwCatFIS_WpJNpSe-gl7ez0-m_s4F2_4Teg2eM,6240
+schemathesis/config/__init__.py,sha256=fXE_NxvAxhyGag0_gC3xJwUrUkxZz4OKANQ1nYuGFQk,6311
 schemathesis/config/_auth.py,sha256=83RLVPm97W2thbn-yi01Rt94YwOxLG_a5VoxhEfjUjs,1528
 schemathesis/config/_checks.py,sha256=F0r16eSSiICvoiTUkNNOE2PH73EGd8bikoeZdME_3Yw,10763
 schemathesis/config/_diff_base.py,sha256=U7wuE4480EjP3K16mfC528TP5q7Q5IwAZwZLqRIrS1E,4300
@@ -39,13 +39,13 @@ schemathesis/config/_health_check.py,sha256=zC9inla5ibMBlEy5WyM4_TME7ju_KH3Bwfo2
 schemathesis/config/_operations.py,sha256=JvfMkieYBkbEmZRb4cTvQLfvHQLhmsxa3GXzgjOtmFc,12383
 schemathesis/config/_output.py,sha256=3G9SOi-4oNcQPHeNRG3HggFCwvcKOW1kF28a9m0H-pU,4434
 schemathesis/config/_parameters.py,sha256=i76Hwaf834fBAMmtKfKTl1SFCicJ-Y-5tZt5QNGW2fA,618
-schemathesis/config/_phases.py,sha256=JgDyh579iR301OpD93L3WBeEpYUrNxD7R59WZE1X2MA,8390
+schemathesis/config/_phases.py,sha256=0D6eTo_jOVOyMevlpYAo-hcdgi4ocPpibsDpleMzSJ8,8741
 schemathesis/config/_projects.py,sha256=MpXFBIkNAWAzE_NWQISI9R8dlbCVId2eXGdIqZBgK98,20468
 schemathesis/config/_rate_limit.py,sha256=ekEW-jP_Ichk_O6hYpj-h2TTTKfp7Fm0nyFUbvlWcbA,456
 schemathesis/config/_report.py,sha256=ZECDpaCY4WWHD5UbjvgZoSjLz-rlTvfd5Ivzdgzqf2I,3891
 schemathesis/config/_validator.py,sha256=IcE8geFZ0ZwR18rkIRs25i7pTl7Z84XbjYGUB-mqReU,258
 schemathesis/config/_warnings.py,sha256=sI0VZcTj3dOnphhBwYwU_KTagxr89HGWTtQ99HcY84k,772
-schemathesis/config/schema.json,sha256=3CRSBfUK2vLVl1h5PfeK_YDdEoBZSojYl8Q1kT-ITLE,19846
+schemathesis/config/schema.json,sha256=MWWV2W9ozqBBGtzrtTiYQkdyCdTFSx_fDlYLKrXRs0Q,19887
 schemathesis/core/__init__.py,sha256=h4gmDePIPvPiVuYxnjrpPKytSZPi6fZeVdTG6c822E4,1973
 schemathesis/core/adapter.py,sha256=zwJ0vNhalrF9sYXN8_0pMSkJ71GPDnUBKqBCVsnuVIY,951
 schemathesis/core/compat.py,sha256=9BWCrFoqN2sJIaiht_anxe8kLjYMR7t0iiOkXqLRUZ8,1058
@@ -64,19 +64,19 @@ schemathesis/core/parameters.py,sha256=20pd4DLW1uXs61YuESKG1Fx9QJJQN3JY7CKnOJMgD
 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=rgr22JdVjFj0di9Oeo94Leo1JmdLJdCjnA-eGpfszV8,4095
+schemathesis/core/transforms.py,sha256=n_inn8Vb-CFiDUd9Z8E7JIp2kn2eAnxO8DD3OSwOTiM,4310
 schemathesis/core/transport.py,sha256=LQcamAkFqJ0HuXQzepevAq2MCJW-uq5Nm-HE9yc7HMI,7503
 schemathesis/core/validation.py,sha256=b0USkKzkWvdz3jOW1JXYc_TfYshfKZeP7xAUnMqcNoc,2303
 schemathesis/core/version.py,sha256=dOBUWrY3-uA2NQXJp9z7EtZgkR6jYeLg8sMhQCL1mcI,205
 schemathesis/core/jsonschema/__init__.py,sha256=gBZGsXIpK2EFfcp8x0b69dqzWAm2OeZHepKImkkLvoE,320
-schemathesis/core/jsonschema/bundler.py,sha256=IWZqKb0PqYSKtFW5ncItqHg5o1uVM0yS7vgbBg6pD0c,7724
+schemathesis/core/jsonschema/bundler.py,sha256=7Cc-1ccBNEdyMMypPyqTEbwcXmnkkjFPDxTZidgzIpU,7804
 schemathesis/core/jsonschema/keywords.py,sha256=pjseXTfH9OItNs_Qq6ubkhNWQOrxTnwHmrP_jxrHeJU,631
 schemathesis/core/jsonschema/references.py,sha256=c2Q4IKWUbwENNtkbFaqf8r3LLZu6GFE5YLnYQlg5tPg,6069
 schemathesis/core/jsonschema/types.py,sha256=C7f9g8yKFuoxC5_0YNIh8QAyGU0-tj8pzTMfMDjjjVM,1248
 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=40L4rEu34Y6a4jrag5O7N7sYh3qG5asE2ErF8w9-ktA,5362
+schemathesis/engine/context.py,sha256=iMyyum60AmZlX1reghxzCW6A_dDA43RA3NXJZqruHv8,6821
 schemathesis/engine/control.py,sha256=FXzP8dxL47j1Giqpy2-Bsr_MdMw9YiATSK_UfpFwDtk,1348
 schemathesis/engine/core.py,sha256=qlPHnZVq2RrUe93fOciXd1hC3E1gVyF2BIWMPMeLIj8,6655
 schemathesis/engine/errors.py,sha256=FlpEk44WRLzRkdK9m37z93EQuY3kbeMIQRGwU5e3Qm4,19005
@@ -98,8 +98,8 @@ schemathesis/generation/meta.py,sha256=tXhUZBEdpQMn68uMx1SW8Vv59Uf6Wl6yzs-VB9lu_
 schemathesis/generation/metrics.py,sha256=cZU5HdeAMcLFEDnTbNE56NuNq4P0N4ew-g1NEz5-kt4,2836
 schemathesis/generation/modes.py,sha256=Q1fhjWr3zxabU5qdtLvKfpMFZJAwlW9pnxgenjeXTyU,481
 schemathesis/generation/overrides.py,sha256=xI2djHsa42fzP32xpxgxO52INixKagf5DjDAWJYswM8,3890
-schemathesis/generation/hypothesis/__init__.py,sha256=Dfdz6_Wa7ez6GxrMBxnWQnLaNjPUweTxfi01jiFqso4,4900
-schemathesis/generation/hypothesis/builder.py,sha256=ZdY68aDGeZLLtIld288KF_O6ardFKZdFMBogwltTx2o,38362
+schemathesis/generation/hypothesis/__init__.py,sha256=68BHULoXQC1WjFfw03ga5lvDGZ-c-J7H_fNEuUzFWRw,4976
+schemathesis/generation/hypothesis/builder.py,sha256=tnDN_0MNT48mAO421JmcI3E0U2zeeTX-mjF3KXmpc7A,38629
 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
@@ -110,7 +110,7 @@ schemathesis/graphql/__init__.py,sha256=_eO6MAPHGgiADVGRntnwtPxmuvk666sAh-FAU4cG
 schemathesis/graphql/checks.py,sha256=IADbxiZjgkBWrC5yzHDtohRABX6zKXk5w_zpWNwdzYo,3186
 schemathesis/graphql/loaders.py,sha256=2tgG4HIvFmjHLr_KexVXnT8hSBM-dKG_fuXTZgE97So,9445
 schemathesis/openapi/__init__.py,sha256=-KcsSAM19uOM0N5J4s-yTnQ1BFsptYhW1E51cEf6kVM,311
-schemathesis/openapi/checks.py,sha256=VaQRxko6KwZL6saIzc4uUgJa_fj086O7Y6QFK8Zg-7A,12419
+schemathesis/openapi/checks.py,sha256=nrkkagRqg-HOsDCAMbJqCnHyBZEA2PpRV_AB8lI_I9c,13080
 schemathesis/openapi/loaders.py,sha256=-DSFWcvD_PmekTyy0qZrJ1YYODh9C1KuAJJIytEnS1s,10733
 schemathesis/openapi/generation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/openapi/generation/filters.py,sha256=pY9cUZdL_kQK80Z2aylTOqqa12zmaYUlYC5BfYgeQMk,2395
@@ -142,14 +142,14 @@ schemathesis/specs/openapi/schemas.py,sha256=vwBgw7kznPlQJIufgJ48oRxCzDFkUWKfb4u
 schemathesis/specs/openapi/serialization.py,sha256=RPNdadne5wdhsGmjSvgKLRF58wpzpRx3wura8PsHM3o,12152
 schemathesis/specs/openapi/utils.py,sha256=XkOJT8qD-6uhq-Tmwxk_xYku1Gy5F9pKL3ldNg_DRZw,522
 schemathesis/specs/openapi/adapter/__init__.py,sha256=YEovBgLjnXd3WGPMJXq0KbSGHezkRlEv4dNRO7_evfk,249
-schemathesis/specs/openapi/adapter/parameters.py,sha256=jX6tQuJ8k0Ml9w4jAquncGv2ZbJzsG2fUwLu6Grmlq8,18614
-schemathesis/specs/openapi/adapter/protocol.py,sha256=6Ioe563EL_ZAyRe8Kj8AE6l6grpFbIVn4C3GDuqizTA,2567
+schemathesis/specs/openapi/adapter/parameters.py,sha256=MYEQUxhtv23e1uhoDq5bDHMUT3Q64bW7aZloJuz13QY,18626
+schemathesis/specs/openapi/adapter/protocol.py,sha256=VDF6COcilHEUnmw76YBVur8bFiTFQHsNvaO9pR_i_KM,2709
 schemathesis/specs/openapi/adapter/references.py,sha256=6M59pJy_U_sLh3Xzgu6-izWXtz3bjXnqJYSD65wRHtk,549
-schemathesis/specs/openapi/adapter/responses.py,sha256=bti5FhqZaq_8g95kdpYx5lD2_1cUZEq56yIjlASji8I,12455
+schemathesis/specs/openapi/adapter/responses.py,sha256=Zv9uNgyr591-ZUcBCYMGot9ZccJgrxEOd9KI8wDfDTY,13253
 schemathesis/specs/openapi/adapter/security.py,sha256=W3cqlbs80NxF9SAavOi7BhtNGzdxHO476lYxiWN0D08,4945
-schemathesis/specs/openapi/adapter/v2.py,sha256=tWbq3EuJnSomWylPw_BT6TfEw8sIJQEFnVKpxCiq5XE,1153
-schemathesis/specs/openapi/adapter/v3_0.py,sha256=Q6b1Rfajx2tiO5W6uEwLosxQcdFqVgT5TS4r2jYFwg4,1145
-schemathesis/specs/openapi/adapter/v3_1.py,sha256=lvLvoxMC_AEwm8c_d3RGHk0BptaOFCdDcV8RrH-uOGw,1155
+schemathesis/specs/openapi/adapter/v2.py,sha256=2Rd1cTv7_I5QrBPLVfa2yD80NAErxV3tdeACjtEfXAA,1280
+schemathesis/specs/openapi/adapter/v3_0.py,sha256=8bOE9WUDrvPivGs0w-S1PP2TXgWuaoTzMdg2_WWbi-E,1272
+schemathesis/specs/openapi/adapter/v3_1.py,sha256=Hi4iMQdLDAeqSVYjafXbRb5yolWuqMz9A954tE2SCQY,1282
 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=IvOrgq_1IWNnirOSV_wLi0UcWOTiL-mLvBLFzLwRpVA,498
@@ -162,8 +162,15 @@ schemathesis/specs/openapi/negative/types.py,sha256=a7buCcVxNBG6ILBM3A7oNTAX0lyD
 schemathesis/specs/openapi/negative/utils.py,sha256=ozcOIuASufLqZSgnKUACjX-EOZrrkuNdXX0SDnLoGYA,168
 schemathesis/specs/openapi/stateful/__init__.py,sha256=nD5f9pP2Rx2DKIeXtbc_KqUukC4Nf2834cHeOp52byM,16247
 schemathesis/specs/openapi/stateful/control.py,sha256=QaXLSbwQWtai5lxvvVtQV3BLJ8n5ePqSKB00XFxp-MA,3695
-schemathesis/specs/openapi/stateful/inference.py,sha256=TCgEnDdTg2syk8KM8YCM96eE6-hMRNMW4OvVCxuyZkc,9603
+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/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/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
@@ -172,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.2.2.dist-info/METADATA,sha256=x3D71YX9YO81-h_n1Emw98R4jxq6NoL33XbYe3ntWNc,8540
-schemathesis-4.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.2.2.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.2.2.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.2.2.dist-info/RECORD,,
+schemathesis-4.3.1.dist-info/METADATA,sha256=cJcbDVPtmrVZIVWanF1tJxF1Vbhel76KAhpzJLj_KHs,8540
+schemathesis-4.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.3.1.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.3.1.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.3.1.dist-info/RECORD,,