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

schemathesis/core/jsonschema/bundler.py

@@ -90,7 +90,7 @@ class Bundler:
                         # In the future, it **should** be handled by `hypothesis-jsonschema` instead.
                         cloned = deepclone(resolved_schema)
                         remaining_references = sanitize(cloned)
-                        if remaining_references:
+                        if reference in remaining_references:
                             # This schema is either infinitely recursive or the sanitization logic misses it, in any
                             # event, we git up here
                             raise InfiniteRecursiveReference(reference)

schemathesis/core/jsonschema/references.py

@@ -1,122 +1,222 @@
 from __future__ import annotations
 
-from schemathesis.core.jsonschema.keywords import ALL_KEYWORDS
-from schemathesis.core.jsonschema.types import JsonSchema, JsonSchemaObject, get_type
+from typing import Any
 
+from schemathesis.core.jsonschema.types import JsonSchema, JsonSchemaObject
 
-def sanitize(schema: JsonSchema) -> set[str]:
-    """Remove optional parts of the schema that contain references.
 
-    It covers only the most popular cases, as removing all optional parts is complicated.
-    We might fall back to filtering out invalid cases in the future.
-    """
+def sanitize(schema: JsonSchema) -> set[str]:
+    """Remove $ref from optional locations."""
     if isinstance(schema, bool):
         return set()
 
-    stack = [schema]
+    stack: list[JsonSchema] = [schema]
+
     while stack:
         current = stack.pop()
-        if isinstance(current, dict):
-            # Optional properties
-            if "properties" in current:
-                properties = current["properties"]
-                required = current.get("required", [])
-                for name, value in list(properties.items()):
-                    if isinstance(value, dict):
-                        if name not in required and _has_references(value):
-                            del properties[name]
-                        elif _find_single_reference_combinators(value):
-                            properties.pop(name, None)
-                        else:
-                            stack.append(value)
-
-            # Optional items
-            if "items" in current:
-                _sanitize_items(current)
-            # Not required additional properties
-            if "additionalProperties" in current:
-                _sanitize_additional_properties(current)
-            for k in _find_single_reference_combinators(current):
-                del current[k]
+        if not isinstance(current, dict):
+            continue
+
+        _sanitize_combinators(current)
+
+        _sanitize_properties(current)
+
+        if "items" in current:
+            _sanitize_items(current)
+
+        if "prefixItems" in current:
+            _sanitize_prefix_items(current)
+
+        if "additionalProperties" in current:
+            _sanitize_additional_properties(current)
+
+        if "additionalItems" in current:
+            _sanitize_additional_items(current)
+
+        for value in current.values():
+            if isinstance(value, dict):
+                stack.append(value)
+            elif isinstance(value, list):
+                for item in value:
+                    if isinstance(item, dict):
+                        stack.append(item)
 
     remaining: set[str] = set()
     _collect_all_references(schema, remaining)
     return remaining
 
 
-def _collect_all_references(schema: JsonSchema | list[JsonSchema], remaining: set[str]) -> None:
-    """Recursively collect all $ref present in the schema."""
-    if isinstance(schema, dict):
-        reference = schema.get("$ref")
-        if isinstance(reference, str):
-            remaining.add(reference)
-        for value in schema.values():
-            _collect_all_references(value, remaining)
-    elif isinstance(schema, list):
-        for item in schema:
-            _collect_all_references(item, remaining)
+def _sanitize_combinators(schema: JsonSchemaObject) -> None:
+    """Sanitize anyOf/oneOf/allOf."""
+    for combinator_key in ("anyOf", "oneOf"):
+        variants = schema.get(combinator_key)
+        if not isinstance(variants, list):
+            continue
 
+        flattened = _flatten_combinator(variants, combinator_key)
 
-def _has_references_in_items(items: list[JsonSchema]) -> bool:
-    return any("$ref" in item for item in items if isinstance(item, dict))
+        cleaned = [variant for variant in flattened if not _has_ref(variant)]
 
+        # Only update if we have non-$ref variants
+        if cleaned:
+            # At least one alternative remains, which narrows the constraints
+            schema[combinator_key] = cleaned
+        elif not flattened:
+            schema.pop(combinator_key, None)
 
-def _has_references(schema: JsonSchemaObject) -> bool:
-    if "$ref" in schema:
+    all_of = schema.get("allOf")
+    if isinstance(all_of, list):
+        flattened = _flatten_combinator(all_of, "allOf")
+
+        cleaned = [variant for variant in flattened if not _is_empty(variant)]
+        if cleaned:
+            schema["allOf"] = cleaned
+        else:
+            schema.pop("allOf", None)
+
+
+def _flatten_combinator(variants: list, key: str) -> list:
+    """Flatten nested same-type combinators."""
+    result = []
+    for variant in variants:
+        if isinstance(variant, dict) and key in variant and isinstance(variant[key], list):
+            result.extend(variant[key])
+        else:
+            result.append(variant)
+    return result
+
+
+def _is_empty(schema: JsonSchema) -> bool:
+    """Check if schema accepts anything."""
+    if schema is True:
         return True
-    items = schema.get("items")
-    return (isinstance(items, dict) and "$ref" in items) or isinstance(items, list) and _has_references_in_items(items)
 
+    if not isinstance(schema, dict):
+        return False
 
-def _is_optional_schema(schema: JsonSchema) -> bool:
-    # Whether this schema could be dropped from a list of schemas
-    if isinstance(schema, bool):
+    if not schema:
         return True
-    type_ = get_type(schema)
-    if type_ == ["object"]:
-        # Empty object is valid for this schema -> could be dropped
-        return schema.get("required", []) == [] and schema.get("minProperties", 0) == 0
-    # Has at least one keyword -> should not be removed
-    return not any(k in ALL_KEYWORDS for k in schema)
-
-
-def _find_single_reference_combinators(schema: JsonSchemaObject) -> list[str]:
-    # Schema example:
-    # {
-    #     "type": "object",
-    #     "properties": {
-    #         "parent": {
-    #             "allOf": [{"$ref": "#/components/schemas/User"}]
-    #         }
-    #     }
-    # }
-    found = []
-    for keyword in ("allOf", "oneOf", "anyOf"):
-        combinator = schema.get(keyword)
-        if combinator is not None:
-            optionals = [subschema for subschema in combinator if not _is_optional_schema(subschema)]
-            # NOTE: The first schema is not bool, hence it is safe to pass it to `_has_references`
-            if len(optionals) == 1 and _has_references(optionals[0]):
-                found.append(keyword)
-    return found
+
+    # Only non-validating keywords
+    NON_VALIDATING = {
+        "$id",
+        "$schema",
+        "$defs",
+        "definitions",
+        "title",
+        "description",
+        "default",
+        "examples",
+        "example",
+        "$comment",
+        "deprecated",
+        "readOnly",
+        "writeOnly",
+    }
+
+    return all(key in NON_VALIDATING for key in schema.keys())
+
+
+def _sanitize_properties(schema: JsonSchemaObject) -> None:
+    """Remove OPTIONAL property schemas if they have $ref."""
+    if "properties" not in schema:
+        return
+
+    properties = schema["properties"]
+    if not isinstance(properties, dict):
+        return
+
+    required = schema.get("required", [])
+
+    for name, subschema in list(properties.items()):
+        if not _has_ref(subschema):
+            continue
+
+        if name not in required:
+            del properties[name]
 
 
 def _sanitize_items(schema: JsonSchemaObject) -> None:
+    """Convert to empty array ONLY if minItems allows it."""
     items = schema["items"]
+
+    has_ref = False
+    if isinstance(items, dict):
+        has_ref = _has_ref(items)
+    elif isinstance(items, list):
+        has_ref = any(_has_ref(item) for item in items)
+
+    if not has_ref:
+        return
+
     min_items = schema.get("minItems", 0)
-    if not min_items:
-        if isinstance(items, dict) and ("$ref" in items or _find_single_reference_combinators(items)):
-            _convert_to_empty_array(schema)
-        if isinstance(items, list) and _has_references_in_items(items):
-            _convert_to_empty_array(schema)
+
+    if min_items == 0:
+        _convert_to_empty_array(schema)
+
+
+def _sanitize_prefix_items(schema: JsonSchemaObject) -> None:
+    """Same logic as items."""
+    prefix_items = schema["prefixItems"]
+
+    if not isinstance(prefix_items, list):
+        return
+
+    if not any(_has_ref(item) for item in prefix_items):
+        return
+
+    min_items = schema.get("minItems", 0)
+
+    if min_items == 0:
+        _convert_to_empty_array(schema)
 
 
 def _convert_to_empty_array(schema: JsonSchemaObject) -> None:
-    del schema["items"]
+    schema.pop("items", None)
+    schema.pop("prefixItems", None)
     schema["maxItems"] = 0
+    schema["minItems"] = 0
 
 
 def _sanitize_additional_properties(schema: JsonSchemaObject) -> None:
-    additional_properties = schema["additionalProperties"]
-    if isinstance(additional_properties, dict) and "$ref" in additional_properties:
+    additional = schema["additionalProperties"]
+    if _has_ref(additional):
         schema["additionalProperties"] = False
+
+
+def _sanitize_additional_items(schema: JsonSchemaObject) -> None:
+    additional = schema["additionalItems"]
+    if _has_ref(additional):
+        schema["additionalItems"] = False
+
+
+def _has_ref(schema: Any) -> bool:
+    """Check if schema contains $ref at any level."""
+    if not isinstance(schema, dict):
+        return False
+
+    if "$ref" in schema:
+        return True
+    for value in schema.values():
+        if isinstance(value, dict):
+            if _has_ref(value):
+                return True
+        elif isinstance(value, list):
+            for item in value:
+                if isinstance(item, dict) and _has_ref(item):
+                    return True
+
+    return False
+
+
+def _collect_all_references(schema: JsonSchema | list[JsonSchema], remaining: set[str]) -> None:
+    """Collect all remaining $ref."""
+    if isinstance(schema, dict):
+        ref = schema.get("$ref")
+        if isinstance(ref, str):
+            remaining.add(ref)
+        for value in schema.values():
+            _collect_all_references(value, remaining)
+    elif isinstance(schema, list):
+        for item in schema:
+            _collect_all_references(item, remaining)

schemathesis/specs/openapi/examples.py

@@ -109,15 +109,19 @@ def extract_top_level(
     assert isinstance(operation.schema, BaseOpenAPISchema)
 
     responses = list(operation.responses.iter_examples())
-    seen_references: set[str] = set()
     for parameter in operation.iter_parameters():
         if "schema" in parameter.definition:
             schema = parameter.definition["schema"]
             resolver = RefResolver.from_schema(schema)
-            seen_references.clear()
+            reference_path: tuple[str, ...] = ()
             definitions = [
                 parameter.definition,
-                *_expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references),
+                *[
+                    expanded_schema
+                    for expanded_schema, _ in _expand_subschemas(
+                        schema=schema, resolver=resolver, reference_path=reference_path
+                    )
+                ],
             ]
         else:
             definitions = [parameter.definition]
@@ -138,10 +142,15 @@ def extract_top_level(
         if "schema" in parameter.definition:
             schema = parameter.definition["schema"]
             resolver = RefResolver.from_schema(schema)
-            seen_references.clear()
-            for expanded in _expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references):
-                if isinstance(expanded, dict) and parameter.adapter.examples_container_keyword in expanded:
-                    for value in expanded[parameter.adapter.examples_container_keyword]:
+            reference_path = ()
+            for expanded_schema, _ in _expand_subschemas(
+                schema=schema, resolver=resolver, reference_path=reference_path
+            ):
+                if (
+                    isinstance(expanded_schema, dict)
+                    and parameter.adapter.examples_container_keyword in expanded_schema
+                ):
+                    for value in expanded_schema[parameter.adapter.examples_container_keyword]:
                         yield ParameterExample(
                             container=parameter.location.container_name, name=parameter.name, value=value
                         )
@@ -152,10 +161,15 @@ def extract_top_level(
         if "schema" in body.definition:
             schema = body.definition["schema"]
             resolver = RefResolver.from_schema(schema)
-            seen_references.clear()
+            reference_path = ()
             definitions = [
                 body.definition,
-                *_expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references),
+                *[
+                    expanded_schema
+                    for expanded_schema, _ in _expand_subschemas(
+                        schema=schema, resolver=resolver, reference_path=reference_path
+                    )
+                ],
             ]
         else:
             definitions = [body.definition]
@@ -172,58 +186,76 @@ def extract_top_level(
         if "schema" in body.definition:
             schema = body.definition["schema"]
             resolver = RefResolver.from_schema(schema)
-            seen_references.clear()
-            for expanded in _expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references):
-                if isinstance(expanded, dict) and body.adapter.examples_container_keyword in expanded:
-                    for value in expanded[body.adapter.examples_container_keyword]:
+            reference_path = ()
+            for expanded_schema, _ in _expand_subschemas(
+                schema=schema, resolver=resolver, reference_path=reference_path
+            ):
+                if isinstance(expanded_schema, dict) and body.adapter.examples_container_keyword in expanded_schema:
+                    for value in expanded_schema[body.adapter.examples_container_keyword]:
                         yield BodyExample(value=value, media_type=body.media_type)
 
 
 @overload
 def _resolve_bundled(
-    schema: dict[str, Any], resolver: RefResolver, seen_references: set[str]
-) -> dict[str, Any]: ...  # pragma: no cover
+    schema: dict[str, Any], resolver: RefResolver, reference_path: tuple[str, ...]
+) -> tuple[dict[str, Any], tuple[str, ...]]: ...
 
 
 @overload
-def _resolve_bundled(schema: bool, resolver: RefResolver, seen_references: set[str]) -> bool: ...  # pragma: no cover
+def _resolve_bundled(
+    schema: bool, resolver: RefResolver, reference_path: tuple[str, ...]
+) -> tuple[bool, tuple[str, ...]]: ...
 
 
 def _resolve_bundled(
-    schema: dict[str, Any] | bool, resolver: RefResolver, seen_references: set[str]
-) -> dict[str, Any] | bool:
+    schema: dict[str, Any] | bool, resolver: RefResolver, reference_path: tuple[str, ...]
+) -> tuple[dict[str, Any] | bool, tuple[str, ...]]:
+    """Resolve $ref if present."""
     if isinstance(schema, dict):
         reference = schema.get("$ref")
         if isinstance(reference, str):
-            if reference in seen_references:
+            # Check if this reference is already in the current path
+            if reference in reference_path:
                 # Try to remove recursive references to avoid infinite recursion
                 remaining_references = references.sanitize(schema)
                 if reference in remaining_references:
                     raise InfiniteRecursiveReference(reference)
-            seen_references.add(reference)
+
+            new_path = reference_path + (reference,)
+
             try:
-                _, schema = resolver.resolve(schema["$ref"])
+                _, resolved_schema = resolver.resolve(reference)
             except RefResolutionError as exc:
                 raise UnresolvableReference(reference) from exc
-    return schema
+
+            return resolved_schema, new_path
+
+    return schema, reference_path
 
 
 def _expand_subschemas(
-    *, schema: dict[str, Any] | bool, resolver: RefResolver, seen_references: set[str]
-) -> Generator[dict[str, Any] | bool, None, None]:
-    schema = _resolve_bundled(schema, resolver, seen_references)
-    yield schema
+    *, schema: dict[str, Any] | bool, resolver: RefResolver, reference_path: tuple[str, ...]
+) -> Generator[tuple[dict[str, Any] | bool, tuple[str, ...]], None, None]:
+    """Expand schema and all its subschemas."""
+    schema, current_path = _resolve_bundled(schema, resolver, reference_path)
+    yield (schema, current_path)
+
     if isinstance(schema, dict):
+        # For anyOf/oneOf, yield each alternative with the same path
         for key in ("anyOf", "oneOf"):
             if key in schema:
                 for subschema in schema[key]:
-                    yield subschema
+                    # Each alternative starts with the current path
+                    yield (subschema, current_path)
+
+        # For allOf, merge all alternatives
         if "allOf" in schema:
             subschema = deepclone(schema["allOf"][0])
-            subschema = _resolve_bundled(subschema, resolver, seen_references)
+            subschema, _ = _resolve_bundled(subschema, resolver, current_path)
+
             for sub in schema["allOf"][1:]:
                 if isinstance(sub, dict):
-                    sub = _resolve_bundled(sub, resolver, seen_references)
+                    sub, _ = _resolve_bundled(sub, resolver, current_path)
                     for key, value in sub.items():
                         if key == "properties":
                             subschema.setdefault("properties", {}).update(value)
@@ -235,7 +267,8 @@ def _expand_subschemas(
                             subschema.setdefault("examples", []).append(value)
                         else:
                             subschema[key] = value
-            yield subschema
+
+            yield (subschema, current_path)
 
 
 def extract_inner_examples(examples: dict[str, Any] | list, schema: BaseOpenAPISchema) -> Generator[Any, None, None]:
@@ -269,13 +302,12 @@ def extract_from_schemas(
     operation: APIOperation[OpenApiParameter, OpenApiResponses, OpenApiSecurityParameters],
 ) -> Generator[Example, None, None]:
     """Extract examples from parameters' schema definitions."""
-    seen_references: set[str] = set()
     for parameter in operation.iter_parameters():
         schema = parameter.optimized_schema
         if isinstance(schema, bool):
             continue
         resolver = RefResolver.from_schema(schema)
-        seen_references.clear()
+        reference_path: tuple[str, ...] = ()
         bundle_storage = schema.get(BUNDLE_STORAGE_KEY)
         for value in extract_from_schema(
             operation=operation,
@@ -283,7 +315,7 @@ def extract_from_schemas(
             example_keyword=parameter.adapter.example_keyword,
             examples_container_keyword=parameter.adapter.examples_container_keyword,
             resolver=resolver,
-            seen_references=seen_references,
+            reference_path=reference_path,
             bundle_storage=bundle_storage,
         ):
             yield ParameterExample(container=parameter.location.container_name, name=parameter.name, value=value)
@@ -295,14 +327,14 @@ def extract_from_schemas(
         resolver = RefResolver.from_schema(schema)
         bundle_storage = schema.get(BUNDLE_STORAGE_KEY)
         for example_keyword, examples_container_keyword in (("example", "examples"), ("x-example", "x-examples")):
-            seen_references.clear()
+            reference_path = ()
             for value in extract_from_schema(
                 operation=operation,
                 schema=schema,
                 example_keyword=example_keyword,
                 examples_container_keyword=examples_container_keyword,
                 resolver=resolver,
-                seen_references=seen_references,
+                reference_path=reference_path,
                 bundle_storage=bundle_storage,
             ):
                 yield BodyExample(value=value, media_type=body.media_type)
@@ -315,49 +347,57 @@ def extract_from_schema(
     example_keyword: str,
     examples_container_keyword: str,
     resolver: RefResolver,
-    seen_references: set[str],
+    reference_path: tuple[str, ...],
     bundle_storage: dict[str, Any] | None,
 ) -> Generator[Any, None, None]:
     """Extract all examples from a single schema definition."""
     # This implementation supports only `properties` and `items`
-    schema = _resolve_bundled(schema, resolver, seen_references)
+    schema, current_path = _resolve_bundled(schema, resolver, reference_path)
+
     if "properties" in schema:
         variants = {}
         required = schema.get("required", [])
         to_generate: dict[str, Any] = {}
+
         for name, subschema in schema["properties"].items():
             values = []
-            for subsubschema in _expand_subschemas(
-                schema=subschema, resolver=resolver, seen_references=seen_references
+            for expanded_schema, expanded_path in _expand_subschemas(
+                schema=subschema, resolver=resolver, reference_path=current_path
             ):
-                if isinstance(subsubschema, bool):
-                    to_generate[name] = subsubschema
+                if isinstance(expanded_schema, bool):
+                    to_generate[name] = expanded_schema
                     continue
-                if example_keyword in subsubschema:
-                    values.append(subsubschema[example_keyword])
-                if examples_container_keyword in subsubschema and isinstance(
-                    subsubschema[examples_container_keyword], list
+
+                if example_keyword in expanded_schema:
+                    values.append(expanded_schema[example_keyword])
+
+                if examples_container_keyword in expanded_schema and isinstance(
+                    expanded_schema[examples_container_keyword], list
                 ):
                     # These are JSON Schema examples, which is an array of values
-                    values.extend(subsubschema[examples_container_keyword])
+                    values.extend(expanded_schema[examples_container_keyword])
+
                 # Check nested examples as well
                 values.extend(
                     extract_from_schema(
                         operation=operation,
-                        schema=subsubschema,
+                        schema=expanded_schema,
                         example_keyword=example_keyword,
                         examples_container_keyword=examples_container_keyword,
                         resolver=resolver,
-                        seen_references=seen_references,
+                        reference_path=expanded_path,
                         bundle_storage=bundle_storage,
                     )
                 )
+
                 if not values:
                     if name in required:
                         # Defer generation to only generate these variants if at least one property has examples
-                        to_generate[name] = subsubschema
+                        to_generate[name] = expanded_schema
                     continue
+
                 variants[name] = values
+
         if variants:
             config = operation.schema.config.generation_for(operation=operation, phase="examples")
             for name, subschema in to_generate.items():
@@ -369,6 +409,7 @@ def extract_from_schema(
                     subschema[BUNDLE_STORAGE_KEY] = bundle_storage
                 generated = _generate_single_example(subschema, config)
                 variants[name] = [generated]
+
             # Calculate the maximum number of examples any property has
             total_combos = max(len(examples) for examples in variants.values())
             # Evenly distribute examples by cycling through them
@@ -377,6 +418,7 @@ def extract_from_schema(
                     name: next(islice(cycle(property_variants), idx, None))
                     for name, property_variants in variants.items()
                 }
+
     elif "items" in schema and isinstance(schema["items"], dict):
         # Each inner value should be wrapped in an array
         for value in extract_from_schema(
@@ -385,7 +427,7 @@ def extract_from_schema(
             example_keyword=example_keyword,
             examples_container_keyword=examples_container_keyword,
             resolver=resolver,
-            seen_references=seen_references,
+            reference_path=current_path,
             bundle_storage=bundle_storage,
         ):
             yield [value]

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

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

@@ -69,9 +69,9 @@ 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=ECNAHrXl5nh52crm5Qu1QvRWVV2Vv9gU8H722oKA7k0,7711
+schemathesis/core/jsonschema/bundler.py,sha256=IWZqKb0PqYSKtFW5ncItqHg5o1uVM0yS7vgbBg6pD0c,7724
 schemathesis/core/jsonschema/keywords.py,sha256=pjseXTfH9OItNs_Qq6ubkhNWQOrxTnwHmrP_jxrHeJU,631
-schemathesis/core/jsonschema/references.py,sha256=uB7-DGYhLFqbIAvuO-IDc9xSatoGw54FOYn4xE4qE6A,4667
+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
@@ -133,7 +133,7 @@ schemathesis/specs/openapi/_hypothesis.py,sha256=g5476s_ArzheWKHHlOfKwx46tqoiehP
 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
-schemathesis/specs/openapi/examples.py,sha256=UquzOwy5QhmpHjFXv_QnZGpWZTU-N4CkQ1PQOxACIb8,22981
+schemathesis/specs/openapi/examples.py,sha256=xddFhKUQFmh5wdHrSWPBAcaby6C3Jtvuo_hsVbRGN1w,24006
 schemathesis/specs/openapi/formats.py,sha256=4tYRdckauHxkJCmOhmdwDq_eOpHPaKloi89lzMPbPzw,3975
 schemathesis/specs/openapi/media_types.py,sha256=F5M6TKl0s6Z5X8mZpPsWDEdPBvxclKRcUOc41eEwKbo,2472
 schemathesis/specs/openapi/patterns.py,sha256=GqPZEXMRdWENQxanWjBOalIZ2MQUjuxk21kmdiI703E,18027
@@ -172,8 +172,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.1.dist-info/METADATA,sha256=66gKdf-zvd-gHePTQubZs_QnlCvuuC3fELYv4hHK8NY,8540
-schemathesis-4.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.2.1.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.2.1.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.2.1.dist-info/RECORD,,
+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,,