schemathesis 4.0.0a7__py3-none-any.whl → 4.0.0a8__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

@@ -150,7 +150,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:
@@ -437,6 +437,36 @@ 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:
+                    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
@@ -770,7 +800,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,9 +1,11 @@
 from __future__ import annotations
 
+import asyncio
 from dataclasses import dataclass, field
 from enum import Enum
 from functools import wraps
 from itertools import combinations
+import os
 from time import perf_counter
 from typing import Any, Callable, Generator, Mapping
 
@@ -15,7 +17,7 @@ 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 +40,7 @@ from schemathesis.schemas import APIOperation, ParameterSet
 setup()
 
 
-class HypothesisTestMode(Enum):
+class HypothesisTestMode(str, Enum):
     EXAMPLES = "examples"
     COVERAGE = "coverage"
     FUZZING = "fuzzing"
@@ -120,8 +122,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 +163,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/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
 
@@ -1202,14 +1208,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.0a8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.0.0a7
+Version: 4.0.0a8
 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.0a8.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=vv2dbj_KAaqo8PCwMdyDWLyyAssk-YL5oTU3aCkgB1s,41185
 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=cSgFWQG-apIHNdW-PpIBDBjLw4RorihfZ4e_Ln3j2-w,30341
 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/parameters.py,sha256=tVL61gDe9A8_jwoVKZZvpXKPerMyq7vkAvwdMsi44TI,14622
 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/references.py,sha256=c8Ufa8hp6Dyf-gPn5lpmyqF_GtqXIBWoKkj3bk3WaPA,8871
+schemathesis/specs/openapi/schemas.py,sha256=zfGPFWnaI9_W8F8E8qCTzuYQRE5yDuGx7WGW4EH-QgI,55020
 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.0a8.dist-info/METADATA,sha256=hdJd_ASqgZ75dZ1EW27p3mL6CAG179nTb-cm1zVtQqk,10427
+schemathesis-4.0.0a8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.0.0a8.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.0.0a8.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.0.0a8.dist-info/RECORD,,