schemathesis 3.36.2__py3-none-any.whl → 3.36.4__py3-none-any.whl

schemathesis/_hypothesis.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+from copy import copy
 import warnings
 from typing import TYPE_CHECKING, Any, Callable, Generator, Mapping
 
@@ -221,7 +222,13 @@ def _iter_coverage_cases(
 
     ctx = coverage.CoverageContext(data_generation_methods=data_generation_methods)
     meta = GenerationMetadata(
-        query=None, path_parameters=None, headers=None, cookies=None, body=None, phase=TestPhase.COVERAGE
+        query=None,
+        path_parameters=None,
+        headers=None,
+        cookies=None,
+        body=None,
+        phase=TestPhase.COVERAGE,
+        description=None,
     )
     generators: dict[tuple[str, str], Generator[coverage.GeneratedValue, None, None]] = {}
     template: dict[str, Any] = {}
@@ -259,17 +266,19 @@ def _iter_coverage_cases(
                 template["media_type"] = body.media_type
             case = operation.make_case(**{**template, "body": value.value, "media_type": body.media_type})
             case.data_generation_method = value.data_generation_method
-            case.meta = meta
+            case.meta = copy(meta)
+            case.meta.description = value.description
             yield case
             for next_value in gen:
                 case = operation.make_case(**{**template, "body": next_value.value, "media_type": body.media_type})
                 case.data_generation_method = next_value.data_generation_method
-                case.meta = meta
+                case.meta = copy(meta)
+                case.meta.description = next_value.description
                 yield case
     elif DataGenerationMethod.positive in data_generation_methods:
         case = operation.make_case(**template)
         case.data_generation_method = DataGenerationMethod.positive
-        case.meta = meta
+        case.meta = copy(meta)
         yield case
     for (location, name), gen in generators.items():
         container_name = LOCATION_TO_CONTAINER[location]
@@ -281,7 +290,8 @@ def _iter_coverage_cases(
                 generated = value.value
             case = operation.make_case(**{**template, container_name: {**container, name: generated}})
             case.data_generation_method = value.data_generation_method
-            case.meta = meta
+            case.meta = copy(meta)
+            case.meta.description = value.description
             yield case
 
 

schemathesis/cli/cassettes.py

@@ -79,24 +79,18 @@ class CassetteWriter(EventHandler):
     def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
         if isinstance(event, events.Initialized):
             # In the beginning we write metadata and start `http_interactions` list
-            self.queue.put(Initialize())
+            self.queue.put(Initialize(seed=event.seed))
         elif isinstance(event, events.AfterExecution):
-            # Seed is always present at this point, the original Optional[int] type is there because `TestResult`
-            # instance is created before `seed` is generated on the hypothesis side
-            seed = cast(int, event.result.seed)
             self.queue.put(
                 Process(
-                    seed=seed,
                     correlation_id=event.correlation_id,
                     thread_id=event.thread_id,
                     interactions=event.result.interactions,
                 )
             )
         elif isinstance(event, events.AfterStatefulExecution):
-            seed = cast(int, event.result.seed)
             self.queue.put(
                 Process(
-                    seed=seed,
                     # Correlation ID is not used in stateful testing
                     correlation_id="",
                     thread_id=event.thread_id,
@@ -118,12 +112,13 @@ class CassetteWriter(EventHandler):
 class Initialize:
     """Start up, the first message to make preparations before proceeding the input data."""
 
+    seed: int | None
+
 
 @dataclass
 class Process:
     """A new chunk of data should be processed."""
 
-    seed: int
     correlation_id: str
     thread_id: int
     interactions: list[SerializedInteraction]
@@ -219,9 +214,11 @@ def vcr_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: boo
                 )
                 write_double_quoted(output, string)
 
+    seed = "null"
     while True:
         item = queue.get()
         if isinstance(item, Initialize):
+            seed = f"'{item.seed}'"
             stream.write(
                 f"""command: '{get_command_representation()}'
 recorded_with: 'Schemathesis {SCHEMATHESIS_VERSION}'
@@ -235,10 +232,20 @@ http_interactions:"""
                 stream.write(
                     f"""\n- id: '{current_id}'
   status: '{status}'
-  seed: '{item.seed}'
+  seed: {seed}
   thread_id: {item.thread_id}
   correlation_id: '{item.correlation_id}'
   data_generation_method: '{interaction.data_generation_method.value}'
+  meta:
+    description: """
+                )
+
+                if interaction.description is not None:
+                    write_double_quoted(stream, interaction.description)
+                else:
+                    stream.write("null")
+                stream.write(
+                    f"""
   phase: {phase}
   elapsed: '{interaction.response.elapsed if interaction.response else 0}'
   recorded_at: '{interaction.recorded_at}'

schemathesis/generation/_hypothesis.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 from functools import lru_cache, reduce
 from operator import or_
 from typing import TYPE_CHECKING, TypeVar
@@ -8,6 +9,8 @@ if TYPE_CHECKING:
     from hypothesis import settings
     from hypothesis import strategies as st
 
+SCHEMATHESIS_BENCHMARK_SEED = os.environ.get("SCHEMATHESIS_BENCHMARK_SEED")
+
 
 @lru_cache
 def default_settings() -> settings:
@@ -33,13 +36,16 @@ def get_single_example(strategy: st.SearchStrategy[T]) -> T:  # type: ignore[typ
 
 
 def add_single_example(strategy: st.SearchStrategy[T], examples: list[T]) -> None:
-    from hypothesis import given
+    from hypothesis import given, seed
 
     @given(strategy)  # type: ignore
     @default_settings()  # type: ignore
     def example_generating_inner_function(ex: T) -> None:
         examples.append(ex)
 
+    if SCHEMATHESIS_BENCHMARK_SEED is not None:
+        example_generating_inner_function = seed(SCHEMATHESIS_BENCHMARK_SEED)(example_generating_inner_function)
+
     example_generating_inner_function()
 
 

schemathesis/generation/coverage.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import json
+import functools
 from contextlib import contextmanager, suppress
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from functools import lru_cache
 from itertools import combinations
 from typing import Any, Generator, Iterator, TypeVar, cast
@@ -18,12 +19,20 @@ from schemathesis.constants import NOT_SET
 from ._hypothesis import get_single_example
 from ._methods import DataGenerationMethod
 
+
+def _replace_zero_with_nonzero(x: float) -> float:
+    return x or 0.0
+
+
+def json_recursive_strategy(strategy: st.SearchStrategy) -> st.SearchStrategy:
+    return st.lists(strategy, max_size=3) | st.dictionaries(st.text(), strategy, max_size=3)
+
+
 BUFFER_SIZE = 8 * 1024
-FLOAT_STRATEGY: st.SearchStrategy = st.floats(allow_nan=False, allow_infinity=False).map(lambda x: x or 0.0)
+FLOAT_STRATEGY: st.SearchStrategy = st.floats(allow_nan=False, allow_infinity=False).map(_replace_zero_with_nonzero)
 NUMERIC_STRATEGY: st.SearchStrategy = st.integers() | FLOAT_STRATEGY
 JSON_STRATEGY: st.SearchStrategy = st.recursive(
-    st.none() | st.booleans() | NUMERIC_STRATEGY | st.text(),
-    lambda strategy: st.lists(strategy, max_size=3) | st.dictionaries(st.text(), strategy, max_size=3),
+    st.none() | st.booleans() | NUMERIC_STRATEGY | st.text(), json_recursive_strategy
 )
 ARRAY_STRATEGY: st.SearchStrategy = st.lists(JSON_STRATEGY)
 OBJECT_STRATEGY: st.SearchStrategy = st.dictionaries(st.text(), JSON_STRATEGY)
@@ -36,16 +45,17 @@ UNKNOWN_PROPERTY_VALUE = 42
 class GeneratedValue:
     value: Any
     data_generation_method: DataGenerationMethod
+    description: str
 
-    __slots__ = ("value", "data_generation_method")
+    __slots__ = ("value", "data_generation_method", "description")
 
     @classmethod
-    def with_positive(cls, value: Any) -> GeneratedValue:
-        return cls(value, DataGenerationMethod.positive)
+    def with_positive(cls, value: Any, *, description: str) -> GeneratedValue:
+        return cls(value=value, data_generation_method=DataGenerationMethod.positive, description=description)
 
     @classmethod
-    def with_negative(cls, value: Any) -> GeneratedValue:
-        return cls(value, DataGenerationMethod.negative)
+    def with_negative(cls, value: Any, *, description: str) -> GeneratedValue:
+        return cls(value=value, data_generation_method=DataGenerationMethod.negative, description=description)
 
 
 PositiveValue = GeneratedValue.with_positive
@@ -59,7 +69,14 @@ def cached_draw(strategy: st.SearchStrategy) -> Any:
 
 @dataclass
 class CoverageContext:
-    data_generation_methods: list[DataGenerationMethod] = field(default_factory=DataGenerationMethod.all)
+    data_generation_methods: list[DataGenerationMethod]
+
+    __slots__ = ("data_generation_methods",)
+
+    def __init__(self, data_generation_methods: list[DataGenerationMethod] | None = None) -> None:
+        self.data_generation_methods = (
+            data_generation_methods if data_generation_methods is not None else DataGenerationMethod.all()
+        )
 
     @classmethod
     def with_positive(cls) -> CoverageContext:
@@ -69,12 +86,8 @@ class CoverageContext:
     def with_negative(cls) -> CoverageContext:
         return CoverageContext(data_generation_methods=[DataGenerationMethod.negative])
 
-    def generate_from(self, strategy: st.SearchStrategy, cached: bool = False) -> Any:
-        if cached:
-            value = cached_draw(strategy)
-        else:
-            value = get_single_example(strategy)
-        return value
+    def generate_from(self, strategy: st.SearchStrategy) -> Any:
+        return cached_draw(strategy)
 
     def generate_from_schema(self, schema: dict) -> Any:
         return self.generate_from(from_schema(schema))
@@ -117,15 +130,15 @@ def _cover_positive_for_type(
                     yield from cover_schema_iter(ctx, canonical)
         if enum is not NOT_SET:
             for value in enum:
-                yield PositiveValue(value)
+                yield PositiveValue(value, description="Enum value")
         elif const is not NOT_SET:
-            yield PositiveValue(const)
+            yield PositiveValue(const, description="Const value")
         elif ty is not None:
             if ty == "null":
-                yield PositiveValue(None)
+                yield PositiveValue(None, description="Value null value")
             elif ty == "boolean":
-                yield PositiveValue(True)
-                yield PositiveValue(False)
+                yield PositiveValue(True, description="Valid boolean value")
+                yield PositiveValue(False, description="Valid boolean value")
             elif ty == "string":
                 yield from _positive_string(ctx, schema)
             elif ty == "integer" or ty == "number":
@@ -200,15 +213,17 @@ def cover_schema_iter(
                 elif key == "maximum":
                     next = value + 1
                     if next not in seen:
-                        yield NegativeValue(next)
+                        yield NegativeValue(next, description="Value greater than maximum")
                         seen.add(next)
                 elif key == "minimum":
                     next = value - 1
                     if next not in seen:
-                        yield NegativeValue(next)
+                        yield NegativeValue(next, description="Value smaller than minimum")
                         seen.add(next)
                 elif key == "exclusiveMaximum" or key == "exclusiveMinimum" and value not in seen:
-                    yield NegativeValue(value)
+                    verb = "greater" if key == "exclusiveMaximum" else "smaller"
+                    limit = "maximum" if key == "exclusiveMaximum" else "minimum"
+                    yield NegativeValue(value, description=f"Value {verb} than {limit}")
                     seen.add(value)
                 elif key == "multipleOf":
                     for value_ in _negative_multiple_of(ctx, schema, value):
@@ -221,14 +236,14 @@ def cover_schema_iter(
                         value = ctx.generate_from_schema({**schema, "minLength": value - 1, "maxLength": value - 1})
                         k = _to_hashable_key(value)
                         if k not in seen:
-                            yield NegativeValue(value)
+                            yield NegativeValue(value, description="String smaller than minLength")
                             seen.add(k)
                 elif key == "maxLength" and value < BUFFER_SIZE:
                     with suppress(InvalidArgument):
                         value = ctx.generate_from_schema({**schema, "minLength": value + 1, "maxLength": value + 1})
                         k = _to_hashable_key(value)
                         if k not in seen:
-                            yield NegativeValue(value)
+                            yield NegativeValue(value, description="String larger than maxLength")
                             seen.add(k)
                 elif key == "uniqueItems" and value:
                     yield from _negative_unique_items(ctx, schema)
@@ -237,7 +252,10 @@ def cover_schema_iter(
                     yield from _negative_required(ctx, template, value)
                 elif key == "additionalProperties" and not value:
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
-                    yield NegativeValue({**template, UNKNOWN_PROPERTY_KEY: UNKNOWN_PROPERTY_VALUE})
+                    yield NegativeValue(
+                        {**template, UNKNOWN_PROPERTY_KEY: UNKNOWN_PROPERTY_VALUE},
+                        description="Object with unexpected properties",
+                    )
                 elif key == "allOf":
                     nctx = ctx.with_negative()
                     if len(value) == 1:
@@ -291,43 +309,50 @@ def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
     default = schema.get("default")
     if example or examples or default:
         if example:
-            yield PositiveValue(example)
+            yield PositiveValue(example, description="Example value")
         if examples:
             for example in examples:
-                yield PositiveValue(example)
+                yield PositiveValue(example, description="Example value")
         if (
             default
             and not (example is not None and default == example)
             and not (examples is not None and any(default == ex for ex in examples))
         ):
-            yield PositiveValue(default)
+            yield PositiveValue(default, description="Default value")
     elif not min_length and not max_length:
         # Default positive value
-        yield PositiveValue(ctx.generate_from_schema(schema))
+        yield PositiveValue(ctx.generate_from_schema(schema), description="Valid string")
     elif "pattern" in schema:
         # Without merging `maxLength` & `minLength` into a regex it is problematic
         # to generate a valid value as the unredlying machinery will resort to filtering
         # and it is unlikely that it will generate a string of that length
-        yield PositiveValue(ctx.generate_from_schema(schema))
+        yield PositiveValue(ctx.generate_from_schema(schema), description="Valid string")
         return
 
     seen = set()
 
     if min_length is not None and min_length < BUFFER_SIZE:
         # Exactly the minimum length
-        yield PositiveValue(ctx.generate_from_schema({**schema, "maxLength": min_length}))
+        yield PositiveValue(
+            ctx.generate_from_schema({**schema, "maxLength": min_length}), description="Minimum length string"
+        )
         seen.add(min_length)
 
         # One character more than minimum if possible
         larger = min_length + 1
         if larger < BUFFER_SIZE and larger not in seen and (not max_length or larger <= max_length):
-            yield PositiveValue(ctx.generate_from_schema({**schema, "minLength": larger, "maxLength": larger}))
+            yield PositiveValue(
+                ctx.generate_from_schema({**schema, "minLength": larger, "maxLength": larger}),
+                description="Near-boundary length string",
+            )
             seen.add(larger)
 
     if max_length is not None:
         # Exactly the maximum length
         if max_length < BUFFER_SIZE and max_length not in seen:
-            yield PositiveValue(ctx.generate_from_schema({**schema, "minLength": max_length}))
+            yield PositiveValue(
+                ctx.generate_from_schema({**schema, "minLength": max_length}), description="Maximum length string"
+            )
             seen.add(max_length)
 
         # One character less than maximum if possible
@@ -337,7 +362,10 @@ def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
             and smaller not in seen
             and (smaller > 0 and (min_length is None or smaller >= min_length))
         ):
-            yield PositiveValue(ctx.generate_from_schema({**schema, "minLength": smaller, "maxLength": smaller}))
+            yield PositiveValue(
+                ctx.generate_from_schema({**schema, "minLength": smaller, "maxLength": smaller}),
+                description="Near-boundary length string",
+            )
             seen.add(smaller)
 
 
@@ -367,19 +395,19 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
 
     if example or examples or default:
         if example:
-            yield PositiveValue(example)
+            yield PositiveValue(example, description="Example value")
         if examples:
             for example in examples:
-                yield PositiveValue(example)
+                yield PositiveValue(example, description="Example value")
         if (
             default
             and not (example is not None and default == example)
             and not (examples is not None and any(default == ex for ex in examples))
         ):
-            yield PositiveValue(default)
+            yield PositiveValue(default, description="Default value")
     elif not minimum and not maximum:
         # Default positive value
-        yield PositiveValue(ctx.generate_from_schema(schema))
+        yield PositiveValue(ctx.generate_from_schema(schema), description="Valid number")
 
     seen = set()
 
@@ -390,7 +418,7 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
         else:
             smallest = minimum
         seen.add(smallest)
-        yield PositiveValue(smallest)
+        yield PositiveValue(smallest, description="Minimum value")
 
         # One more than minimum if possible
         if multiple_of is not None:
@@ -399,7 +427,7 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
             larger = minimum + 1
         if larger not in seen and (not maximum or larger <= maximum):
             seen.add(larger)
-            yield PositiveValue(larger)
+            yield PositiveValue(larger, description="Near-boundary number")
 
     if maximum is not None:
         # Exactly the maximum
@@ -409,7 +437,7 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
             largest = maximum
         if largest not in seen:
             seen.add(largest)
-            yield PositiveValue(largest)
+            yield PositiveValue(largest, description="Maximum value")
 
         # One less than maximum if possible
         if multiple_of is not None:
@@ -418,7 +446,7 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
             smaller = maximum - 1
         if smaller not in seen and (smaller > 0 and (minimum is None or smaller >= minimum)):
             seen.add(smaller)
-            yield PositiveValue(smaller)
+            yield PositiveValue(smaller, description="Near-boundary number")
 
 
 def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Generator[GeneratedValue, None, None]:
@@ -429,18 +457,18 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
 
     if example or examples or default:
         if example:
-            yield PositiveValue(example)
+            yield PositiveValue(example, description="Example value")
         if examples:
             for example in examples:
-                yield PositiveValue(example)
+                yield PositiveValue(example, description="Example value")
         if (
             default
             and not (example is not None and default == example)
             and not (examples is not None and any(default == ex for ex in examples))
         ):
-            yield PositiveValue(default)
+            yield PositiveValue(default, description="Default value")
     else:
-        yield PositiveValue(template)
+        yield PositiveValue(template, description="Valid array")
     seen.add(len(template))
 
     # Boundary and near-boundary sizes
@@ -452,12 +480,18 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
         # One item more than minimum if possible
         larger = min_items + 1
         if larger not in seen and (max_items is None or larger <= max_items):
-            yield PositiveValue(ctx.generate_from_schema({**schema, "minItems": larger, "maxItems": larger}))
+            yield PositiveValue(
+                ctx.generate_from_schema({**schema, "minItems": larger, "maxItems": larger}),
+                description="Near-boundary items array",
+            )
             seen.add(larger)
 
     if max_items is not None:
         if max_items < BUFFER_SIZE and max_items not in seen:
-            yield PositiveValue(ctx.generate_from_schema({**schema, "minItems": max_items}))
+            yield PositiveValue(
+                ctx.generate_from_schema({**schema, "minItems": max_items}),
+                description="Maximum items array",
+            )
             seen.add(max_items)
 
         # One item smaller than maximum if possible
@@ -468,7 +502,10 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
             and smaller not in seen
             and (min_items is None or smaller >= min_items)
         ):
-            yield PositiveValue(ctx.generate_from_schema({**schema, "minItems": smaller, "maxItems": smaller}))
+            yield PositiveValue(
+                ctx.generate_from_schema({**schema, "minItems": smaller, "maxItems": smaller}),
+                description="Near-boundary items array",
+            )
             seen.add(smaller)
 
 
@@ -479,19 +516,18 @@ def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Gene
 
     if example or examples or default:
         if example:
-            yield PositiveValue(example)
+            yield PositiveValue(example, description="Example value")
         if examples:
             for example in examples:
-                yield PositiveValue(example)
+                yield PositiveValue(example, description="Example value")
         if (
             default
             and not (example is not None and default == example)
             and not (examples is not None and any(default == ex for ex in examples))
         ):
-            yield PositiveValue(default)
-
+            yield PositiveValue(default, description="Default value")
     else:
-        yield PositiveValue(template)
+        yield PositiveValue(template, description="Valid object")
 
     properties = schema.get("properties", {})
     required = set(schema.get("required", []))
@@ -502,22 +538,24 @@ def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Gene
     for name in optional:
         combo = {k: v for k, v in template.items() if k in required or k == name}
         if combo != template:
-            yield PositiveValue(combo)
+            yield PositiveValue(combo, description=f"Object with all required properties and '{name}'")
     # Generate one combination for each size from 2 to N-1
     for selection in select_combinations(optional):
         combo = {k: v for k, v in template.items() if k in required or k in selection}
-        yield PositiveValue(combo)
+        yield PositiveValue(combo, description="Object with all required and a subset of optional properties")
     # Generate only required properties
     if set(properties) != required:
         only_required = {k: v for k, v in template.items() if k in required}
-        yield PositiveValue(only_required)
+        yield PositiveValue(only_required, description="Object with only required properties")
     seen = set()
     for name, sub_schema in properties.items():
         seen.add(_to_hashable_key(template.get(name)))
         for new in cover_schema_iter(ctx, sub_schema):
             key = _to_hashable_key(new.value)
             if key not in seen:
-                yield PositiveValue({**template, name: new.value})
+                yield PositiveValue(
+                    {**template, name: new.value}, description=f"Object with valid '{name}' value: {new.description}"
+                )
                 seen.add(key)
         seen.clear()
 
@@ -528,9 +566,12 @@ def select_combinations(optional: list[str]) -> Iterator[tuple[str, ...]]:
 
 
 def _negative_enum(ctx: CoverageContext, value: list) -> Generator[GeneratedValue, None, None]:
-    strategy = JSON_STRATEGY.filter(lambda x: x not in value)
+    def is_not_in_value(x: Any) -> bool:
+        return x not in value
+
+    strategy = JSON_STRATEGY.filter(is_not_in_value)
     # The exact negative value is not important here
-    yield NegativeValue(ctx.generate_from(strategy, cached=True))
+    yield NegativeValue(ctx.generate_from(strategy), description="Invalid enum value")
 
 
 def _negative_properties(
@@ -539,11 +580,17 @@ def _negative_properties(
     nctx = ctx.with_negative()
     for key, sub_schema in properties.items():
         for value in cover_schema_iter(nctx, sub_schema):
-            yield NegativeValue({**template, key: value.value})
+            yield NegativeValue(
+                {**template, key: value.value},
+                description=f"Object with invalid '{key}' value: {value.description}",
+            )
 
 
 def _negative_pattern(ctx: CoverageContext, pattern: str) -> Generator[GeneratedValue, None, None]:
-    yield NegativeValue(ctx.generate_from(st.text().filter(lambda x: x != pattern), cached=True))
+    yield NegativeValue(
+        ctx.generate_from(st.text().filter(pattern.__ne__)),
+        description=f"Value not matching the '{pattern}' pattern",
+    )
 
 
 def _with_negated_key(schema: dict, key: str, value: Any) -> dict:
@@ -553,19 +600,33 @@ def _with_negated_key(schema: dict, key: str, value: Any) -> dict:
 def _negative_multiple_of(
     ctx: CoverageContext, schema: dict, multiple_of: int | float
 ) -> Generator[GeneratedValue, None, None]:
-    yield NegativeValue(ctx.generate_from_schema(_with_negated_key(schema, "multipleOf", multiple_of)))
+    yield NegativeValue(
+        ctx.generate_from_schema(_with_negated_key(schema, "multipleOf", multiple_of)),
+        description=f"Non-multiple of {multiple_of}",
+    )
 
 
 def _negative_unique_items(ctx: CoverageContext, schema: dict) -> Generator[GeneratedValue, None, None]:
     unique = ctx.generate_from_schema({**schema, "type": "array", "minItems": 1, "maxItems": 1})
-    yield NegativeValue(unique + unique)
+    yield NegativeValue(unique + unique, description="Non-unique items")
 
 
 def _negative_required(
     ctx: CoverageContext, template: dict, required: list[str]
 ) -> Generator[GeneratedValue, None, None]:
     for key in required:
-        yield NegativeValue({k: v for k, v in template.items() if k != key})
+        yield NegativeValue(
+            {k: v for k, v in template.items() if k != key},
+            description=f"Missing required property: {key}",
+        )
+
+
+def _is_invalid_hostname(v: Any) -> bool:
+    return v == "" or not jsonschema.Draft202012Validator.FORMAT_CHECKER.conforms(v, "hostname")
+
+
+def _is_invalid_format(v: Any, format: str) -> bool:
+    return not jsonschema.Draft202012Validator.FORMAT_CHECKER.conforms(v, format)
 
 
 def _negative_format(ctx: CoverageContext, schema: dict, format: str) -> Generator[GeneratedValue, None, None]:
@@ -574,11 +635,15 @@ def _negative_format(ctx: CoverageContext, schema: dict, format: str) -> Generat
     without_format.setdefault("type", "string")
     strategy = from_schema(without_format)
     if format in jsonschema.Draft202012Validator.FORMAT_CHECKER.checkers:
-        strategy = strategy.filter(
-            lambda v: (format == "hostname" and v == "")
-            or not jsonschema.Draft202012Validator.FORMAT_CHECKER.conforms(v, format)
-        )
-    yield NegativeValue(ctx.generate_from(strategy))
+        if format == "hostname":
+            strategy = strategy.filter(_is_invalid_hostname)
+        else:
+            strategy = strategy.filter(functools.partial(_is_invalid_format, format=format))
+    yield NegativeValue(ctx.generate_from(strategy), description=f"Value not matching the '{format}' format")
+
+
+def _is_non_integer_float(x: float) -> bool:
+    return x != int(x)
 
 
 def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Generator[GeneratedValue, None, None]:
@@ -600,13 +665,13 @@ def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Gene
     if "number" in types:
         del strategies["integer"]
     if "integer" in types:
-        strategies["number"] = FLOAT_STRATEGY.filter(lambda x: x != int(x))
+        strategies["number"] = FLOAT_STRATEGY.filter(_is_non_integer_float)
     for strat in strategies.values():
-        value = ctx.generate_from(strat, cached=True)
+        value = ctx.generate_from(strat)
         hashed = _to_hashable_key(value)
         if hashed in seen:
             continue
-        yield NegativeValue(value)
+        yield NegativeValue(value, description="Incorrect type")
         seen.add(hashed)
 
 

schemathesis/internal/checks.py

@@ -6,6 +6,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Callable, Optional
 
 if TYPE_CHECKING:
+    from requests.auth import HTTPDigestAuth
     from requests.structures import CaseInsensitiveDict
 
     from ..models import Case
@@ -23,7 +24,7 @@ class CheckContext:
     Provides access to broader test execution data beyond individual test cases.
     """
 
-    auth: RawAuth | None = None
+    auth: HTTPDigestAuth | RawAuth | None = None
     headers: CaseInsensitiveDict | None = None
 
 

schemathesis/models.py

@@ -154,8 +154,9 @@ class GenerationMetadata:
     cookies: DataGenerationMethod | None
     body: DataGenerationMethod | None
     phase: TestPhase
+    description: str | None
 
-    __slots__ = ("query", "path_parameters", "headers", "cookies", "body", "phase")
+    __slots__ = ("query", "path_parameters", "headers", "cookies", "body", "phase", "description")
 
 
 @dataclass(repr=False)
@@ -1017,6 +1018,7 @@ class Interaction:
     status: Status
     data_generation_method: DataGenerationMethod
     phase: TestPhase | None
+    description: str | None
     recorded_at: str = field(default_factory=lambda: datetime.datetime.now(TIMEZONE).isoformat())
 
     @classmethod
@@ -1046,6 +1048,7 @@ class Interaction:
             checks=checks,
             data_generation_method=cast(DataGenerationMethod, case.data_generation_method),
             phase=case.meta.phase if case.meta is not None else None,
+            description=case.meta.description if case.meta is not None else None,
         )
 
     @classmethod
@@ -1069,6 +1072,7 @@ class Interaction:
             checks=checks,
             data_generation_method=cast(DataGenerationMethod, case.data_generation_method),
             phase=case.meta.phase if case.meta is not None else None,
+            description=case.meta.description if case.meta is not None else None,
         )
 
 

schemathesis/runner/serialization.py

@@ -395,6 +395,7 @@ class SerializedInteraction:
     status: Status
     data_generation_method: DataGenerationMethod
     phase: TestPhase | None
+    description: str | None
     recorded_at: str
 
     @classmethod
@@ -406,6 +407,7 @@ class SerializedInteraction:
             status=interaction.status,
             data_generation_method=interaction.data_generation_method,
             phase=interaction.phase,
+            description=interaction.description,
             recorded_at=interaction.recorded_at,
         )
 

schemathesis/specs/openapi/_hypothesis.py

@@ -215,6 +215,7 @@ def get_case_strategy(
             cookies=cookies_.generator,
             body=body_.generator,
             phase=phase,
+            description=None,
         ),
     )
     auth_context = auths.AuthContext(

schemathesis/specs/openapi/definitions.py

@@ -1330,6 +1330,8 @@ OPENAPI_30 = {
         },
     },
 }
+# Generated from the updated schema.yaml from 0035208, which includes unpublished bugfixes
+# https://github.com/OAI/OpenAPI-Specification/blob/0035208611701b4f7f2c959eb99a8725cca41e6e/schemas/v3.1/schema.yaml
 OPENAPI_31 = {
     "$id": "https://spec.openapis.org/oas/3.1/schema/2022-10-07",
     "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -1345,7 +1347,7 @@ OPENAPI_31 = {
         },
         "servers": {"type": "array", "items": {"$ref": "#/$defs/server"}, "default": [{"url": "/"}]},
         "paths": {"$ref": "#/$defs/paths"},
-        "webhooks": {"type": "object", "additionalProperties": {"$ref": "#/$defs/path-item-or-reference"}},
+        "webhooks": {"type": "object", "additionalProperties": {"$ref": "#/$defs/path-item"}},
         "components": {"$ref": "#/$defs/components"},
         "security": {"type": "array", "items": {"$ref": "#/$defs/security-requirement"}},
         "tags": {"type": "array", "items": {"$ref": "#/$defs/tag"}},
@@ -1400,7 +1402,7 @@ OPENAPI_31 = {
             "$comment": "https://spec.openapis.org/oas/v3.1.0#server-object",
             "type": "object",
             "properties": {
-                "url": {"type": "string", "format": "uri-reference"},
+                "url": {"type": "string"},
                 "description": {"type": "string"},
                 "variables": {"type": "object", "additionalProperties": {"$ref": "#/$defs/server-variable"}},
             },
@@ -1439,7 +1441,7 @@ OPENAPI_31 = {
                 },
                 "links": {"type": "object", "additionalProperties": {"$ref": "#/$defs/link-or-reference"}},
                 "callbacks": {"type": "object", "additionalProperties": {"$ref": "#/$defs/callbacks-or-reference"}},
-                "pathItems": {"type": "object", "additionalProperties": {"$ref": "#/$defs/path-item-or-reference"}},
+                "pathItems": {"type": "object", "additionalProperties": {"$ref": "#/$defs/path-item"}},
             },
             "patternProperties": {
                 "^(schemas|responses|parameters|examples|requestBodies|headers|securitySchemes|links|callbacks|pathItems)$": {
@@ -1461,6 +1463,7 @@ OPENAPI_31 = {
             "$comment": "https://spec.openapis.org/oas/v3.1.0#path-item-object",
             "type": "object",
             "properties": {
+                "$ref": {"type": "string", "format": "uri-reference"},
                 "summary": {"type": "string"},
                 "description": {"type": "string"},
                 "servers": {"type": "array", "items": {"$ref": "#/$defs/server"}},
@@ -1477,11 +1480,6 @@ OPENAPI_31 = {
             "$ref": "#/$defs/specification-extensions",
             "unevaluatedProperties": False,
         },
-        "path-item-or-reference": {
-            "if": {"type": "object", "required": ["$ref"]},
-            "then": {"$ref": "#/$defs/reference"},
-            "else": {"$ref": "#/$defs/path-item"},
-        },
         "operation": {
             "$comment": "https://spec.openapis.org/oas/v3.1.0#operation-object",
             "type": "object",
@@ -1542,7 +1540,6 @@ OPENAPI_31 = {
                             "if": {"properties": {"in": {"const": "path"}}, "required": ["in"]},
                             "then": {
                                 "properties": {
-                                    "name": {"pattern": "[^/#?]+$"},
                                     "style": {"default": "simple", "enum": ["matrix", "label", "simple"]},
                                     "required": {"const": True},
                                 },
@@ -1662,7 +1659,7 @@ OPENAPI_31 = {
             "$comment": "https://spec.openapis.org/oas/v3.1.0#callback-object",
             "type": "object",
             "$ref": "#/$defs/specification-extensions",
-            "additionalProperties": {"$ref": "#/$defs/path-item-or-reference"},
+            "additionalProperties": {"$ref": "#/$defs/path-item"},
         },
         "callbacks-or-reference": {
             "if": {"type": "object", "required": ["$ref"]},
@@ -1755,7 +1752,6 @@ OPENAPI_31 = {
                 "summary": {"type": "string"},
                 "description": {"type": "string"},
             },
-            "unevaluatedProperties": False,
         },
         "schema": {
             "$comment": "https://spec.openapis.org/oas/v3.1.0#schema-object",

schemathesis/stateful/runner.py

@@ -12,6 +12,7 @@ from hypothesis.control import current_build_context
 from hypothesis.errors import Flaky, Unsatisfiable
 
 from ..exceptions import CheckFailed
+from ..internal.checks import CheckContext
 from ..targets import TargetMetricCollector
 from . import events
 from .config import StatefulTestRunnerConfig
@@ -113,6 +114,7 @@ def _execute_state_machine_loop(
 ) -> None:
     """Execute the state machine testing loop."""
     from hypothesis import reporting
+    from requests.structures import CaseInsensitiveDict
 
     from ..transports import RequestsTransport
 
@@ -129,6 +131,7 @@ def _execute_state_machine_loop(
         if config.auth is not None:
             session.auth = config.auth
         call_kwargs["session"] = session
+    check_ctx = CheckContext(auth=config.auth, headers=CaseInsensitiveDict(config.headers) if config.headers else None)
 
     class _InstrumentedStateMachine(state_machine):  # type: ignore[valid-type,misc]
         """State machine with additional hooks for emitting events."""
@@ -223,7 +226,8 @@ def _execute_state_machine_loop(
             validate_response(
                 response=response,
                 case=case,
-                ctx=ctx,
+                runner_ctx=ctx,
+                check_ctx=check_ctx,
                 checks=config.checks,
                 additional_checks=additional_checks,
                 max_response_time=config.max_response_time,

schemathesis/stateful/validation.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from ..exceptions import CheckFailed, get_grouped_exception
 from ..internal.checks import CheckContext
@@ -17,27 +17,24 @@ def validate_response(
     *,
     response: GenericResponse,
     case: Case,
-    ctx: RunnerContext,
+    runner_ctx: RunnerContext,
+    check_ctx: CheckContext,
     checks: tuple[CheckFunction, ...],
     additional_checks: tuple[CheckFunction, ...] = (),
     max_response_time: int | None = None,
-    headers: dict[str, Any] | None = None,
 ) -> None:
     """Validate the response against the provided checks."""
-    from requests.structures import CaseInsensitiveDict
-
     from .._compat import MultipleFailures
     from ..checks import _make_max_response_time_failure_message
     from ..failures import ResponseTimeExceeded
     from ..models import Check, Status
 
     exceptions: list[CheckFailed | AssertionError] = []
-    check_results = ctx.checks_for_step
-    check_ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
+    check_results = runner_ctx.checks_for_step
 
     def _on_failure(exc: CheckFailed | AssertionError, message: str, context: FailureContext | None) -> None:
         exceptions.append(exc)
-        if ctx.is_seen_in_suite(exc):
+        if runner_ctx.is_seen_in_suite(exc):
             return
         failed_check = Check(
             name=name,
@@ -49,9 +46,9 @@ def validate_response(
             context=context,
             request=None,
         )
-        ctx.add_failed_check(failed_check)
+        runner_ctx.add_failed_check(failed_check)
         check_results.append(failed_check)
-        ctx.mark_as_seen_in_suite(exc)
+        runner_ctx.mark_as_seen_in_suite(exc)
 
     def _on_passed(_name: str, _case: Case) -> None:
         passed_check = Check(
@@ -72,16 +69,16 @@ def validate_response(
             if not skip_check:
                 _on_passed(name, copied_case)
         except CheckFailed as exc:
-            if ctx.is_seen_in_run(exc):
+            if runner_ctx.is_seen_in_run(exc):
                 continue
             _on_failure(exc, str(exc), exc.context)
         except AssertionError as exc:
-            if ctx.is_seen_in_run(exc):
+            if runner_ctx.is_seen_in_run(exc):
                 continue
             _on_failure(exc, str(exc) or f"Custom check failed: `{name}`", None)
         except MultipleFailures as exc:
             for subexc in exc.exceptions:
-                if ctx.is_seen_in_run(subexc):
+                if runner_ctx.is_seen_in_run(subexc):
                     continue
                 _on_failure(subexc, str(subexc), subexc.context)
 
@@ -93,7 +90,7 @@ def validate_response(
             try:
                 raise AssertionError(message)
             except AssertionError as _exc:
-                if not ctx.is_seen_in_run(_exc):
+                if not runner_ctx.is_seen_in_run(_exc):
                     _on_failure(_exc, message, context)
         else:
             _on_passed("max_response_time", case)

schemathesis/transports/__init__.py

@@ -7,7 +7,7 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from datetime import timedelta
 from inspect import iscoroutinefunction
-from typing import TYPE_CHECKING, Any, Generator, Optional, Protocol, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Generator, Protocol, TypeVar, cast
 from urllib.parse import urlparse
 
 from .. import failures

{schemathesis-3.36.2.dist-info → schemathesis-3.36.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.36.2
+Version: 3.36.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://schemathesis.readthedocs.io/en/stable/changelog.html

{schemathesis-3.36.2.dist-info → schemathesis-3.36.4.dist-info}/RECORD

@@ -1,7 +1,7 @@
 schemathesis/__init__.py,sha256=UW2Bq8hDDkcBeAAA7PzpBFXkOOxkmHox-mfQwzHDjL0,1914
 schemathesis/_compat.py,sha256=y4RZd59i2NCnZ91VQhnKeMn_8t3SgvLOk2Xm8nymUHY,1837
 schemathesis/_dependency_versions.py,sha256=pjEkkGAfOQJYNb-9UOo84V8nj_lKHr_TGDVdFwY2UU0,816
-schemathesis/_hypothesis.py,sha256=Sj7pGspDGeevcPgLkCF1pV7T5HleF84nZd7FbDUs_vE,14646
+schemathesis/_hypothesis.py,sha256=TUGODyKJzTSnUQPWt_uj6-MBXCPthquJXGiCobVdFh0,14930
 schemathesis/_lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
 schemathesis/_override.py,sha256=TAjYB3eJQmlw9K_xiR9ptt9Wj7if4U7UFlUhGjpBAoM,1625
 schemathesis/_rate_limiter.py,sha256=q_XWst5hzuAyXQRiZc4s_bx7-JlPYZM_yKDmeavt3oo,242
@@ -17,7 +17,7 @@ schemathesis/graphql.py,sha256=XiuKcfoOB92iLFC8zpz2msLkM0_V0TLdxPNBqrrGZ8w,216
 schemathesis/hooks.py,sha256=qXyVRfJdhsLk1GuJX47VAqkX0VPm6X6fK-cXhEnFLT4,14765
 schemathesis/lazy.py,sha256=uE8ef_7U_9ovs0-7UA7ssIiiDipJurJFHuxaUFOUETo,18956
 schemathesis/loaders.py,sha256=MoEhcdOEBJxNRn5X-ZNhWB9jZDHQQNpkNfEdQjf_NDw,4590
-schemathesis/models.py,sha256=YNZ9EXVw0WreTy_3hw2aZ9OPS-0W7xePlh5h0dLmgvs,46411
+schemathesis/models.py,sha256=mgufFwK6pVWn6hjfJIJwbk0qZM-XUeUaVVaOOEPaR50,46646
 schemathesis/parameters.py,sha256=PndmqQRlEYsCt1kWjSShPsFf6vj7X_7FRdz_-A95eNg,2258
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/sanitization.py,sha256=Lycn1VVfula9B6XpzkxTHja7CZ7RHqbUh9kBic0Yi4M,9056
@@ -30,7 +30,7 @@ schemathesis/utils.py,sha256=8RkTZ9Ft5IUaGkxABhh34oU7WO2ouMsfgtvFPTx9alI,4875
 schemathesis/cli/__init__.py,sha256=OC6QO38QDf55DTIVwrWiQKz8BfTD5QcK574m67NCE2w,72862
 schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
 schemathesis/cli/callbacks.py,sha256=grMKlx_iGiJA4oJsYt_q8l354Y8Nb11IBvOKwbD0jOA,15192
-schemathesis/cli/cassettes.py,sha256=rephr8daCVGV0alG9XaNBpUOwF6AB6q_z81a-p4VZeo,19403
+schemathesis/cli/cassettes.py,sha256=jD1JTkkEALUUEyzyuJ-KuxgntfGodILUuOu3C9HKjIw,19412
 schemathesis/cli/constants.py,sha256=wk-0GsoJIel8wFFerQ6Kf_6eAYUtIWkwMFwyAqv3yj4,1635
 schemathesis/cli/context.py,sha256=j_lvYQiPa6Q7P4P_IGCM9V2y2gJSpDbpxIIzR5oFB2I,2567
 schemathesis/cli/debug.py,sha256=_YA-bX1ujHl4bqQDEum7M-I2XHBTEGbvgkhvcvKhmgU,658
@@ -58,11 +58,11 @@ schemathesis/fixups/__init__.py,sha256=RP5QYJVJhp8LXjhH89fCRaIVU26dHCy74jD9seoYM
 schemathesis/fixups/fast_api.py,sha256=mn-KzBqnR8jl4W5fY-_ZySabMDMUnpzCIESMHnlvE1c,1304
 schemathesis/fixups/utf8_bom.py,sha256=lWT9RNmJG8i-l5AXIpaCT3qCPUwRgzXPW3eoOjmZETA,745
 schemathesis/generation/__init__.py,sha256=29Zys_tD6kfngaC4zHeC6TOBZQcmo7CWm7KDSYsHStQ,1581
-schemathesis/generation/_hypothesis.py,sha256=QDBzpcM9eXPgLGGdCPdGlxCtfMXD4YBN9_6Oz73lofI,1406
+schemathesis/generation/_hypothesis.py,sha256=Aaol5w3TEOVZn8znrnnJCYfrll8eALW0dCRtz3k0Eis,1661
 schemathesis/generation/_methods.py,sha256=jCK09f4sedDfePrS-6BIiE-CcEE8fJ4ZHxq1BHoTltQ,1101
-schemathesis/generation/coverage.py,sha256=F_ABsBsQ7k4dR_sGI2ZNTUNRCjxpAPh5V80MYXx8F20,24758
+schemathesis/generation/coverage.py,sha256=rq7em0ifTQMZxprBE4NIJWFiV6PquKFcnMMSuR2-ohI,28268
 schemathesis/internal/__init__.py,sha256=93HcdG3LF0BbQKbCteOsFMa1w6nXl8yTmx87QLNJOik,161
-schemathesis/internal/checks.py,sha256=m6lY6x2Pkz6AjU8Hs-UMSDJZEOq8EcgZOCp6BQA7p_g,1668
+schemathesis/internal/checks.py,sha256=qxJ5Ndeiveh_BT0QZq0Vbv72-ZTpbevOY48XKGQC9Ec,1730
 schemathesis/internal/copy.py,sha256=DcL56z-d69kKR_5u8mlHvjSL1UTyUKNMAwexrwHFY1s,1031
 schemathesis/internal/datetime.py,sha256=zPLBL0XXLNfP-KYel3H2m8pnsxjsA_4d-zTOhJg2EPQ,136
 schemathesis/internal/deprecation.py,sha256=Ty5VBFBlufkITpP0WWTPIPbnB7biDi0kQgXVYWZp820,1273
@@ -75,7 +75,7 @@ schemathesis/internal/validation.py,sha256=G7i8jIMUpAeOnDsDF_eWYvRZe_yMprRswx0QA
 schemathesis/runner/__init__.py,sha256=dLvb4FvH1zvYyVj5i7naR0ehfKL7K8QBKKbBNp_ClY8,21536
 schemathesis/runner/events.py,sha256=cRKKSDvHvKLBIyFBz-J0JtAKshbGGKco9eaMyLCgzsY,11734
 schemathesis/runner/probes.py,sha256=no5AfO3kse25qvHevjeUfB0Q3C860V2AYzschUW3QMQ,5688
-schemathesis/runner/serialization.py,sha256=Rn8wUpxe8saWUBfSI60jK7-qPR-D2pY1ad1hD8qTHhE,20418
+schemathesis/runner/serialization.py,sha256=jHpfm1PgPAmorNkF8_rkzIYoeA43jpbSKeh5Hm5nqF0,20495
 schemathesis/runner/impl/__init__.py,sha256=1E2iME8uthYPBh9MjwVBCTFV-P3fi7AdphCCoBBspjs,199
 schemathesis/runner/impl/context.py,sha256=KT3Dl1HIUM29Jpp_DwfoSx_NbWFH_7s6gw-p2Sr-N24,2505
 schemathesis/runner/impl/core.py,sha256=bAPwfhLJrXLlPN6BDNGyQoO9v35YlmeuxAmyFTNQg5Y,47197
@@ -104,11 +104,11 @@ schemathesis/specs/graphql/schemas.py,sha256=b7QwglKbcYQCMjuYmqDsVoFu2o4xaA_kduU
 schemathesis/specs/graphql/validation.py,sha256=uINIOt-2E7ZuQV2CxKzwez-7L9tDtqzMSpnVoRWvxy0,1635
 schemathesis/specs/openapi/__init__.py,sha256=HDcx3bqpa6qWPpyMrxAbM3uTo0Lqpg-BUNZhDJSJKnw,279
 schemathesis/specs/openapi/_cache.py,sha256=PAiAu4X_a2PQgD2lG5H3iisXdyg4SaHpU46bRZvfNkM,4320
-schemathesis/specs/openapi/_hypothesis.py,sha256=ZbLo8hDf4WVmRKmKF6rhK47xetkVJmE59Ghu_p7kLCw,24293
+schemathesis/specs/openapi/_hypothesis.py,sha256=Ym1d3GXlabOSbDk_AEkmkZGl9EMIDpumciLZtfYNdUI,24323
 schemathesis/specs/openapi/checks.py,sha256=-4qOzkova0e4QSqdgsoUiOv2bg57HZmzbpAiAeotc3Q,22288
 schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnKDwCwPLhID4,783
 schemathesis/specs/openapi/converter.py,sha256=NkrzBNjtmVwQTeE73NOtwB_puvQTjxxqqrc7gD_yscc,3241
-schemathesis/specs/openapi/definitions.py,sha256=nEsCKn_LgqYjZ9nNWp-8KUIrB4S94pT3GsV5A8UIzDw,94043
+schemathesis/specs/openapi/definitions.py,sha256=WTkWwCgTc3OMxfKsqh6YDoGfZMTThSYrHGp8h0vLAK0,93935
 schemathesis/specs/openapi/examples.py,sha256=FwhPWca7bpdHpUp_LRoK09DVgusojO3aXXhXYrK373I,20354
 schemathesis/specs/openapi/formats.py,sha256=JmmkQWNAj5XreXb7Edgj4LADAf4m86YulR_Ec8evpJ4,1220
 schemathesis/specs/openapi/links.py,sha256=a8JmWM9aZhrR5CfyIh6t2SkfonMLfYKOScXY2XlZYN0,17749
@@ -140,19 +140,19 @@ schemathesis/stateful/__init__.py,sha256=HBg-h131EI8IipHQgufSaXe-CrFTKmffPVsoEFj
 schemathesis/stateful/config.py,sha256=huYzqDoD6x20p_VNAR79NgxPwUFO8UXoc3_z4BEuHqU,3586
 schemathesis/stateful/context.py,sha256=vJ9nxTTjI5wo7A6PBGCvVVO_7y-ELs3XERi9PxLzykA,5085
 schemathesis/stateful/events.py,sha256=CyYvyQebOaeTn6UevaB7HXOrUhxCWbqXMfQ7pZK7fV8,6727
-schemathesis/stateful/runner.py,sha256=doEzd7IOfrW1zPzRC0WOqR-N1x5FmaJVGOZur-za6Ao,12352
+schemathesis/stateful/runner.py,sha256=e3vvRrx0NwN20RdC0cC4mZjcsYezwkhoDwE1cCVOAlw,12615
 schemathesis/stateful/sink.py,sha256=bHYlgh-fMwg1Srxk_XGs0-WV34YccotwH9PGrxCK57A,2474
 schemathesis/stateful/state_machine.py,sha256=PFztY82W5enuXjO6k4Mz8fbHmDJ7Z8OLYZRWtuBeyjg,12956
 schemathesis/stateful/statistic.py,sha256=2-uU5xpT9CbMulKgJWLZN6MUpC0Fskf5yXTt4ef4NFA,542
-schemathesis/stateful/validation.py,sha256=mNiT8fT2aaxNwhyj2n2G-wxqtMPYxurtH4PYZNRXCzI,3848
-schemathesis/transports/__init__.py,sha256=UKt3GJboaPbwcX0vlBZB3i1rFF6tTBQkwDmzB-3o7ns,12892
+schemathesis/stateful/validation.py,sha256=23qSZjC1_xRmtCX4OqsyG6pGxdlo6IZYid695ZpDQyU,3747
+schemathesis/transports/__init__.py,sha256=ybH90TrGwODO5s94UMEX2P2HX-6Jb66X5UUOgKTbZz8,12882
 schemathesis/transports/asgi.py,sha256=bwW9vMd1h89Jh7I4jHJVwSNUQzHvc7-JOD5u4hSHZd8,212
 schemathesis/transports/auth.py,sha256=urSTO9zgFO1qU69xvnKHPFQV0SlJL3d7_Ojl0tLnZwo,1143
 schemathesis/transports/content_types.py,sha256=MiKOm-Hy5i75hrROPdpiBZPOTDzOwlCdnthJD12AJzI,2187
 schemathesis/transports/headers.py,sha256=hr_AIDOfUxsJxpHfemIZ_uNG3_vzS_ZeMEKmZjbYiBE,990
 schemathesis/transports/responses.py,sha256=OFD4ZLqwEFpo7F9vaP_SVgjhxAqatxIj38FS4XVq8Qs,1680
-schemathesis-3.36.2.dist-info/METADATA,sha256=eoWwbh8dfwwyl3EyHoJsV_MUm4zvKYGTMMehbfOJyyQ,12904
-schemathesis-3.36.2.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-schemathesis-3.36.2.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.36.2.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.36.2.dist-info/RECORD,,
+schemathesis-3.36.4.dist-info/METADATA,sha256=_FwLfobUt1E2LW6L-xhL-bMbe3VGSOgoykQT8DhOan0,12904
+schemathesis-3.36.4.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+schemathesis-3.36.4.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.36.4.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.36.4.dist-info/RECORD,,