schemathesis 4.0.0a7__py3-none-any.whl → 4.0.0a9__py3-none-any.whl

schemathesis/__init__.py

@@ -8,6 +8,8 @@ from schemathesis.core.version import SCHEMATHESIS_VERSION
 from schemathesis.generation import GenerationConfig, GenerationMode, HeaderConfig
 from schemathesis.generation.case import Case
 from schemathesis.generation.targets import TargetContext, TargetFunction, target
+from schemathesis.hooks import HookContext
+from schemathesis.schemas import BaseSchema
 
 __version__ = SCHEMATHESIS_VERSION
 
@@ -26,6 +28,8 @@ __all__ = [
     "Response",
     "TargetContext",
     "TargetFunction",
+    "HookContext",
+    "BaseSchema",
     "__version__",
     "auth",
     "check",

schemathesis/core/failures.py

@@ -251,7 +251,7 @@ class FailureGroup(BaseExceptionGroup):
         return super().__new__(cls, message, list(failures))
 
 
-class MessageBlock(Enum):
+class MessageBlock(str, Enum):
     CASE_ID = "case_id"
     FAILURE = "failure"
     STATUS = "status"

schemathesis/engine/phases/__init__.py

@@ -10,7 +10,7 @@ if TYPE_CHECKING:
     from schemathesis.engine.events import EventGenerator
 
 
-class PhaseName(enum.Enum):
+class PhaseName(str, enum.Enum):
     """Available execution phases."""
 
     PROBING = "API probing"

schemathesis/engine/phases/unit/__init__.py

@@ -51,43 +51,48 @@ def execute(engine: EngineContext, phase: Phase) -> events.EventGenerator:
     status = None
     is_executed = False
 
-    with WorkerPool(
-        workers_num=workers_num,
-        producer=producer,
-        worker_factory=worker_task,
-        ctx=engine,
-        mode=mode,
-        phase=phase.name,
-        suite_id=suite_started.id,
-    ) as pool:
-        try:
-            while True:
-                try:
-                    event = pool.events_queue.get(timeout=WORKER_TIMEOUT)
-                    is_executed = True
-                    if engine.is_interrupted:
-                        raise KeyboardInterrupt
-                    yield event
-                    if isinstance(event, events.NonFatalError):
-                        status = Status.ERROR
-                    if isinstance(event, events.ScenarioFinished):
-                        if event.status != Status.SKIP and (status is None or status < event.status):
-                            status = event.status
-                        if event.status in (Status.ERROR, Status.FAILURE):
-                            engine.control.count_failure()
-                    if isinstance(event, events.Interrupted) or engine.is_interrupted:
-                        status = Status.INTERRUPTED
-                        engine.stop()
-                    if engine.has_to_stop:
-                        break  # type: ignore[unreachable]
-                except queue.Empty:
-                    if all(not worker.is_alive() for worker in pool.workers):
-                        break
-                    continue
-        except KeyboardInterrupt:
-            engine.stop()
-            status = Status.INTERRUPTED
-            yield events.Interrupted(phase=phase.name)
+    try:
+        with WorkerPool(
+            workers_num=workers_num,
+            producer=producer,
+            worker_factory=worker_task,
+            ctx=engine,
+            mode=mode,
+            phase=phase.name,
+            suite_id=suite_started.id,
+        ) as pool:
+            try:
+                while True:
+                    try:
+                        event = pool.events_queue.get(timeout=WORKER_TIMEOUT)
+                        is_executed = True
+                        if engine.is_interrupted:
+                            raise KeyboardInterrupt
+                        yield event
+                        if isinstance(event, events.NonFatalError):
+                            status = Status.ERROR
+                        if isinstance(event, events.ScenarioFinished):
+                            if event.status != Status.SKIP and (status is None or status < event.status):
+                                status = event.status
+                            if event.status in (Status.ERROR, Status.FAILURE):
+                                engine.control.count_failure()
+                        if isinstance(event, events.Interrupted) or engine.is_interrupted:
+                            status = Status.INTERRUPTED
+                            engine.stop()
+                        if engine.has_to_stop:
+                            break  # type: ignore[unreachable]
+                    except queue.Empty:
+                        if all(not worker.is_alive() for worker in pool.workers):
+                            break
+                        continue
+            except KeyboardInterrupt:
+                # Soft stop, waiting for workers to terminate
+                engine.stop()
+                status = Status.INTERRUPTED
+                yield events.Interrupted(phase=phase.name)
+    except KeyboardInterrupt:
+        # Hard stop, don't wait for worker threads
+        pass
 
     if not is_executed:
         phase.skip_reason = PhaseSkipReason.NOTHING_TO_TEST

schemathesis/generation/coverage.py

@@ -37,6 +37,8 @@ def json_recursive_strategy(strategy: st.SearchStrategy) -> st.SearchStrategy:
 
 
 BUFFER_SIZE = 8 * 1024
+NEGATIVE_MODE_MAX_LENGTH_WITH_PATTERN = 100
+NEGATIVE_MODE_MAX_ITEMS = 15
 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(
@@ -150,7 +152,7 @@ class CoverageContext:
 
     def is_valid_for_location(self, value: Any) -> bool:
         if self.location in ("header", "cookie") and isinstance(value, str):
-            return is_latin_1_encodable(value) and not has_invalid_characters("", value)
+            return not value or (is_latin_1_encodable(value) and not has_invalid_characters("", value))
         return True
 
     def generate_from(self, strategy: st.SearchStrategy) -> Any:
@@ -257,6 +259,9 @@ def _cover_positive_for_type(
     if ty == "object" or ty == "array":
         template_schema = _get_template_schema(schema, ty)
         template = ctx.generate_from_schema(template_schema)
+    elif "properties" in schema or "required" in schema:
+        template_schema = _get_template_schema(schema, "object")
+        template = ctx.generate_from_schema(template_schema)
     else:
         template = None
     if GenerationMode.POSITIVE in ctx.generation_modes:
@@ -295,6 +300,8 @@ def _cover_positive_for_type(
                 yield from _positive_array(ctx, schema, cast(list, template))
             elif ty == "object":
                 yield from _positive_object(ctx, schema, cast(dict, template))
+        elif "properties" in schema or "required" in schema:
+            yield from _positive_object(ctx, schema, cast(dict, template))
 
 
 @contextmanager
@@ -387,41 +394,58 @@ def cover_schema_iter(
                             yield value_
                             seen.add(k)
                 elif key == "minLength" and 0 < value < BUFFER_SIZE:
-                    with suppress(InvalidArgument):
-                        min_length = max_length = value - 1
-                        new_schema = {**schema, "minLength": min_length, "maxLength": max_length}
-                        new_schema.setdefault("type", "string")
-                        if "pattern" in new_schema:
-                            new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
-                            if new_schema["pattern"] == schema["pattern"]:
-                                # Pattern wasn't updated, try to generate a valid value then shrink the string to the required length
-                                del new_schema["minLength"]
-                                del new_schema["maxLength"]
-                                value = ctx.generate_from_schema(new_schema)[:max_length]
-                            else:
-                                value = ctx.generate_from_schema(new_schema)
-                        else:
-                            value = ctx.generate_from_schema(new_schema)
+                    if value == 1:
+                        # In this case, the only possible negative string is an empty one
+                        # The `pattern` value may require an non-empty one and the generation will fail
+                        # However, it is fine to violate `pattern` here as it is negative string generation anyway
+                        value = ""
                         k = _to_hashable_key(value)
                         if k not in seen:
                             yield NegativeValue(
                                 value, description="String smaller than minLength", location=ctx.current_path
                             )
                             seen.add(k)
+                    else:
+                        with suppress(InvalidArgument):
+                            min_length = max_length = value - 1
+                            new_schema = {**schema, "minLength": min_length, "maxLength": max_length}
+                            new_schema.setdefault("type", "string")
+                            if "pattern" in new_schema:
+                                new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
+                                if new_schema["pattern"] == schema["pattern"]:
+                                    # Pattern wasn't updated, try to generate a valid value then shrink the string to the required length
+                                    del new_schema["minLength"]
+                                    del new_schema["maxLength"]
+                                    value = ctx.generate_from_schema(new_schema)[:max_length]
+                                else:
+                                    value = ctx.generate_from_schema(new_schema)
+                            else:
+                                value = ctx.generate_from_schema(new_schema)
+                            k = _to_hashable_key(value)
+                            if k not in seen:
+                                yield NegativeValue(
+                                    value, description="String smaller than minLength", location=ctx.current_path
+                                )
+                                seen.add(k)
                 elif key == "maxLength" and value < BUFFER_SIZE:
                     try:
                         min_length = max_length = value + 1
                         new_schema = {**schema, "minLength": min_length, "maxLength": max_length}
                         new_schema.setdefault("type", "string")
                         if "pattern" in new_schema:
-                            new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
-                            if new_schema["pattern"] == schema["pattern"]:
-                                # Pattern wasn't updated, try to generate a valid value then extend the string to the required length
-                                del new_schema["minLength"]
-                                del new_schema["maxLength"]
-                                value = ctx.generate_from_schema(new_schema).ljust(max_length, "0")
-                            else:
+                            if value > NEGATIVE_MODE_MAX_LENGTH_WITH_PATTERN:
+                                # Large `maxLength` value can be extremely slow to generate when combined with `pattern`
+                                del new_schema["pattern"]
                                 value = ctx.generate_from_schema(new_schema)
+                            else:
+                                new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
+                                if new_schema["pattern"] == schema["pattern"]:
+                                    # Pattern wasn't updated, try to generate a valid value then extend the string to the required length
+                                    del new_schema["minLength"]
+                                    del new_schema["maxLength"]
+                                    value = ctx.generate_from_schema(new_schema).ljust(max_length, "0")
+                                else:
+                                    value = ctx.generate_from_schema(new_schema)
                         else:
                             value = ctx.generate_from_schema(new_schema)
                         k = _to_hashable_key(value)
@@ -437,6 +461,61 @@ def cover_schema_iter(
                 elif key == "required":
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
                     yield from _negative_required(ctx, template, value)
+                elif key == "maxItems" and isinstance(value, int) and value < BUFFER_SIZE:
+                    if value > NEGATIVE_MODE_MAX_ITEMS:
+                        # It could be extremely slow to generate large arrays
+                        # Generate values up to the limit and reuse them to construct the final array
+                        new_schema = {
+                            **schema,
+                            "minItems": NEGATIVE_MODE_MAX_ITEMS,
+                            "maxItems": NEGATIVE_MODE_MAX_ITEMS,
+                            "type": "array",
+                        }
+                        array_value = ctx.generate_from_schema(new_schema)
+                        # Extend the array to be of length value + 1 by repeating its own elements
+                        diff = value + 1 - len(array_value)
+                        if diff > 0:
+                            array_value += (
+                                array_value * (diff // len(array_value)) + array_value[: diff % len(array_value)]
+                            )
+                        k = _to_hashable_key(array_value)
+                        if k not in seen:
+                            yield NegativeValue(
+                                array_value,
+                                description="Array with more items than allowed by maxItems",
+                                location=ctx.current_path,
+                            )
+                            seen.add(k)
+                    else:
+                        try:
+                            # Force the array to have one more item than allowed
+                            new_schema = {**schema, "minItems": value + 1, "maxItems": value + 1, "type": "array"}
+                            array_value = ctx.generate_from_schema(new_schema)
+                            k = _to_hashable_key(array_value)
+                            if k not in seen:
+                                yield NegativeValue(
+                                    array_value,
+                                    description="Array with more items than allowed by maxItems",
+                                    location=ctx.current_path,
+                                )
+                                seen.add(k)
+                        except (InvalidArgument, Unsatisfiable):
+                            pass
+                elif key == "minItems" and isinstance(value, int) and value > 0:
+                    try:
+                        # Force the array to have one less item than the minimum
+                        new_schema = {**schema, "minItems": value - 1, "maxItems": value - 1, "type": "array"}
+                        array_value = ctx.generate_from_schema(new_schema)
+                        k = _to_hashable_key(array_value)
+                        if k not in seen:
+                            yield NegativeValue(
+                                array_value,
+                                description="Array with fewer items than allowed by minItems",
+                                location=ctx.current_path,
+                            )
+                            seen.add(k)
+                    except (InvalidArgument, Unsatisfiable):
+                        pass
                 elif (
                     key == "additionalProperties"
                     and not value
@@ -653,19 +732,22 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
 
     if example or examples or default:
         if example:
+            seen.add(_to_hashable_key(example))
             yield PositiveValue(example, description="Example value")
         if examples:
             for example in examples:
+                seen.add(_to_hashable_key(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))
         ):
+            seen.add(_to_hashable_key(default))
             yield PositiveValue(default, description="Default value")
     else:
         yield PositiveValue(template, description="Valid array")
-    seen.add(len(template))
+    seen.add(_to_hashable_key(template))
 
     # Boundary and near-boundary sizes
     min_items = schema.get("minItems")
@@ -676,19 +758,19 @@ 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}),
-                description="Near-boundary items array",
-            )
-            seen.add(larger)
+            value = ctx.generate_from_schema({**schema, "minItems": larger, "maxItems": larger})
+            key = _to_hashable_key(value)
+            if key not in seen:
+                seen.add(key)
+                yield PositiveValue(value, description="Near-boundary items array")
 
     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}),
-                description="Maximum items array",
-            )
-            seen.add(max_items)
+            value = ctx.generate_from_schema({**schema, "minItems": max_items})
+            key = _to_hashable_key(value)
+            if key not in seen:
+                seen.add(key)
+                yield PositiveValue(value, description="Maximum items array")
 
         # One item smaller than maximum if possible
         smaller = max_items - 1
@@ -698,11 +780,26 @@ 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}),
-                description="Near-boundary items array",
-            )
-            seen.add(smaller)
+            value = ctx.generate_from_schema({**schema, "minItems": smaller, "maxItems": smaller})
+            key = _to_hashable_key(value)
+            if key not in seen:
+                seen.add(key)
+                yield PositiveValue(value, description="Near-boundary items array")
+
+    if "items" in schema and "enum" in schema["items"] and isinstance(schema["items"]["enum"], list) and max_items != 0:
+        # Ensure there is enough items to pass `minItems` if it is specified
+        length = min_items or 1
+        for variant in schema["items"]["enum"]:
+            value = [variant] * length
+            key = _to_hashable_key(value)
+            if key not in seen:
+                seen.add(key)
+                yield PositiveValue(value, description="Enum value from available for items array")
+    elif min_items is None and max_items is None and "items" in schema and isinstance(schema["items"], dict):
+        # Otherwise only an empty array is generated
+        sub_schema = schema["items"]
+        for item in cover_schema_iter(ctx, sub_schema):
+            yield PositiveValue([item.value], description=f"Single-item array: {item.description}")
 
 
 def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Generator[GeneratedValue, None, None]:
@@ -770,7 +867,12 @@ def _negative_enum(
         _hashed = _to_hashable_key(x)
         return _hashed not in seen
 
-    strategy = (st.none() | st.booleans() | NUMERIC_STRATEGY | st.text()).filter(is_not_in_value)
+    strategy = (
+        st.text(alphabet=st.characters(min_codepoint=65, max_codepoint=122, categories=["L"]), min_size=3)
+        | st.none()
+        | st.booleans()
+        | NUMERIC_STRATEGY
+    ).filter(is_not_in_value)
     value = ctx.generate_from(strategy)
     yield NegativeValue(value, description="Invalid enum value", location=ctx.current_path)
     hashed = _to_hashable_key(value)

schemathesis/generation/hypothesis/builder.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import asyncio
+import os
 from dataclasses import dataclass, field
 from enum import Enum
 from functools import wraps
@@ -10,12 +12,13 @@ from typing import Any, Callable, Generator, Mapping
 import hypothesis
 from hypothesis import Phase
 from hypothesis import strategies as st
+from hypothesis._settings import all_settings
 from hypothesis.errors import Unsatisfiable
 from jsonschema.exceptions import SchemaError
 
 from schemathesis import auths
 from schemathesis.auths import AuthStorage, AuthStorageMark
-from schemathesis.core import NOT_SET, NotSet, SpecificationFeature, media_types
+from schemathesis.core import NOT_SET, NotSet, SpecificationFeature, media_types, string_to_boolean
 from schemathesis.core.errors import InvalidSchema, SerializationNotPossible
 from schemathesis.core.marks import Mark
 from schemathesis.core.transport import prepare_urlencoded
@@ -38,7 +41,7 @@ from schemathesis.schemas import APIOperation, ParameterSet
 setup()
 
 
-class HypothesisTestMode(Enum):
+class HypothesisTestMode(str, Enum):
     EXAMPLES = "examples"
     COVERAGE = "coverage"
     FUZZING = "fuzzing"
@@ -96,7 +99,11 @@ def create_test(
         # Merge the user-provided settings with the current ones
         settings = hypothesis.settings(
             settings,
-            **{item: value for item, value in config.settings.__dict__.items() if value != getattr(default, item)},
+            **{
+                item: getattr(config.settings, item)
+                for item in all_settings
+                if getattr(config.settings, item) != getattr(default, item)
+            },
         )
 
     if Phase.explain in settings.phases:
@@ -120,8 +127,11 @@ def create_test(
     ):
         hypothesis_test = add_examples(hypothesis_test, operation, hook_dispatcher=hook_dispatcher, **strategy_kwargs)
 
+    disable_coverage = string_to_boolean(os.getenv("SCHEMATHESIS_DISABLE_COVERAGE", ""))
+
     if (
-        HypothesisTestMode.COVERAGE in config.modes
+        not disable_coverage
+        and HypothesisTestMode.COVERAGE in config.modes
         and Phase.explicit in settings.phases
         and specification.supports_feature(SpecificationFeature.COVERAGE)
         and not config.given_args
@@ -158,7 +168,24 @@ def create_base_test(
         __tracebackhide__ = True
         return test_function(*args, **kwargs)
 
-    return hypothesis.given(*args, **{**kwargs, "case": strategy})(test_wrapper)
+    funcobj = hypothesis.given(*args, **{**kwargs, "case": strategy})(test_wrapper)
+
+    if asyncio.iscoroutinefunction(test_function):
+        funcobj.hypothesis.inner_test = make_async_test(test_function)  # type: ignore
+    return funcobj
+
+
+def make_async_test(test: Callable) -> Callable:
+    def async_run(*args: Any, **kwargs: Any) -> None:
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+        coro = test(*args, **kwargs)
+        future = asyncio.ensure_future(coro, loop=loop)
+        loop.run_until_complete(future)
+
+    return async_run
 
 
 def add_examples(

schemathesis/hooks.py

@@ -21,7 +21,7 @@ HookDispatcherMark = Mark["HookDispatcher"](attr_name="hook_dispatcher")
 
 
 @unique
-class HookScope(Enum):
+class HookScope(int, Enum):
     GLOBAL = 1
     SCHEMA = 2
     TEST = 3

schemathesis/pytest/plugin.py

@@ -108,7 +108,12 @@ class SchemathesisCase(PyCollector):
         This implementation is based on the original one in pytest, but with slight adjustments
         to produce tests out of hypothesis ones.
         """
-        from schemathesis.generation.hypothesis.builder import HypothesisTestConfig, HypothesisTestMode, create_test
+        from schemathesis.generation.hypothesis.builder import (
+            HypothesisTestConfig,
+            HypothesisTestMode,
+            create_test,
+            make_async_test,
+        )
 
         is_trio_test = False
         for mark in getattr(self.test_function, "pytestmark", []):
@@ -221,19 +226,6 @@ class SchemathesisCase(PyCollector):
             pytest.fail("Error during collection")
 
 
-def make_async_test(test: Callable) -> Callable:
-    def async_run(*args: Any, **kwargs: Any) -> None:
-        try:
-            loop = asyncio.get_event_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-        coro = test(*args, **kwargs)
-        future = asyncio.ensure_future(coro, loop=loop)
-        loop.run_until_complete(future)
-
-    return async_run
-
-
 @hookimpl(hookwrapper=True)  # type:ignore
 def pytest_pycollect_makeitem(collector: nodes.Collector, name: str, obj: Any) -> Generator[None, Any, None]:
     """Switch to a different collector if the test is parametrized marked by schemathesis."""

schemathesis/schemas.py

@@ -14,7 +14,7 @@ from typing import (
     NoReturn,
     TypeVar,
 )
-from urllib.parse import quote, unquote, urljoin, urlsplit, urlunsplit
+from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
 
 from schemathesis import transport
 from schemathesis.core import NOT_SET, NotSet
@@ -436,6 +436,8 @@ class BaseSchema(Mapping):
         app: Any | NotSet = NOT_SET,
     ) -> Self:
         if not isinstance(base_url, NotSet):
+            if base_url is not None:
+                validate_base_url(base_url)
             self.base_url = base_url
         if not isinstance(location, NotSet):
             self.location = location
@@ -453,6 +455,21 @@ class BaseSchema(Mapping):
         return self
 
 
+INVALID_BASE_URL_MESSAGE = (
+    "The provided base URL is invalid. This URL serves as a prefix for all API endpoints you want to test. "
+    "Make sure it is a properly formatted URL."
+)
+
+
+def validate_base_url(value: str) -> None:
+    try:
+        netloc = urlparse(value).netloc
+    except ValueError as exc:
+        raise ValueError(INVALID_BASE_URL_MESSAGE) from exc
+    if value and not netloc:
+        raise ValueError(INVALID_BASE_URL_MESSAGE)
+
+
 @dataclass
 class APIOperationMap(Mapping):
     _schema: BaseSchema

schemathesis/specs/openapi/checks.py

@@ -460,7 +460,7 @@ def ensure_resource_availability(ctx: CheckContext, response: Response, case: Ca
     )
 
 
-class AuthKind(enum.Enum):
+class AuthKind(str, enum.Enum):
     EXPLICIT = "explicit"
     GENERATED = "generated"
 

schemathesis/specs/openapi/expressions/lexer.py

@@ -6,7 +6,7 @@ from typing import Callable, Generator
 
 
 @unique
-class TokenType(Enum):
+class TokenType(int, Enum):
     VARIABLE = 1
     STRING = 2
     POINTER = 3

schemathesis/specs/openapi/expressions/nodes.py

@@ -25,7 +25,7 @@ class Node:
 
 
 @unique
-class NodeType(Enum):
+class NodeType(str, Enum):
     URL = "$url"
     METHOD = "$method"
     STATUS_CODE = "$statusCode"

schemathesis/specs/openapi/negative/mutations.py

@@ -20,7 +20,7 @@ from .utils import can_negate
 T = TypeVar("T")
 
 
-class MutationResult(enum.Enum):
+class MutationResult(int, enum.Enum):
     """The result of applying some mutation to some schema.
 
     Failing to mutate something means that by applying some mutation, it is not possible to change

schemathesis/specs/openapi/parameters.py

@@ -134,6 +134,7 @@ class OpenAPI20Parameter(OpenAPIParameter):
         "multipleOf",
         "example",
         "examples",
+        "default",
     )
 
 
@@ -178,6 +179,7 @@ class OpenAPI30Parameter(OpenAPIParameter):
         "format",
         "example",
         "examples",
+        "default",
     )
 
     def from_open_api_to_json_schema(self, operation: APIOperation, open_api_schema: dict[str, Any]) -> dict[str, Any]:
@@ -230,6 +232,7 @@ class OpenAPI20Body(OpenAPIBody, OpenAPI20Parameter):
         "additionalProperties",
         "example",
         "examples",
+        "default",
     )
     # NOTE. For Open API 2.0 bodies, we still give `x-example` precedence over the schema-level `example` field to keep
     # the precedence rules consistent.

schemathesis/specs/openapi/patterns.py

@@ -69,13 +69,18 @@ def _handle_parsed_pattern(parsed: list, pattern: str, min_length: int | None, m
         trailing_anchor_length = _get_anchor_length(parsed[2][1])
         leading_anchor = pattern[:leading_anchor_length]
         trailing_anchor = pattern[-trailing_anchor_length:]
-        return (
-            leading_anchor
-            + _update_quantifier(
-                op, value, pattern[leading_anchor_length:-trailing_anchor_length], min_length, max_length
-            )
-            + trailing_anchor
-        )
+        # Special case for patterns canonicalisation. Some frameworks generate `\\w\\W` instead of `.`
+        # Such patterns lead to significantly slower data generation
+        if op == sre.IN and _matches_anything(value):
+            op = sre.ANY
+            value = None
+            inner_pattern = "."
+        elif op in REPEATS and len(value[2]) == 1 and value[2][0][0] == sre.IN and _matches_anything(value[2][0][1]):
+            value = (value[0], value[1], [(sre.ANY, None)], *value[3:])
+            inner_pattern = "."
+        else:
+            inner_pattern = pattern[leading_anchor_length:-trailing_anchor_length]
+        return leading_anchor + _update_quantifier(op, value, inner_pattern, min_length, max_length) + trailing_anchor
     elif (
         len(parsed) > 3
         and parsed[0][0] == ANCHOR
@@ -86,6 +91,19 @@ def _handle_parsed_pattern(parsed: list, pattern: str, min_length: int | None, m
     return pattern
 
 
+def _matches_anything(value: list) -> bool:
+    """Check if the given pattern is equivalent to '.' (match any character)."""
+    # Common forms: [\w\W], [\s\S], etc.
+    return value in (
+        [(sre.CATEGORY, sre.CATEGORY_WORD), (sre.CATEGORY, sre.CATEGORY_NOT_WORD)],
+        [(sre.CATEGORY, sre.CATEGORY_SPACE), (sre.CATEGORY, sre.CATEGORY_NOT_SPACE)],
+        [(sre.CATEGORY, sre.CATEGORY_DIGIT), (sre.CATEGORY, sre.CATEGORY_NOT_DIGIT)],
+        [(sre.CATEGORY, sre.CATEGORY_NOT_WORD), (sre.CATEGORY, sre.CATEGORY_WORD)],
+        [(sre.CATEGORY, sre.CATEGORY_NOT_SPACE), (sre.CATEGORY, sre.CATEGORY_SPACE)],
+        [(sre.CATEGORY, sre.CATEGORY_NOT_DIGIT), (sre.CATEGORY, sre.CATEGORY_DIGIT)],
+    )
+
+
 def _handle_anchored_pattern(parsed: list, pattern: str, min_length: int | None, max_length: int | None) -> str:
     """Update regex pattern with multiple quantified patterns to satisfy length constraints."""
     # Extract anchors
@@ -269,15 +287,28 @@ def _get_anchor_length(node_type: int) -> int:
     return 1  # ^ or $ or their multiline/locale/unicode variants
 
 
-def _update_quantifier(op: int, value: tuple, pattern: str, min_length: int | None, max_length: int | None) -> str:
+def _update_quantifier(
+    op: int, value: tuple | None, pattern: str, min_length: int | None, max_length: int | None
+) -> str:
     """Update the quantifier based on the operation type and given constraints."""
-    if op in REPEATS:
+    if op in REPEATS and value is not None:
         return _handle_repeat_quantifier(value, pattern, min_length, max_length)
     if op in (LITERAL, IN) and max_length != 0:
         return _handle_literal_or_in_quantifier(pattern, min_length, max_length)
+    if op == sre.ANY and value is None:
+        # Equivalent to `.` which is in turn is the same as `.{1}`
+        return _handle_repeat_quantifier(
+            SINGLE_ANY,
+            pattern,
+            min_length,
+            max_length,
+        )
     return pattern
 
 
+SINGLE_ANY = sre_parse.parse(".{1}")[0][1]
+
+
 def _handle_repeat_quantifier(
     value: tuple[int, int, tuple], pattern: str, min_length: int | None, max_length: int | None
 ) -> str:

schemathesis/specs/openapi/references.py

@@ -139,7 +139,10 @@ class ConvertingResolver(InliningResolver):
     def resolve(self, ref: str) -> tuple[str, Any]:
         url, document = super().resolve(ref)
         document = to_json_schema_recursive(
-            document, nullable_name=self.nullable_name, is_response_schema=self.is_response_schema
+            document,
+            nullable_name=self.nullable_name,
+            is_response_schema=self.is_response_schema,
+            update_quantifiers=False,
         )
         return url, document
 

schemathesis/specs/openapi/schemas.py

@@ -1022,24 +1022,30 @@ class SwaggerV20(BaseOpenAPISchema):
         content_types = self.get_request_payload_content_types(operation)
         is_multipart = "multipart/form-data" in content_types
 
-        def add_file(file_value: Any) -> None:
-            if isinstance(file_value, list):
-                for item in file_value:
-                    files.append((name, (None, item)))
-            else:
-                files.append((name, file_value))
+        known_fields: dict[str, dict] = {}
 
         for parameter in operation.body:
             if isinstance(parameter, OpenAPI20CompositeBody):
                 for form_parameter in parameter.definition:
-                    name = form_parameter.name
-                    # It might be not in `form_data`, if the parameter is optional
-                    if name in form_data:
-                        value = form_data[name]
-                        if form_parameter.definition.get("type") == "file" or is_multipart:
-                            add_file(value)
-                        else:
-                            data[name] = value
+                    known_fields[form_parameter.name] = form_parameter.definition
+
+        def add_file(name: str, value: Any) -> None:
+            if isinstance(value, list):
+                for item in value:
+                    files.append((name, (None, item)))
+            else:
+                files.append((name, value))
+
+        for name, value in form_data.items():
+            param_def = known_fields.get(name)
+            if param_def:
+                if param_def.get("type") == "file" or is_multipart:
+                    add_file(name, value)
+                else:
+                    data[name] = value
+            else:
+                # Unknown field — treat it as a file (safe default under multipart/form-data)
+                add_file(name, value)
         # `None` is the default value for `files` and `data` arguments in `requests.request`
         return files or None, data or None
 
@@ -1189,7 +1195,11 @@ class OpenApi30(SwaggerV20):
         files = []
         definition = operation.definition.raw
         if "$ref" in definition["requestBody"]:
-            body = self.resolver.resolve_all(definition["requestBody"], RECURSION_DEPTH_LIMIT)
+            self.resolver.push_scope(operation.definition.scope)
+            try:
+                body = self.resolver.resolve_all(definition["requestBody"], RECURSION_DEPTH_LIMIT)
+            finally:
+                self.resolver.pop_scope()
         else:
             body = definition["requestBody"]
         content = body["content"]
@@ -1202,14 +1212,19 @@ class OpenApi30(SwaggerV20):
                 break
         else:
             raise InternalError("No 'multipart/form-data' media type found in the schema")
-        for name, property_schema in (schema or {}).get("properties", {}).items():
-            if name in form_data:
-                if isinstance(form_data[name], list):
-                    files.extend([(name, item) for item in form_data[name]])
+        for name, value in form_data.items():
+            property_schema = (schema or {}).get("properties", {}).get(name)
+            if property_schema:
+                if isinstance(value, list):
+                    files.extend([(name, item) for item in value])
                 elif property_schema.get("format") in ("binary", "base64"):
-                    files.append((name, form_data[name]))
+                    files.append((name, value))
                 else:
-                    files.append((name, (None, form_data[name])))
+                    files.append((name, (None, value)))
+            elif isinstance(value, list):
+                files.extend([(name, item) for item in value])
+            else:
+                files.append((name, (None, value)))
         # `None` is the default value for `files` and `data` arguments in `requests.request`
         return files or None, None
 

{schemathesis-4.0.0a7.dist-info → schemathesis-4.0.0a9.dist-info}/METADATA

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

@@ -1,11 +1,11 @@
-schemathesis/__init__.py,sha256=ggp1CxctLo__wwFwlDhvtrexxDXGSbRjFKzXw_Twi7k,1139
+schemathesis/__init__.py,sha256=S9MD8cGyXWihyQikye9mSBpvrfUJbOItD5yr65vkx6A,1263
 schemathesis/auths.py,sha256=t-YuPyoLqL7jlRUH-45JxO7Ir3pYxpe31CRmNIJh7rI,15423
 schemathesis/checks.py,sha256=B5-ROnjvvwpaqgj_iQ7eCjGqvRRVT30eWNPLKmwdrM8,5084
 schemathesis/errors.py,sha256=VSZ-h9Bt7QvrvywOGB-MoHCshR8OWJegYlBxfVh5Vuw,899
 schemathesis/filters.py,sha256=CzVPnNSRLNgvLlU5_WssPEC0wpdQi0dMvDpHSQbAlkE,13577
-schemathesis/hooks.py,sha256=jTdN5GJbxHRMshxgcuI_th9ouuL32CN4m2Jt0pmT_bs,13148
+schemathesis/hooks.py,sha256=ZSGEnsLJ7UVezf4CcaJebVkjEpvwgJolJFZo5fjQNDc,13153
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schemathesis/schemas.py,sha256=Hs2pJTUa2Od3x5YRprrKYIfE7ndpKbAqeDylAWkB6yM,27407
+schemathesis/schemas.py,sha256=A2qAs1PY9wbRWk6PFnslWyIqzchAhu5oo_MsKL7uF8w,27952
 schemathesis/cli/__init__.py,sha256=U9gjzWWpiFhaqevPjZbwyTNjABdpvXETI4HgwdGKnvs,877
 schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
 schemathesis/cli/constants.py,sha256=rUixnqorraUFDtOu3Nmm1x_k0qbgmW9xW96kQB_fBCQ,338
@@ -40,7 +40,7 @@ schemathesis/core/control.py,sha256=IzwIc8HIAEMtZWW0Q0iXI7T1niBpjvcLlbuwOSmy5O8,
 schemathesis/core/curl.py,sha256=yuaCe_zHLGwUjEeloQi6W3tOA3cGdnHDNI17-5jia0o,1723
 schemathesis/core/deserialization.py,sha256=ygIj4fNaOd0mJ2IvTsn6bsabBt_2AbSLCz-z9UqfpdQ,2406
 schemathesis/core/errors.py,sha256=97Fk3udsMaS5xZrco7ZaShqe4W6g2aZ55J7d58HPRac,15881
-schemathesis/core/failures.py,sha256=jbbxOXB8LDYoLI97YrLCKi9XLuSqVqFJSLeeixVJPRU,8828
+schemathesis/core/failures.py,sha256=nt_KJAQnachw4Ey-rZ__P8q6nGJ_YekZiSLc6-PfFW0,8833
 schemathesis/core/fs.py,sha256=ItQT0_cVwjDdJX9IiI7EnU75NI2H3_DCEyyUjzg_BgI,472
 schemathesis/core/lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
 schemathesis/core/loaders.py,sha256=SQQ-8m64-D2FaOgvwKZLyTtLJuzP3RPo7Ud2BERK1c0,3404
@@ -63,24 +63,24 @@ schemathesis/engine/core.py,sha256=DfulRMVTivmZj-wwLekIhuSzLsFnuVPtSg7j9HyWdz0,5
 schemathesis/engine/errors.py,sha256=8PHYsuq2qIEJHm2FDf_UnWa4IDc-DRFTPckLAr22yhE,16895
 schemathesis/engine/events.py,sha256=gslRAWQKMPqBCQzLDS4wAbsKcVuONSy5SPqimJJJYT4,6250
 schemathesis/engine/recorder.py,sha256=K3HfMARrT5mPWXPnYebjjcq5CcsBRhMrtZwEL9_Lvtg,8432
-schemathesis/engine/phases/__init__.py,sha256=3p_T3JYBFOtrwtgmMM7J-6a41QJgk83dUtm7NKcVl3o,2490
+schemathesis/engine/phases/__init__.py,sha256=CuTBMaQIsGdtWw400maiwqfIbMyVv5_vHXV-SY5A5NI,2495
 schemathesis/engine/phases/probes.py,sha256=3M9g3E7CXbDDK_8inuvkRZibCCcoO2Ce5U3lnyTeWXQ,5131
 schemathesis/engine/phases/stateful/__init__.py,sha256=lWo2RLrutNblHvohTzofQqL22GORwBRA8bf6jvLuGPg,2391
 schemathesis/engine/phases/stateful/_executor.py,sha256=m1ZMqFUPc4Hdql10l0gF3tpP4JOImSA-XeBd4jg3Ll8,12443
 schemathesis/engine/phases/stateful/context.py,sha256=SKWsok-tlWbUDagiUmP7cLNW6DsgFDc_Afv0vQfWv6c,2964
-schemathesis/engine/phases/unit/__init__.py,sha256=LcBQpGNPeEFB9XPGpcHBcH-C7nF-e8bZNPop9PIfiKA,7861
+schemathesis/engine/phases/unit/__init__.py,sha256=QmtzIgP9KWLo-IY1kMyBqYXPMxFQz-WF2eVTWewqUfI,8174
 schemathesis/engine/phases/unit/_executor.py,sha256=buMEr7e01SFSeNuEQNGMf4hoiLxX9_sp0JhH4LBAk9M,12928
 schemathesis/engine/phases/unit/_pool.py,sha256=9OgmFd-ov1AAvcZGquK40PXkGLp7f2qCjZoPZuoZl4A,2529
 schemathesis/experimental/__init__.py,sha256=jYY3Mq6okqTRTMudPzcaT0JVjzJW5IN_ZVJdGU0stBs,2011
 schemathesis/generation/__init__.py,sha256=sWTRPTh-qDNkSfpM9rYI3v8zskH8_wFKUuPRg18fZI8,1627
 schemathesis/generation/case.py,sha256=Rt5MCUtPVYVQzNyjUx8magocPJpHV1svyuqQSTwUE-I,7306
-schemathesis/generation/coverage.py,sha256=hyDb465tBoCWE7nI-ZJjhTUzk7f2WDufaadWdSAkdr0,39276
+schemathesis/generation/coverage.py,sha256=YQHmC_wVQ9WBuThNr62LFort9WqHM1DHUtexk-ALSV8,45471
 schemathesis/generation/meta.py,sha256=36h6m4E7jzLGa8TCvl7eBl_xUWLiRul3qxzexl5cB58,2515
 schemathesis/generation/modes.py,sha256=t_EvKr2aOXYMsEfdMu4lLF4KCGcX1LVVyvzTkcpJqhk,663
 schemathesis/generation/overrides.py,sha256=FhqcFoliEvgW6MZyFPYemfLgzKt3Miy8Cud7OMOCb7g,3045
 schemathesis/generation/targets.py,sha256=_rN2qgxTE2EfvygiN-Fy3WmDnRH0ERohdx3sKRDaYhU,2120
 schemathesis/generation/hypothesis/__init__.py,sha256=Rl7QwvMBMJI7pBqTydplX6bXC420n0EGQHVm-vZgaYQ,1204
-schemathesis/generation/hypothesis/builder.py,sha256=6U4BaTx0VMVRXhmKrEakDSnHunIdEMQiBZfr89pdpP4,29618
+schemathesis/generation/hypothesis/builder.py,sha256=QDfZRpFjQ0KYFPgu2BVSlxop0TQL7fQc201jOMR4rSQ,30472
 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
@@ -99,7 +99,7 @@ schemathesis/pytest/__init__.py,sha256=7W0q-Thcw03IAQfXE_Mo8JPZpUdHJzfu85fjK1Zdf
 schemathesis/pytest/control_flow.py,sha256=F8rAPsPeNv_sJiJgbZYtTpwKWjauZmqFUaKroY2GmQI,217
 schemathesis/pytest/lazy.py,sha256=g7DpOeQNsjXC03FCG5e1L65iz3zE48qAyaqG81HzCZY,12028
 schemathesis/pytest/loaders.py,sha256=oQJ78yyuIm3Ye9X7giVjDB1vYfaW5UY5YuhaTLm_ZFU,266
-schemathesis/pytest/plugin.py,sha256=RDOuT25Uotese7W-SD3Pu-nb7zdnaPbyPOoJSkJKSoQ,12379
+schemathesis/pytest/plugin.py,sha256=TxbESQy9JPZBaIwUP4BHiIGFzPd2oMWwq_4VqFS_UfI,12067
 schemathesis/python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/python/asgi.py,sha256=5PyvuTBaivvyPUEi3pwJni91K1kX5Zc0u9c6c1D8a1Q,287
 schemathesis/python/wsgi.py,sha256=uShAgo_NChbfYaV1117e6UHp0MTg7jaR0Sy_to3Jmf8,219
@@ -113,28 +113,28 @@ schemathesis/specs/graphql/validation.py,sha256=-W1Noc1MQmTb4RX-gNXMeU2qkgso4mzV
 schemathesis/specs/openapi/__init__.py,sha256=C5HOsfuDJGq_3mv8CRBvRvb0Diy1p0BFdqyEXMS-loE,238
 schemathesis/specs/openapi/_cache.py,sha256=HpglmETmZU0RCHxp3DO_sg5_B_nzi54Zuw9vGzzYCxY,4295
 schemathesis/specs/openapi/_hypothesis.py,sha256=n_39iyz1rt2EdSe-Lyr-3sOIEyJIthnCVR4tGUUvH1c,21328
-schemathesis/specs/openapi/checks.py,sha256=m3n5N3_iZcS7inJojW47FF6dfbUQzrBH-bXwsCAOyhM,27737
+schemathesis/specs/openapi/checks.py,sha256=i4tVVkK1wLthdmG-zu7EaQLkBxJ2T3FkuHqw0dA4qlA,27742
 schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnKDwCwPLhID4,783
 schemathesis/specs/openapi/converter.py,sha256=lil8IewM5j8tvt4lpA9g_KITvIwx1M96i45DNSHNjoc,3505
 schemathesis/specs/openapi/definitions.py,sha256=8htclglV3fW6JPBqs59lgM4LnA25Mm9IptXBPb_qUT0,93949
 schemathesis/specs/openapi/examples.py,sha256=Xvjp60QUcLaeGsJRbi2i6XM15_4uO0ceVoClIaJehiE,21062
 schemathesis/specs/openapi/formats.py,sha256=ViVF3aFeFI1ctwGQbiRDXhU3so82P0BCaF2aDDbUUm8,2816
 schemathesis/specs/openapi/media_types.py,sha256=ADedOaNWjbAtAekyaKmNj9fY6zBTeqcNqBEjN0EWNhI,1014
-schemathesis/specs/openapi/parameters.py,sha256=hv1reNpSjVuzFbtMpSTwWZ75zcWTOy5ZE0ah6AVEqAo,14565
-schemathesis/specs/openapi/patterns.py,sha256=NLnGybcana_kYLVKVEjkEyAzdClAV0xKe4Oy4NVayMI,12834
-schemathesis/specs/openapi/references.py,sha256=YjD1xMlaYS7xLt6PrrVS20R72ZWHuFZFTa8Llzf54Rg,8808
-schemathesis/specs/openapi/schemas.py,sha256=VSeacEAVJJ6EKJ-llwOaX4aalzUTXyWP8s4wbxTqtWc,54720
+schemathesis/specs/openapi/parameters.py,sha256=tVL61gDe9A8_jwoVKZZvpXKPerMyq7vkAvwdMsi44TI,14622
+schemathesis/specs/openapi/patterns.py,sha256=EQdf4net9QtwngKv36FEr7l0-3_afIMrrBdpKUWGWGc,14382
+schemathesis/specs/openapi/references.py,sha256=c8Ufa8hp6Dyf-gPn5lpmyqF_GtqXIBWoKkj3bk3WaPA,8871
+schemathesis/specs/openapi/schemas.py,sha256=dL1uLz_twgJZUdYBcs2JJ3b8ZlQH3nrGUg1p78pm9Os,55169
 schemathesis/specs/openapi/security.py,sha256=6UWYMhL-dPtkTineqqBFNKca1i4EuoTduw-EOLeE0aQ,7149
 schemathesis/specs/openapi/serialization.py,sha256=VdDLmeHqxlWM4cxQQcCkvrU6XurivolwEEaT13ohelA,11972
 schemathesis/specs/openapi/utils.py,sha256=ER4vJkdFVDIE7aKyxyYatuuHVRNutytezgE52pqZNE8,900
 schemathesis/specs/openapi/expressions/__init__.py,sha256=hfuRtXD75tQFhzSo6QgDZ3zByyWeZRKevB8edszAVj4,2272
 schemathesis/specs/openapi/expressions/errors.py,sha256=YLVhps-sYcslgVaahfcUYxUSHlIfWL-rQMeT5PZSMZ8,219
 schemathesis/specs/openapi/expressions/extractors.py,sha256=Py3of3_vBACP4ljiZIcgd-xQCrWIpcMsfQFc0EtAUoA,470
-schemathesis/specs/openapi/expressions/lexer.py,sha256=LeVE6fgYT9-fIsXrv0-YrRHnI4VPisbwsexyh9Q5YU0,3982
-schemathesis/specs/openapi/expressions/nodes.py,sha256=YvpbAi8OFdb6RqqrqReGBeADpAmFaoyWN-lGiyYOXTc,4072
+schemathesis/specs/openapi/expressions/lexer.py,sha256=KFA8Z-Kh1IYUpKgwAnDtEucN9YLLpnFR1GQl8KddWlA,3987
+schemathesis/specs/openapi/expressions/nodes.py,sha256=63LC4mQHy3a0_tKiGIVWaUHu9L9IWilq6R004GLpjyY,4077
 schemathesis/specs/openapi/expressions/parser.py,sha256=e-ZxshrGE_5CVbgcZLYgdGSjdifgyzgKkLQp0dI0cJY,4503
 schemathesis/specs/openapi/negative/__init__.py,sha256=60QqVBTXPTsAojcf7GDs7v8WbOE_k3g_VC_DBeQUqBw,3749
-schemathesis/specs/openapi/negative/mutations.py,sha256=7jTjD9rt5vxWSVBL5Hx8Avj4WhTA63frDQiFMKysrUU,19248
+schemathesis/specs/openapi/negative/mutations.py,sha256=MIFVSWbZHW92KhpWruJT3XLisgc-rFnvYasRtwMmExs,19253
 schemathesis/specs/openapi/negative/types.py,sha256=a7buCcVxNBG6ILBM3A7oNTAX0lyDseEtZndBuej8MbI,174
 schemathesis/specs/openapi/negative/utils.py,sha256=ozcOIuASufLqZSgnKUACjX-EOZrrkuNdXX0SDnLoGYA,168
 schemathesis/specs/openapi/stateful/__init__.py,sha256=0pu_iGjRiKuqUDN3ewz1zUOt6f1SdvSxVtHC5uK-CYw,14750
@@ -146,8 +146,8 @@ schemathesis/transport/prepare.py,sha256=qQ6zXBw5NN2AIM0bzLAc5Ryc3dmMb0R6xN14lnR
 schemathesis/transport/requests.py,sha256=j5wI1Uo_PnVuP1eV8l6ddsXosyxAPQ1mLSyWEZmTI9I,8747
 schemathesis/transport/serialization.py,sha256=jIMra1LqRGav0OX3Hx7mvORt38ll4cd2DKit2D58FN0,10531
 schemathesis/transport/wsgi.py,sha256=RWSuUXPrl91GxAy8a4jyNNozOWVMRBxKx_tljlWA_Lo,5697
-schemathesis-4.0.0a7.dist-info/METADATA,sha256=l_31cA1530vqN9M094EGpnFezX2Sk-YyJDq8_pSWcro,10427
-schemathesis-4.0.0a7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.0.0a7.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.0.0a7.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.0.0a7.dist-info/RECORD,,
+schemathesis-4.0.0a9.dist-info/METADATA,sha256=xL00zLDR06C2Jth4cyLvr-lrNBb5mDkognESM0xvJfI,10427
+schemathesis-4.0.0a9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.0.0a9.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.0.0a9.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.0.0a9.dist-info/RECORD,,