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

schemathesis/cli/commands/run/context.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Callable, Generator
 
@@ -121,10 +122,32 @@ class Statistic:
             # We need a response to get there, so it should be present
             assert response is not None
 
+            history = None
+
+            if (
+                transition.request_body is not None
+                and isinstance(transition.request_body.value, Ok)
+                and transition.request_body.value.ok() is UNRESOLVABLE
+            ):
+                history = collect_history(parent, response)
+                extraction_failures.add(
+                    ExtractionFailure(
+                        id=transition.id,
+                        case_id=case_id,
+                        source=parent.value.operation.label,
+                        target=case.value.operation.label,
+                        parameter_name="body",
+                        expression=json.dumps(transition.request_body.definition),
+                        history=history,
+                        response=response,
+                        error=None,
+                    )
+                )
+
             for params in transition.parameters.values():
                 for parameter, extracted in params.items():
                     if isinstance(extracted.value, Ok) and extracted.value.ok() is UNRESOLVABLE:
-                        history = collect_history(parent, response)
+                        history = history or collect_history(parent, response)
                         extraction_failures.add(
                             ExtractionFailure(
                                 id=transition.id,
@@ -139,7 +162,7 @@ class Statistic:
                             )
                         )
                     elif isinstance(extracted.value, Err):
-                        history = collect_history(parent, response)
+                        history = history or collect_history(parent, response)
                         extraction_failures.add(
                             ExtractionFailure(
                                 id=transition.id,

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

@@ -1295,9 +1295,10 @@ class OutputHandler(EventHandler):
                     else:
                         click.echo(f"\n{indent}{failure.error.__class__.__name__}: {failure.error}")
                 else:
-                    description = (
-                        f"\n{indent}Could not resolve parameter `{failure.parameter_name}` via `{failure.expression}`"
-                    )
+                    if failure.parameter_name == "body":
+                        description = f"\n{indent}Could not resolve request body via {failure.expression}"
+                    else:
+                        description = f"\n{indent}Could not resolve parameter `{failure.parameter_name}` via `{failure.expression}`"
                     prefix = "$response.body"
                     if failure.expression.startswith(prefix):
                         description += f"\n{indent}Path `{failure.expression[len(prefix) :]}` not found in response"

schemathesis/core/jsonschema/bundler.py

@@ -41,6 +41,7 @@ class Bundler:
             return schema
 
         # Track visited URIs and their local definition names
+        inlining_for_recursion: set[str] = set()
         visited: set[str] = set()
         uri_to_def_name: dict[str, str] = {}
         defs = {}
@@ -90,19 +91,26 @@ class Bundler:
                         # L is the number of levels. Even quadratic growth can be unacceptable for large schemas.
                         #
                         # In the future, it **should** be handled by `hypothesis-jsonschema` instead.
-                        cloned = deepclone(resolved_schema)
-                        remaining_references = sanitize(cloned)
-                        if reference in remaining_references:
-                            # This schema is either infinitely recursive or the sanitization logic misses it
+                        if resolved_uri in inlining_for_recursion:
+                            # Check if we're already trying to inline this schema
+                            # If yes, it means we have an unbreakable cycle
                             cycle = scopes[scopes.index(resolved_uri) :]
                             raise InfiniteRecursiveReference(reference, cycle)
 
-                        result = {key: _bundle_recursive(value) for key, value in current.items() if key != "$ref"}
-                        # Recursive references need `$ref` to be in them, which is only possible with `dict`
-                        bundled_clone = _bundle_recursive(cloned)
-                        assert isinstance(bundled_clone, dict)
-                        result.update(bundled_clone)
-                        return result
+                        # Track that we're inlining this schema
+                        inlining_for_recursion.add(resolved_uri)
+                        try:
+                            cloned = deepclone(resolved_schema)
+                            # Sanitize to remove optional recursive references
+                            sanitize(cloned)
+
+                            result = {key: _bundle_recursive(value) for key, value in current.items() if key != "$ref"}
+                            bundled_clone = _bundle_recursive(cloned)
+                            assert isinstance(bundled_clone, dict)
+                            result.update(bundled_clone)
+                            return result
+                        finally:
+                            inlining_for_recursion.discard(resolved_uri)
                     elif resolved_uri not in visited:
                         # Bundle only new schemas
                         visit(resolved_uri)

schemathesis/generation/hypothesis/builder.py

@@ -530,7 +530,6 @@ def _iter_coverage_cases(
     instant = Instant()
     responses = list(operation.responses.iter_examples())
     # NOTE: The HEAD method is excluded
-    unexpected_methods = unexpected_methods or {"get", "put", "post", "delete", "options", "patch", "trace"}
     custom_formats = _build_custom_formats(generation_config)
 
     seen_negative = coverage.HashSet()

schemathesis/specs/openapi/_hypothesis.py

@@ -56,7 +56,7 @@ StrategyFactory = Callable[
 
 @st.composite  # type: ignore
 def openapi_cases(
-    draw: Callable,
+    draw: st.DrawFn,
     *,
     operation: APIOperation,
     hooks: HookDispatcher | None = None,
@@ -116,7 +116,7 @@ def openapi_cases(
             else:
                 candidates = operation.body.items
             parameter = draw(st.sampled_from(candidates))
-            strategy = _get_body_strategy(parameter, strategy_factory, operation, generation_config)
+            strategy = _get_body_strategy(parameter, strategy_factory, operation, generation_config, draw)
             strategy = apply_hooks(operation, ctx, hooks, strategy, ParameterLocation.BODY)
             # Parameter may have a wildcard media type. In this case, choose any supported one
             possible_media_types = sorted(
@@ -200,11 +200,15 @@ def openapi_cases(
     return instance
 
 
+OPTIONAL_BODY_RATE = 0.05
+
+
 def _get_body_strategy(
     parameter: OpenApiBody,
     strategy_factory: StrategyFactory,
     operation: APIOperation,
     generation_config: GenerationConfig,
+    draw: st.DrawFn,
 ) -> st.SearchStrategy:
     from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
 
@@ -220,7 +224,12 @@ def _get_body_strategy(
         generation_config,
         operation.schema.adapter.jsonschema_validator_cls,
     )
-    if not parameter.is_required:
+    # It is likely will be rejected, hence choose it rarely
+    if (
+        not parameter.is_required
+        and draw(st.floats(min_value=0.0, max_value=1.0, allow_infinity=False, allow_nan=False, allow_subnormal=False))
+        < OPTIONAL_BODY_RATE
+    ):
         strategy |= st.just(NOT_SET)
     return strategy
 
@@ -228,7 +237,7 @@ def _get_body_strategy(
 def get_parameters_value(
     value: dict[str, Any] | None,
     location: ParameterLocation,
-    draw: Callable,
+    draw: st.DrawFn,
     operation: APIOperation,
     ctx: HookContext,
     hooks: HookDispatcher | None,
@@ -279,7 +288,7 @@ def generate_parameter(
     location: ParameterLocation,
     explicit: dict[str, Any] | None,
     operation: APIOperation,
-    draw: Callable,
+    draw: st.DrawFn,
     ctx: HookContext,
     hooks: HookDispatcher | None,
     generator: GenerationMode,

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

@@ -7,6 +7,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
+from schemathesis.core import NOT_SET
 from schemathesis.core.compat import RefResolutionError
 from schemathesis.core.result import Ok
 from schemathesis.specs.openapi.stateful.dependencies.inputs import extract_inputs, update_input_field_bindings
@@ -107,9 +108,10 @@ def inject_links(schema: BaseOpenAPISchema) -> int:
         for link_name, definition in response_links.links.items():
             inferred_link = definition.to_openapi()
 
-            # Check if duplicate exists
+            # Check if duplicate / subsets exists
             if normalized_existing:
-                if _normalize_link(inferred_link, schema) in normalized_existing:
+                normalized = _normalize_link(inferred_link, schema)
+                if any(_is_subset_link(normalized, existing) for existing in normalized_existing):
                     continue
 
             # Find unique name if collision exists
@@ -170,3 +172,39 @@ def _resolve_link_name_collision(proposed_name: str, existing_links: dict[str, A
         if candidate not in existing_links:
             return candidate
         suffix += 1
+
+
+def _is_subset_link(inferred: NormalizedLink, existing: NormalizedLink) -> bool:
+    """Check if inferred link is a subset of existing link."""
+    # Must target the same operation
+    if inferred.path != existing.path or inferred.method != existing.method:
+        return False
+
+    # Inferred parameters must be subset of existing parameters
+    if not inferred.parameters.issubset(existing.parameters):
+        return False
+
+    # Inferred request body must be subset of existing body
+    return _is_request_body_subset(inferred.request_body, existing.request_body)
+
+
+def _is_request_body_subset(inferred_body: Any, existing_body: Any) -> bool:
+    """Check if inferred body is a subset of existing body."""
+    # Empty inferred body is always a subset
+    if not inferred_body:
+        return True
+
+    # If existing is empty but inferred isn't, not a subset
+    if not existing_body:
+        return False
+
+    # Both must be dicts for subset comparison, otherwise check for equality
+    if not isinstance(inferred_body, dict) or not isinstance(existing_body, dict):
+        return inferred_body == existing_body
+
+    # Check if all inferred fields exist in existing with same values
+    for key, value in inferred_body.items():
+        if existing_body.get(key, NOT_SET) != value:
+            return False
+
+    return True

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

@@ -5,6 +5,7 @@ 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.jsonschema.types import get_type
 from schemathesis.core.parameters import ParameterLocation
 from schemathesis.specs.openapi.stateful.dependencies import naming
 from schemathesis.specs.openapi.stateful.dependencies.models import (
@@ -36,6 +37,7 @@ def extract_inputs(
     Connects each parameter (e.g., `userId`) to its resource definition (`User`),
     creating placeholder resources if not yet discovered from their schemas.
     """
+    known_dependencies = set()
     for param in operation.path_parameters:
         input_slot = _resolve_parameter_dependency(
             parameter_name=param.name,
@@ -47,12 +49,16 @@ def extract_inputs(
             canonicalization_cache=canonicalization_cache,
         )
         if input_slot is not None:
+            if input_slot.resource.source >= DefinitionSource.SCHEMA_WITH_PROPERTIES:
+                known_dependencies.add(input_slot.resource.name)
             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)
+                yield from _resolve_body_dependencies(
+                    body=body, operation=operation, resources=resources, known_dependencies=known_dependencies
+                )
         except MalformedMediaType:
             continue
 
@@ -162,8 +168,23 @@ def _find_resource_in_responses(
     return None
 
 
+GENERIC_FIELD_NAMES = frozenset(
+    {
+        "body",
+        "text",
+        "content",
+        "message",
+        "description",
+    }
+)
+
+
 def _resolve_body_dependencies(
-    *, body: OpenApiBody, operation: APIOperation, resources: ResourceMap
+    *,
+    body: OpenApiBody,
+    operation: APIOperation,
+    resources: ResourceMap,
+    known_dependencies: set[str],
 ) -> Iterator[InputSlot]:
     schema = body.raw_schema
     if not isinstance(schema, dict):
@@ -178,31 +199,57 @@ def _resolve_body_dependencies(
 
     # Inspect each property that could be a part of some other resource
     properties = resolved.get("properties", {})
+    required = resolved.get("required", [])
     path = operation.path
-    for property_name in properties:
+    for property_name, subschema in properties.items():
         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,
+        if resource_name is not None:
+            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"
                 )
-                or "id"
+            yield InputSlot(
+                resource=resource,
+                resource_field=field,
+                parameter_name=property_name,
+                parameter_location=ParameterLocation.BODY,
             )
+            continue
+
+        # Skip generic property names & optional fields (at least for now)
+        if property_name in GENERIC_FIELD_NAMES or property_name not in required:
+            continue
+
+        # Find candidate resources among known dependencies that actually have this field
+        candidates = [
+            resources[dep] for dep in known_dependencies if dep in resources and property_name in resources[dep].fields
+        ]
+
+        # Skip ambiguous cases when multiple resources have same field name
+        if len(candidates) != 1:
+            continue
+
+        resource = candidates[0]
+        # Ensure the target field supports the same type
+        if not resource.types[property_name] & set(get_type(subschema)):
+            continue
+
         yield InputSlot(
             resource=resource,
-            resource_field=field,
+            resource_field=property_name,
             parameter_name=property_name,
             parameter_location=ParameterLocation.BODY,
         )

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

@@ -73,6 +73,11 @@ class DependencyGraph:
                                 parameters = {
                                     f"{input_slot.parameter_location.value}.{input_slot.parameter_name}": f"$response.body#{body_pointer}",
                                 }
+                            existing = links.get(link_name)
+                            if existing is not None:
+                                existing.parameters.update(parameters)
+                                existing.request_body.update(request_body)
+                                continue
                             links[link_name] = LinkDefinition(
                                 operation_ref=f"#/paths/{consumer_path}/{consumer.method}",
                                 parameters=parameters,
@@ -267,18 +272,20 @@ class ResourceDefinition:
     name: str
     # A sorted list of resource fields
     fields: list[str]
+    # Field types mapping
+    types: dict[str, set[str]]
     # How this resource was created
     source: DefinitionSource
 
-    __slots__ = ("name", "fields", "source")
+    __slots__ = ("name", "fields", "types", "source")
 
     @classmethod
     def without_properties(cls, name: str) -> ResourceDefinition:
-        return cls(name=name, fields=[], source=DefinitionSource.SCHEMA_WITHOUT_PROPERTIES)
+        return cls(name=name, fields=[], types={}, source=DefinitionSource.SCHEMA_WITHOUT_PROPERTIES)
 
     @classmethod
     def inferred_from_parameter(cls, name: str, parameter_name: str) -> ResourceDefinition:
-        return cls(name=name, fields=[parameter_name], source=DefinitionSource.PARAMETER_INFERENCE)
+        return cls(name=name, fields=[parameter_name], types={}, source=DefinitionSource.PARAMETER_INFERENCE)
 
 
 class DefinitionSource(enum.IntEnum):

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

@@ -4,26 +4,45 @@ from __future__ import annotations
 def from_parameter(parameter: str, path: str) -> str | None:
     # TODO: support other naming patterns
     # Named like "userId" -> look for "User" resource
-    if parameter.endswith("Id"):
+    if parameter.endswith("Id") and len(parameter) > 2:
         return to_pascal_case(parameter[:-2])
     # Named like "user_id" -> look for "User" resource
     elif parameter.endswith("_id"):
         return to_pascal_case(parameter[:-3])
     # Just "id" -> infer from path context
     elif parameter == "id":
-        return from_path(path)
+        return from_path(path, parameter_name=parameter)
     return None
 
 
-def from_path(path: str) -> str | None:
-    segments = [s for s in path.split("/") if s and "{" not in s]
+def from_path(path: str, parameter_name: str | None = None) -> str | None:
+    """Detect resource name from OpenAPI path."""
+    segments = [s for s in path.split("/") if s]
 
     if not segments:
         # API Root
         return None
 
-    singular = to_singular(segments[-1])
-    return to_pascal_case(singular)
+    # If parameter name provided, find the resource it refers to
+    if parameter_name:
+        placeholder = f"{{{parameter_name}}}"
+        try:
+            param_index = segments.index(placeholder)
+            if param_index > 0:
+                resource_segment = segments[param_index - 1]
+                if "{" not in resource_segment:
+                    singular = to_singular(resource_segment)
+                    return to_pascal_case(singular)
+        except ValueError:
+            pass  # Parameter not found in path
+
+    # Fallback to last non-parameter segment
+    non_param_segments = [s for s in segments if "{" not in s]
+    if non_param_segments:
+        singular = to_singular(non_param_segments[-1])
+        return to_pascal_case(singular)
+
+    return None
 
 
 IRREGULAR_TO_PLURAL = {

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

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any, Iterator, Mapping, cast
 
 from schemathesis.core.errors import InfiniteRecursiveReference
 from schemathesis.core.jsonschema.bundler import BundleError
+from schemathesis.core.jsonschema.types import get_type
 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
@@ -265,18 +266,21 @@ def _extract_resource_from_schema(
 
         properties = resolved.get("properties")
         if properties:
-            fields = list(properties)
+            fields = sorted(properties)
+            types = {field: set(get_type(subschema)) for field, subschema in properties.items()}
             source = DefinitionSource.SCHEMA_WITH_PROPERTIES
         else:
             fields = []
+            types = {}
             source = DefinitionSource.SCHEMA_WITHOUT_PROPERTIES
         if resource is not None:
             if resource.source < source:
                 resource.source = source
                 resource.fields = fields
+                resource.types = types
                 updated_resources.add(resource_name)
         else:
-            resource = ResourceDefinition(name=resource_name, fields=fields, source=source)
+            resource = ResourceDefinition(name=resource_name, fields=fields, types=types, source=source)
             resources[resource_name] = resource
 
     return resource

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

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

@@ -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=Usa89aSPf8Uv-2m-nWr0ghvTKM1ZZehALBI0m_lFHv4,8087
+schemathesis/cli/commands/run/context.py,sha256=vej33l5yOhlJ5gLXDwat9WCW_XdhrHNc9pdIQQYddoY,9004
 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=jWrqEkEQPO2kgzxOffZacqxH6r7dkDmAx0ep9GA3NU8,64020
+schemathesis/cli/commands/run/handlers/output.py,sha256=pPp5-lJP3Zir1sTA7fmlhc-u1Jn17enXZNUerQMr56M,64166
 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
@@ -69,7 +69,7 @@ schemathesis/core/transport.py,sha256=LQcamAkFqJ0HuXQzepevAq2MCJW-uq5Nm-HE9yc7HM
 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=wK-UhI49TbfnNjr_riQZ28s005d4c-s05WcXLGQFlCs,7861
+schemathesis/core/jsonschema/bundler.py,sha256=rHaNAVgBn0XvAk3t9dHsyym1xK4FyBW7zR1GLejPD0A,8204
 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
@@ -99,7 +99,7 @@ schemathesis/generation/metrics.py,sha256=cZU5HdeAMcLFEDnTbNE56NuNq4P0N4ew-g1NEz
 schemathesis/generation/modes.py,sha256=Q1fhjWr3zxabU5qdtLvKfpMFZJAwlW9pnxgenjeXTyU,481
 schemathesis/generation/overrides.py,sha256=xI2djHsa42fzP32xpxgxO52INixKagf5DjDAWJYswM8,3890
 schemathesis/generation/hypothesis/__init__.py,sha256=68BHULoXQC1WjFfw03ga5lvDGZ-c-J7H_fNEuUzFWRw,4976
-schemathesis/generation/hypothesis/builder.py,sha256=tnDN_0MNT48mAO421JmcI3E0U2zeeTX-mjF3KXmpc7A,38629
+schemathesis/generation/hypothesis/builder.py,sha256=j7R_X9Z_50xjwIl_Z8DVBe6P1r8leVNvQME7mRLXM1A,38520
 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
@@ -129,7 +129,7 @@ schemathesis/specs/graphql/scalars.py,sha256=6lew8mnwhrtg23leiEbG43mLGPLlRln8mCl
 schemathesis/specs/graphql/schemas.py,sha256=GKJcnTAT1wUzzUr3r6wiTfiAdFLcgFQjYRRz7x4VQl0,14457
 schemathesis/specs/graphql/validation.py,sha256=-W1Noc1MQmTb4RX-gNXMeU2qkgso4mzVfHxtdLkCPKM,1422
 schemathesis/specs/openapi/__init__.py,sha256=C5HOsfuDJGq_3mv8CRBvRvb0Diy1p0BFdqyEXMS-loE,238
-schemathesis/specs/openapi/_hypothesis.py,sha256=g5476s_ArzheWKHHlOfKwx46tqoiehP3KaQM7L_AoEI,22359
+schemathesis/specs/openapi/_hypothesis.py,sha256=O8vN-koBjzBVZfpD3pmgIt6ecU4ddAPHOxTAORd23Lo,22642
 schemathesis/specs/openapi/checks.py,sha256=YYV6j6idyw2ubY4sLp-avs2OVEkAWeIihjT0xiV1RRA,30669
 schemathesis/specs/openapi/converter.py,sha256=4a6-8STT5snF7B-t6IsOIGdK5rV16oNqsdvWL7VFf2M,6472
 schemathesis/specs/openapi/definitions.py,sha256=8htclglV3fW6JPBqs59lgM4LnA25Mm9IptXBPb_qUT0,93949
@@ -164,12 +164,12 @@ schemathesis/specs/openapi/stateful/__init__.py,sha256=CQx2WJ3mKn5qmYRc90DqsG9w3
 schemathesis/specs/openapi/stateful/control.py,sha256=QaXLSbwQWtai5lxvvVtQV3BLJ8n5ePqSKB00XFxp-MA,3695
 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/__init__.py,sha256=0JM-FrY6Awv6gl-qDHaaK7pXbt_GKutBKPyIaph8apA,7842
+schemathesis/specs/openapi/stateful/dependencies/inputs.py,sha256=1qVVIlzx52qsy55Pht9dYNtn2dewRSiHegfrBO1RD8c,10347
+schemathesis/specs/openapi/stateful/dependencies/models.py,sha256=HxdVcVebjUFhSlSs_M8vDB-BnYfYwLGceIQAzytawrs,11324
+schemathesis/specs/openapi/stateful/dependencies/naming.py,sha256=HfpkCB1GglX1BAKXer3llvPkQsk8wx0QZhZq7ANcdMM,12214
 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/resources.py,sha256=4bgXILFgC1_y9aU_4scaNw3lkJ6laW5MMkLYh3Ph4Hg,9894
 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
@@ -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.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,,
+schemathesis-4.3.6.dist-info/METADATA,sha256=fSBJbdXmS3wufMePS7qdtcEmUy4eMoiV28sqkp0db68,8540
+schemathesis-4.3.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.3.6.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.3.6.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.3.6.dist-info/RECORD,,