schemathesis 4.0.0a10__py3-none-any.whl → 4.0.0a11__py3-none-any.whl

schemathesis/specs/openapi/schemas.py

@@ -43,7 +43,7 @@ from schemathesis.generation.overrides import Override, OverrideMark, check_no_o
 from schemathesis.openapi.checks import JsonSchemaError, MissingContentType
 from schemathesis.specs.openapi.stateful import links
 
-from ...generation import GenerationConfig, GenerationMode
+from ...generation import GenerationMode
 from ...hooks import HookContext, HookDispatcher
 from ...schemas import APIOperation, APIOperationMap, ApiStatistic, BaseSchema, OperationDefinition
 from . import serialization
@@ -292,9 +292,7 @@ class BaseOpenAPISchema(BaseSchema):
         parameters = operation.get("parameters", ())
         return self.collect_parameters(itertools.chain(parameters, shared_parameters), operation)
 
-    def get_all_operations(
-        self, generation_config: GenerationConfig | None = None
-    ) -> Generator[Result[APIOperation, InvalidSchema], None, None]:
+    def get_all_operations(self) -> Generator[Result[APIOperation, InvalidSchema], None, None]:
         """Iterate over all operations defined in the API.
 
         Each yielded item is either `Ok` or `Err`, depending on the presence of errors during schema processing.
@@ -352,9 +350,6 @@ class BaseOpenAPISchema(BaseSchema):
                                 entry,
                                 resolved,
                                 scope,
-                                with_security_parameters=generation_config.with_security_parameters
-                                if generation_config
-                                else None,
                             )
                             yield Ok(operation)
                         except SCHEMA_PARSING_ERRORS as exc:
@@ -381,7 +376,9 @@ class BaseOpenAPISchema(BaseSchema):
         try:
             self.validate()
         except jsonschema.ValidationError as exc:
-            raise InvalidSchema.from_jsonschema_error(exc, path=path, method=method) from None
+            raise InvalidSchema.from_jsonschema_error(
+                exc, path=path, method=method, config=self.config.output
+            ) from None
         raise InvalidSchema(SCHEMA_ERROR_MESSAGE, path=path, method=method) from error
 
     def validate(self) -> None:
@@ -417,7 +414,6 @@ class BaseOpenAPISchema(BaseSchema):
         raw: dict[str, Any],
         resolved: dict[str, Any],
         scope: str,
-        with_security_parameters: bool | None = None,
     ) -> APIOperation:
         """Create JSON schemas for the query, body, etc from Swagger parameters definitions."""
         __tracebackhide__ = True
@@ -432,12 +428,8 @@ class BaseOpenAPISchema(BaseSchema):
         )
         for parameter in parameters:
             operation.add_parameter(parameter)
-        with_security_parameters = (
-            with_security_parameters
-            if with_security_parameters is not None
-            else self.generation_config.with_security_parameters
-        )
-        if with_security_parameters:
+        config = self.config.generation_for(operation=operation)
+        if config.with_security_parameters:
             self.security.process_definitions(self.raw_schema, operation, self.resolver)
         self.dispatch_hook("before_init_operation", HookContext(operation=operation), operation)
         return operation
@@ -545,21 +537,20 @@ class BaseOpenAPISchema(BaseSchema):
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
         generation_mode: GenerationMode = GenerationMode.default(),
-        generation_config: GenerationConfig | None = None,
         **kwargs: Any,
     ) -> SearchStrategy:
         return openapi_cases(
             operation=operation,
-            auth_storage=auth_storage,
             hooks=hooks,
+            auth_storage=auth_storage,
             generation_mode=generation_mode,
-            generation_config=generation_config or self.generation_config,
             **kwargs,
         )
 
     def get_parameter_serializer(self, operation: APIOperation, location: str) -> Callable | None:
         definitions = [item.definition for item in operation.iter_parameters() if item.location == location]
-        if self.generation_config.with_security_parameters:
+        config = self.config.generation_for(operation=operation)
+        if config.with_security_parameters:
             security_parameters = self.security.get_security_definitions_as_parameters(
                 self.raw_schema, operation, self.resolver, location
             )
@@ -713,7 +704,7 @@ class BaseOpenAPISchema(BaseSchema):
                     JsonSchemaError.from_exception(
                         operation=operation.label,
                         exc=exc,
-                        output_config=operation.schema.output_config,
+                        config=operation.schema.config.output,
                     )
                 )
         _maybe_raise_one_or_more(failures)

schemathesis/specs/openapi/stateful/__init__.py

@@ -162,22 +162,25 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
                         f"{link.source.label} -> {link.status_code} -> {link.name} -> {target.label}"
                     )
                     assert name not in rules, name
+                    config = schema.config.generation_for(operation=target, phase="stateful")
                     rules[name] = precondition(is_transition_allowed(bundle_name, link.source.label, target.label))(
                         transition(
                             name=name,
                             target=catch_all,
                             input=bundles[bundle_name].flatmap(
-                                into_step_input(target=target, link=link, modes=schema.generation_config.modes)
+                                into_step_input(target=target, link=link, modes=config.modes)
                             ),
                         )
                     )
             if target.label in roots.reliable or (not roots.reliable and target.label in roots.fallback):
                 name = _normalize_name(f"RANDOM -> {target.label}")
-                if len(schema.generation_config.modes) == 1:
-                    case_strategy = target.as_strategy(generation_mode=schema.generation_config.modes[0])
+                config = schema.config.generation_for(operation=target, phase="stateful")
+                if len(config.modes) == 1:
+                    case_strategy = target.as_strategy(generation_mode=config.modes[0], __is_stateful_phase=True)
                 else:
                     _strategies = {
-                        method: target.as_strategy(generation_mode=method) for method in schema.generation_config.modes
+                        method: target.as_strategy(generation_mode=method, __is_stateful_phase=True)
+                        for method in config.modes
                     }
 
                     @st.composite  # type: ignore[misc]
@@ -262,7 +265,9 @@ def into_step_input(
                 and not link.merge_body
             ):
                 kwargs["body"] = transition.request_body.value.ok()
-            cases = strategies.combine([target.as_strategy(generation_mode=mode, **kwargs) for mode in modes])
+            cases = strategies.combine(
+                [target.as_strategy(generation_mode=mode, __is_stateful_phase=True, **kwargs) for mode in modes]
+            )
             case = draw(cases)
             if (
                 transition.request_body is not None

schemathesis/transport/prepare.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, Mapping, cast
 from urllib.parse import quote, unquote, urljoin, urlsplit, urlunsplit
 
+from schemathesis.config import SanitizationConfig
 from schemathesis.core import SCHEMATHESIS_TEST_CASE_HEADER, NotSet
 from schemathesis.core.errors import InvalidSchema
 from schemathesis.core.output.sanitization import sanitize_url, sanitize_value
@@ -81,19 +82,19 @@ def prepare_path(path: str, parameters: dict[str, Any] | None) -> str:
         raise InvalidSchema(f"Malformed path template: `{path}`\n\n  {exc}") from exc
 
 
-def prepare_request(case: Case, headers: Mapping[str, Any] | None, sanitize: bool) -> PreparedRequest:
+def prepare_request(case: Case, headers: Mapping[str, Any] | None, *, config: SanitizationConfig) -> PreparedRequest:
     import requests
 
     from schemathesis.transport.requests import REQUESTS_TRANSPORT
 
     base_url = normalize_base_url(case.operation.base_url)
     kwargs = REQUESTS_TRANSPORT.serialize_case(case, base_url=base_url, headers=headers)
-    if sanitize:
-        kwargs["url"] = sanitize_url(kwargs["url"])
-        sanitize_value(kwargs["headers"])
+    if config.enabled:
+        kwargs["url"] = sanitize_url(kwargs["url"], config=config)
+        sanitize_value(kwargs["headers"], config=config)
         if kwargs["cookies"]:
-            sanitize_value(kwargs["cookies"])
+            sanitize_value(kwargs["cookies"], config=config)
         if kwargs["params"]:
-            sanitize_value(kwargs["params"])
+            sanitize_value(kwargs["params"], config=config)
 
     return requests.Request(**kwargs).prepare()

schemathesis/transport/requests.py

@@ -99,7 +99,9 @@ class RequestsTransport(BaseTransport["Case", Response, "requests.Session"]):
         verify = data.get("verify", True)
 
         try:
-            with ratelimit(case.operation.schema.rate_limiter, case.operation.schema.base_url):
+            config = case.operation.schema.config
+            rate_limit = config.rate_limit_for(operation=case.operation)
+            with ratelimit(rate_limit, config.base_url):
                 response = session.request(**data)  # type: ignore
             return Response.from_requests(response, verify=verify)
         finally:

schemathesis/transport/wsgi.py

@@ -75,10 +75,9 @@ class WSGITransport(BaseTransport["Case", Response, "werkzeug.Client"]):
         client = session or wsgi.get_client(application)
         cookies = {**(case.cookies or {}), **(cookies or {})}
 
-        with (
-            cookie_handler(client, cookies),
-            ratelimit(case.operation.schema.rate_limiter, case.operation.schema.base_url),
-        ):
+        config = case.operation.schema.config
+        rate_limit = config.rate_limit_for(operation=case.operation)
+        with cookie_handler(client, cookies), ratelimit(rate_limit, config.base_url):
             start = time.monotonic()
             response = client.open(**data)
             elapsed = time.monotonic() - start

{schemathesis-4.0.0a10.dist-info → schemathesis-4.0.0a11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.0.0a10
+Version: 4.0.0a11
 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
@@ -29,7 +29,7 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.9
 Requires-Dist: backoff<3.0,>=2.1.2
-Requires-Dist: click<9.0,>=8.0
+Requires-Dist: click<9,>=8.0
 Requires-Dist: colorama<1.0,>=0.4
 Requires-Dist: harfile<1.0,>=0.3.0
 Requires-Dist: httpx<1.0,>=0.22.0
@@ -45,6 +45,7 @@ Requires-Dist: pyyaml<7.0,>=5.1
 Requires-Dist: requests<3,>=2.22
 Requires-Dist: rich>=13.9.4
 Requires-Dist: starlette-testclient<1,>=0.4.1
+Requires-Dist: tomli>=2.2.1
 Requires-Dist: typing-extensions>=4.12.2
 Requires-Dist: werkzeug<4,>=0.16.0
 Provides-Extra: bench
@@ -60,6 +61,7 @@ Requires-Dist: coverage[toml]>=5.3; extra == 'dev'
 Requires-Dist: fastapi>=0.86.0; extra == 'dev'
 Requires-Dist: flask<3.0,>=2.1.1; extra == 'dev'
 Requires-Dist: hypothesis-openapi<1,>=0.2; (python_version >= '3.10') and extra == 'dev'
+Requires-Dist: mkdocs-material; extra == 'dev'
 Requires-Dist: pydantic>=1.10.2; extra == 'dev'
 Requires-Dist: pytest-asyncio<1.0,>=0.18.0; extra == 'dev'
 Requires-Dist: pytest-codspeed==2.2.1; extra == 'dev'
@@ -67,16 +69,12 @@ Requires-Dist: pytest-httpserver<2.0,>=1.0; extra == 'dev'
 Requires-Dist: pytest-mock<4.0,>=3.7.0; extra == 'dev'
 Requires-Dist: pytest-trio<1.0,>=0.8; extra == 'dev'
 Requires-Dist: pytest-xdist<4.0,>=3; extra == 'dev'
-Requires-Dist: sphinx; extra == 'dev'
-Requires-Dist: sphinx-click; extra == 'dev'
-Requires-Dist: sphinx-rtd-theme; extra == 'dev'
 Requires-Dist: strawberry-graphql[fastapi]>=0.109.0; extra == 'dev'
 Requires-Dist: syrupy<5.0,>=2; extra == 'dev'
+Requires-Dist: tomli-w>=1.2.0; extra == 'dev'
 Requires-Dist: trustme<1.0,>=0.9.0; extra == 'dev'
 Provides-Extra: docs
-Requires-Dist: sphinx; extra == 'docs'
-Requires-Dist: sphinx-click; extra == 'docs'
-Requires-Dist: sphinx-rtd-theme; extra == 'docs'
+Requires-Dist: mkdocs-material; extra == 'docs'
 Provides-Extra: tests
 Requires-Dist: aiohttp<4.0,>=3.9.1; extra == 'tests'
 Requires-Dist: coverage>=6; extra == 'tests'
@@ -91,6 +89,7 @@ Requires-Dist: pytest-trio<1.0,>=0.8; extra == 'tests'
 Requires-Dist: pytest-xdist<4.0,>=3; extra == 'tests'
 Requires-Dist: strawberry-graphql[fastapi]>=0.109.0; extra == 'tests'
 Requires-Dist: syrupy<5.0,>=2; extra == 'tests'
+Requires-Dist: tomli-w>=1.2.0; extra == 'tests'
 Requires-Dist: trustme<1.0,>=0.9.0; extra == 'tests'
 Description-Content-Type: text/markdown
 

schemathesis-4.0.0a11.dist-info/RECORD

@@ -0,0 +1,166 @@
+schemathesis/__init__.py,sha256=IznSJx_si-x3bBolTLGcq_NakcVoeMCtE11ctKuz9uE,1119
+schemathesis/auths.py,sha256=t-YuPyoLqL7jlRUH-45JxO7Ir3pYxpe31CRmNIJh7rI,15423
+schemathesis/checks.py,sha256=bNrebGDOryn2SmXcgMUVWhItCmGgiGSq54JMNvGiZjE,5421
+schemathesis/errors.py,sha256=T8nobEi5tQX_SkwaYb8JFoIlF9F_vOQVprZ8EVPAhjA,931
+schemathesis/filters.py,sha256=OEub50Ob5sf0Tn3iTeuIaxSMtepF7KVoiEM9wtt5GGA,13433
+schemathesis/hooks.py,sha256=ZSGEnsLJ7UVezf4CcaJebVkjEpvwgJolJFZo5fjQNDc,13153
+schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schemathesis/schemas.py,sha256=KyYuL04FAPEkc6mN53NioDEUgn7rmTDkvv5Q2_PGgoY,25824
+schemathesis/cli/__init__.py,sha256=U9gjzWWpiFhaqevPjZbwyTNjABdpvXETI4HgwdGKnvs,877
+schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
+schemathesis/cli/constants.py,sha256=rUixnqorraUFDtOu3Nmm1x_k0qbgmW9xW96kQB_fBCQ,338
+schemathesis/cli/core.py,sha256=ue7YUdVo3YvuzGL4s6i62NL6YqNDeVPBSnQ1znrvG2w,480
+schemathesis/cli/commands/__init__.py,sha256=rubTCCRGuMIbNYOl8yQEioiuHtTq__tWjkUtFWYGhqQ,3433
+schemathesis/cli/commands/data.py,sha256=_ALywjIeCZjuaoDQFy-Kj8RZkEGqXd-Y95O47h8Jszs,171
+schemathesis/cli/commands/run/__init__.py,sha256=wOrs_7aj-6nYBuuVnMTJ24u2s7C9_hsMwYYes0l5A-k,18818
+schemathesis/cli/commands/run/context.py,sha256=15jijsCgwFZYLfWbeQZJ9lWD0b3Jp3NfWTURzh6Uyuc,7663
+schemathesis/cli/commands/run/events.py,sha256=CuS5iZ5IoYl7d9ytvNmW73WEjjQ3SriEm1O9as8O2wU,1348
+schemathesis/cli/commands/run/executor.py,sha256=x4vfwP3B5OUhx9fiZMH3shjDmTkXZUcRAm3by613_lY,5132
+schemathesis/cli/commands/run/filters.py,sha256=pzkNRcf5vLPSsMfnvt711GNzRSBK5iZIFjPA0fiH1N4,1701
+schemathesis/cli/commands/run/loaders.py,sha256=6j0ez7wduAUYbUT28ELKxMf-dYEWr_67m_KIuTSyNGk,4358
+schemathesis/cli/commands/run/validation.py,sha256=xiDFkR_9lwRVLJXL-0paVMK1Q2JNu1qreDjwf1hoiGA,8502
+schemathesis/cli/commands/run/handlers/__init__.py,sha256=TPZ3KdGi8m0fjlN0GjA31MAXXn1qI7uU4FtiDwroXZI,1915
+schemathesis/cli/commands/run/handlers/base.py,sha256=yDsTtCiztLksfk7cRzg8JlaAVOfS-zwK3tsJMOXAFyc,530
+schemathesis/cli/commands/run/handlers/cassettes.py,sha256=Gu0qcxzvHp1zMY-SVkY96T-Ifwtdh6oj-w0gE1MShnA,19157
+schemathesis/cli/commands/run/handlers/junitxml.py,sha256=FX_347PcHhGLG7XY3eG8VwhB_8tSX4mOtqjZj_s6yLM,2402
+schemathesis/cli/commands/run/handlers/output.py,sha256=i0UGeKKVY4o1eiMzFtg3azXvCOOSj1FS4ZdScW4Nm5Y,58198
+schemathesis/cli/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schemathesis/cli/ext/fs.py,sha256=3lvoAsEDDdih75ITJJNxemd3nwxX55gGWrI7uDxm0cM,447
+schemathesis/cli/ext/groups.py,sha256=kQ37t6qeArcKaY2y5VxyK3_KwAkBKCVm58IYV8gewds,2720
+schemathesis/cli/ext/options.py,sha256=6yYwZNJL__FCEEL7kI3r5MbVmbp3ZeQjm7DrZ6J_h7s,3347
+schemathesis/config/__init__.py,sha256=A7KvfcX_o2sWBXiO798vDUYVDSEQisI9-L84mLyYFZM,6192
+schemathesis/config/_auth.py,sha256=83RLVPm97W2thbn-yi01Rt94YwOxLG_a5VoxhEfjUjs,1528
+schemathesis/config/_checks.py,sha256=F0r16eSSiICvoiTUkNNOE2PH73EGd8bikoeZdME_3Yw,10763
+schemathesis/config/_diff_base.py,sha256=-XqS6cTzZC5fplz8_2RSZHDMSAPJhBBIEP6H8wcgHmo,4221
+schemathesis/config/_env.py,sha256=8XfIyrnGNQuCDnfG0lwmKRFbasRUjgeQGBAMupsmtOU,613
+schemathesis/config/_error.py,sha256=TxuuqQ1olwJc7P7ssfxXb1dB_Xn5uVsoazjvYvRxrxA,5437
+schemathesis/config/_generation.py,sha256=gHLv3wiMuGKg47gwtq6Y6xLCJBE-pceIAlu6Jg4Kmlk,5136
+schemathesis/config/_health_check.py,sha256=zC9inla5ibMBlEy5WyM4_TME7ju_KH3Bwfo21RI3Gks,561
+schemathesis/config/_operations.py,sha256=l1jQHQY18OGefFtvePNPmYhr7hLT0Re0fAUMY5VO2G4,11584
+schemathesis/config/_output.py,sha256=3G9SOi-4oNcQPHeNRG3HggFCwvcKOW1kF28a9m0H-pU,4434
+schemathesis/config/_parameters.py,sha256=i76Hwaf834fBAMmtKfKTl1SFCicJ-Y-5tZt5QNGW2fA,618
+schemathesis/config/_phases.py,sha256=C-OLJNwkVIdp9w4Uw6qNTV2inQZdaT6UGkS7anHxUdg,5090
+schemathesis/config/_projects.py,sha256=U78ZixEIlWIFBXGHgMXrkKRNeol2PkOrHrSFRDvTIlk,18147
+schemathesis/config/_rate_limit.py,sha256=ekEW-jP_Ichk_O6hYpj-h2TTTKfp7Fm0nyFUbvlWcbA,456
+schemathesis/config/_report.py,sha256=FAmmOndCuXju2Eat5DX1lBMobIHWLNSGyJBb7Q32bLk,3739
+schemathesis/config/_validator.py,sha256=IcE8geFZ0ZwR18rkIRs25i7pTl7Z84XbjYGUB-mqReU,258
+schemathesis/config/schema.json,sha256=dJSUxWvrME5JoknxBgkOBtWKZgkgYy-I9RCWIDQRkFE,17843
+schemathesis/contrib/__init__.py,sha256=wxpX86xrEGRAS3f7eugQfKVbnqV6ZfOqFBS_DmWxOok,120
+schemathesis/contrib/openapi/__init__.py,sha256=-7mBZ9RQj0EGzzmC-HKiT5ZslwHcoWFqCVpRG0GHO_o,162
+schemathesis/contrib/openapi/fill_missing_examples.py,sha256=BfBpuy3vCKbE_uILqPXnm7kxEDopAr5tNQwP5E9xX8A,585
+schemathesis/core/__init__.py,sha256=5fAAKG6BAA5DP9qOUnMT1cG5LLN3tU7D7VdLyb-MxfM,1880
+schemathesis/core/compat.py,sha256=9BWCrFoqN2sJIaiht_anxe8kLjYMR7t0iiOkXqLRUZ8,1058
+schemathesis/core/control.py,sha256=IzwIc8HIAEMtZWW0Q0iXI7T1niBpjvcLlbuwOSmy5O8,130
+schemathesis/core/curl.py,sha256=yuaCe_zHLGwUjEeloQi6W3tOA3cGdnHDNI17-5jia0o,1723
+schemathesis/core/deserialization.py,sha256=ygIj4fNaOd0mJ2IvTsn6bsabBt_2AbSLCz-z9UqfpdQ,2406
+schemathesis/core/errors.py,sha256=HbQJyxJbW0-GfhYvm-6nK20f4hiqsdDGEOy--agdvHE,16319
+schemathesis/core/failures.py,sha256=MYyRnom-XeUEuBmq2ffdz34xhxmpSHWaQunfHtliVsY,8932
+schemathesis/core/fs.py,sha256=ItQT0_cVwjDdJX9IiI7EnU75NI2H3_DCEyyUjzg_BgI,472
+schemathesis/core/hooks.py,sha256=qhbkkRSf8URJ4LKv2wmKRINKpquUOgxQzWBHKWRWo3Q,475
+schemathesis/core/lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
+schemathesis/core/loaders.py,sha256=SQQ-8m64-D2FaOgvwKZLyTtLJuzP3RPo7Ud2BERK1c0,3404
+schemathesis/core/marks.py,sha256=SH7jsVuNRJjx2gZN9Ze5MY01u7FJiHeO0iruzKi5rm4,2135
+schemathesis/core/media_types.py,sha256=vV0CEu34sDoZWXvu4R1Y1HosxVS4YXZV8iTov8fU3X0,2148
+schemathesis/core/rate_limit.py,sha256=7tg9Znk11erTfw8-ANutjEmu7hbfUHZx_iEdkoaP174,1757
+schemathesis/core/registries.py,sha256=T4jZB4y3zBHdeSgQc0pRbgSeMblvO-6z4I3zmzIfTi0,811
+schemathesis/core/result.py,sha256=d449YvyONjqjDs-A5DAPgtAI96iT753K8sU6_1HLo2Q,461
+schemathesis/core/transforms.py,sha256=63aeLkR93r3krq4CwYtDcoS_pFBky4L16c9DcFsBHuE,3535
+schemathesis/core/transport.py,sha256=VqtVF4JxMuPXSBORzS8SOSLUnCEZL6gPOr0kuymMCAk,3249
+schemathesis/core/validation.py,sha256=rnhzsqWukMWyrc7sRm0kZNHTePoPCQ3A4kLpLxrb0jM,1641
+schemathesis/core/version.py,sha256=O-6yFbNocbD4RDwiBZLborxTp54htyKxBWTqpZDnPvg,202
+schemathesis/core/output/__init__.py,sha256=SiHqONFskXl73AtP5dV29L14nZoKo7B-IeG52KZB32M,1446
+schemathesis/core/output/sanitization.py,sha256=Ev3tae8dVwsYd7yVb2_1VBFYs92WFsQ4Eu1fGaymItE,2013
+schemathesis/engine/__init__.py,sha256=QaFE-FinaTAaarteADo2RRMJ-Sz6hZB9TzD5KjMinIA,706
+schemathesis/engine/context.py,sha256=1m6KiD2M9_fVRiUnYxFw2csUQeZV0N4FepR7w_DZCHA,3902
+schemathesis/engine/control.py,sha256=QKUOs5VMphe7EcAIro_DDo9ZqdOU6ZVwTU1gMNndHWw,1006
+schemathesis/engine/core.py,sha256=Pnpf1zNTxruUOnnJ9rQ-MskXj4WuA4A27_fWrf0hXWc,5609
+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=zzILnWjoDJQwNmvEmrj3HXVAKT2q7Vb614svjyt8E-U,2794
+schemathesis/engine/phases/probes.py,sha256=MgjH3yLw0siiSnaESzDVww70Uz4dAyJ2W22H1Ome03Q,4964
+schemathesis/engine/phases/stateful/__init__.py,sha256=lWo2RLrutNblHvohTzofQqL22GORwBRA8bf6jvLuGPg,2391
+schemathesis/engine/phases/stateful/_executor.py,sha256=3_UV5r2O_nx4UCAF-m0xo_pdrvPwdZ_g_qQDr7JhTXE,13624
+schemathesis/engine/phases/stateful/context.py,sha256=SKWsok-tlWbUDagiUmP7cLNW6DsgFDc_Afv0vQfWv6c,2964
+schemathesis/engine/phases/unit/__init__.py,sha256=BvZh39LZmXg90Cy_Tn0cQY5y7eWzYvAEmJ43fGKFAt8,8715
+schemathesis/engine/phases/unit/_executor.py,sha256=GE_uFbaaF7SuwL3K7HjSoDf5P3PFc7B1inhMhB3QRcE,14939
+schemathesis/engine/phases/unit/_pool.py,sha256=iU0hdHDmohPnEv7_S1emcabuzbTf-Cznqwn0pGQ5wNQ,2480
+schemathesis/generation/__init__.py,sha256=QA2BiS4nk9VmcBn8_Ad6vaIbj6B9ToigLHLVn-DjCwM,700
+schemathesis/generation/case.py,sha256=dca80qoI4JZot84I7eqpxE_yWbNQ-iwKG6pXTIhxKP0,7486
+schemathesis/generation/coverage.py,sha256=ISXKXTdfYLpdo6bOIW3--AiwWVWnwfOwKb1KQZ7AEM8,47913
+schemathesis/generation/meta.py,sha256=5ikrlhdk424dWcYLekZSMoWJYRl9_IhI80GKZzhByi4,2512
+schemathesis/generation/modes.py,sha256=t_EvKr2aOXYMsEfdMu4lLF4KCGcX1LVVyvzTkcpJqhk,663
+schemathesis/generation/overrides.py,sha256=iPxnxPIKKhO9mwPwKszYv40VM4ylxFJvhzWvrC6qkOE,4385
+schemathesis/generation/targets.py,sha256=_rN2qgxTE2EfvygiN-Fy3WmDnRH0ERohdx3sKRDaYhU,2120
+schemathesis/generation/hypothesis/__init__.py,sha256=SVwM-rx07jPZzms0idWYACgUtWAxh49HRuTnaQ__zf0,1549
+schemathesis/generation/hypothesis/builder.py,sha256=PYJaBbXMAPpM_9WkUmStQKoxQ67tWyJYybt6y4Izjg0,31487
+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
+schemathesis/generation/hypothesis/strategies.py,sha256=RurE81E06d99YKG48dizy9346ayfNswYTt38zewmGgw,483
+schemathesis/generation/stateful/__init__.py,sha256=kXpCGbo1-QqfR2N0Z07tLw0Z5_tvbuG3Tk-WI_I1doI,653
+schemathesis/generation/stateful/state_machine.py,sha256=h79_G8oUOU8TVJFFF6EKbrW8KPuz6E8gc7us0TC2lrA,12656
+schemathesis/graphql/__init__.py,sha256=_eO6MAPHGgiADVGRntnwtPxmuvk666sAh-FAU4cG9-0,326
+schemathesis/graphql/checks.py,sha256=IADbxiZjgkBWrC5yzHDtohRABX6zKXk5w_zpWNwdzYo,3186
+schemathesis/graphql/loaders.py,sha256=bBXWLbwyF31nQILSVldysP1IEMrYle-j71n8nx1TZAE,5301
+schemathesis/openapi/__init__.py,sha256=-KcsSAM19uOM0N5J4s-yTnQ1BFsptYhW1E51cEf6kVM,311
+schemathesis/openapi/checks.py,sha256=5AP_pjTIJ7GcHNhTtGz-IOeoutZ4HqkxyoANrRKf23M,10825
+schemathesis/openapi/loaders.py,sha256=18vdQZGUtwvHUrHZYRmKDoLzuNA5kBx3YdSTKEfuSzQ,7062
+schemathesis/openapi/generation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schemathesis/openapi/generation/filters.py,sha256=EBbgW9zH3wA4d9FyBWp4koiPrrIpNGFnousBDl9qJso,2079
+schemathesis/pytest/__init__.py,sha256=7W0q-Thcw03IAQfXE_Mo8JPZpUdHJzfu85fjK1ZdfQM,88
+schemathesis/pytest/control_flow.py,sha256=F8rAPsPeNv_sJiJgbZYtTpwKWjauZmqFUaKroY2GmQI,217
+schemathesis/pytest/lazy.py,sha256=Wbyn3fYqcmDL7uOFO0PgVpR7--MP8g3Z8q1yArjmDEo,11824
+schemathesis/pytest/loaders.py,sha256=oQJ78yyuIm3Ye9X7giVjDB1vYfaW5UY5YuhaTLm_ZFU,266
+schemathesis/pytest/plugin.py,sha256=j8L3JV1ijf9dYpoLTDNJpdFnS2fbsYM3Gzv-3r2nk60,12454
+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
+schemathesis/specs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schemathesis/specs/graphql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schemathesis/specs/graphql/_cache.py,sha256=QIcEFy2Koy5K0-u1nB-iab52LDlYsTm_9N5t42GplkM,770
+schemathesis/specs/graphql/nodes.py,sha256=bE3G1kNmqJ8OV4igBvIK-UORrkQA6Nofduf87O3TD9I,541
+schemathesis/specs/graphql/scalars.py,sha256=ERUECtwWuEe4_T_fpM6DQJKLrkvahbnaswM7oEOcC0M,1850
+schemathesis/specs/graphql/schemas.py,sha256=EjvXLjti2w11AJF5Hi0m-AXVgtMXw4Z1BoCW1OQfQfU,14168
+schemathesis/specs/graphql/validation.py,sha256=-W1Noc1MQmTb4RX-gNXMeU2qkgso4mzVfHxtdLkCPKM,1422
+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=gLQjVkYkR8Z_dw3HzHeAKDm08qdTZphPHlM0Jzu0xe4,21576
+schemathesis/specs/openapi/checks.py,sha256=oEnogK5H8c_GEJrYe-2_crhDKiOijYFdspVUjtOW1So,27469
+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=9dMY4d2WWz32JywKZzyLO5jdbMWcRqjjGHzhMqlqwIs,21129
+schemathesis/specs/openapi/formats.py,sha256=CbuFP_pegtIQfG0AH2gTl0KCCAI6y1a_z6hGvjeIa5A,2810
+schemathesis/specs/openapi/media_types.py,sha256=ADedOaNWjbAtAekyaKmNj9fY6zBTeqcNqBEjN0EWNhI,1014
+schemathesis/specs/openapi/parameters.py,sha256=tVL61gDe9A8_jwoVKZZvpXKPerMyq7vkAvwdMsi44TI,14622
+schemathesis/specs/openapi/patterns.py,sha256=cBj8W4wn7VLJd4nABaIH5f502-zBDiqljxLgPWUn-50,15609
+schemathesis/specs/openapi/references.py,sha256=40YcDExPLR2B8EOwt-Csw-5MYFi2xj_DXf91J0Pc9d4,8855
+schemathesis/specs/openapi/schemas.py,sha256=bTa7LEod5Oaqc42TD4JwUDCDLDwB4PYtkU60hsY9IQE,54672
+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=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=eKiBWsMYjcJ0mNmh07IOnbVMHZ8k-fCidcohwBz8yJ4,3741
+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=AZoc9lTb0P6zeVf8Yf4D5ZcVecz2E1osCeDpv3WS-sw,14994
+schemathesis/specs/openapi/stateful/control.py,sha256=QaXLSbwQWtai5lxvvVtQV3BLJ8n5ePqSKB00XFxp-MA,3695
+schemathesis/specs/openapi/stateful/links.py,sha256=8oHpmb-yBa3kZKoCv9ytndpOp80dG1vVis2-EpbkeVA,11432
+schemathesis/transport/__init__.py,sha256=z-mRNSOlMBKwQyaEIhpmYv0plWTmK5dJqc9UmQOry80,3949
+schemathesis/transport/asgi.py,sha256=qTClt6oT_xUEWnRHokACN_uqCNNUZrRPT6YG0PjbElY,926
+schemathesis/transport/prepare.py,sha256=wBqKgDyrIxaH1HOP7hjb5ERoSh0WkCBDu7yCaAJQlEY,3958
+schemathesis/transport/requests.py,sha256=zGpTJiDjeX-H6WOJHf13TMe9WSblGCcrVbSEekj8zMU,8831
+schemathesis/transport/serialization.py,sha256=jIMra1LqRGav0OX3Hx7mvORt38ll4cd2DKit2D58FN0,10531
+schemathesis/transport/wsgi.py,sha256=Eva8iTYGSmdqV7-1WSUXLe3Ysdr8vTijTwadM6ybPxE,5736
+schemathesis-4.0.0a11.dist-info/METADATA,sha256=fWWqGEuqISnHZCYthJw9bMx3XmndCWScfSUSMugrpJc,10380
+schemathesis-4.0.0a11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.0.0a11.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.0.0a11.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.0.0a11.dist-info/RECORD,,

schemathesis/cli/commands/run/checks.py

@@ -1,79 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Sequence
-
-from schemathesis import experimental
-from schemathesis.checks import CHECKS, CheckFunction, ChecksConfig
-
-
-@dataclass
-class CheckArguments:
-    included_check_names: Sequence[str]
-    excluded_check_names: Sequence[str]
-    positive_data_acceptance_allowed_statuses: list[str] | None
-    missing_required_header_allowed_statuses: list[str] | None
-    negative_data_rejection_allowed_statuses: list[str] | None
-    max_response_time: float | None
-
-    __slots__ = (
-        "included_check_names",
-        "excluded_check_names",
-        "positive_data_acceptance_allowed_statuses",
-        "missing_required_header_allowed_statuses",
-        "negative_data_rejection_allowed_statuses",
-        "max_response_time",
-    )
-
-    def into(self) -> tuple[list[CheckFunction], ChecksConfig]:
-        # Determine selected checks
-        if "all" in self.included_check_names:
-            selected_checks = CHECKS.get_all()
-        else:
-            selected_checks = CHECKS.get_by_names(self.included_check_names or [])
-
-        # Prepare checks configuration
-        checks_config: ChecksConfig = {}
-
-        if experimental.POSITIVE_DATA_ACCEPTANCE.is_enabled:
-            from schemathesis.openapi.checks import PositiveDataAcceptanceConfig
-            from schemathesis.specs.openapi.checks import positive_data_acceptance
-
-            selected_checks.append(positive_data_acceptance)
-            if self.positive_data_acceptance_allowed_statuses:
-                checks_config[positive_data_acceptance] = PositiveDataAcceptanceConfig(
-                    allowed_statuses=self.positive_data_acceptance_allowed_statuses
-                )
-
-        if self.missing_required_header_allowed_statuses:
-            from schemathesis.openapi.checks import MissingRequiredHeaderConfig
-            from schemathesis.specs.openapi.checks import missing_required_header
-
-            selected_checks.append(missing_required_header)
-            checks_config[missing_required_header] = MissingRequiredHeaderConfig(
-                allowed_statuses=self.missing_required_header_allowed_statuses
-            )
-
-        if self.negative_data_rejection_allowed_statuses:
-            from schemathesis.openapi.checks import NegativeDataRejectionConfig
-            from schemathesis.specs.openapi.checks import negative_data_rejection
-
-            checks_config[negative_data_rejection] = NegativeDataRejectionConfig(
-                allowed_statuses=self.negative_data_rejection_allowed_statuses
-            )
-
-        if self.max_response_time is not None:
-            from schemathesis.checks import max_response_time as _max_response_time
-            from schemathesis.core.failures import MaxResponseTimeConfig
-
-            checks_config[_max_response_time] = MaxResponseTimeConfig(self.max_response_time)
-            selected_checks.append(_max_response_time)
-
-        from schemathesis.specs.openapi.checks import unsupported_method
-
-        selected_checks.append(unsupported_method)
-
-        # Exclude checks based on their names
-        selected_checks = [check for check in selected_checks if check.__name__ not in self.excluded_check_names]
-
-        return selected_checks, checks_config

schemathesis/cli/commands/run/hypothesis.py

@@ -1,78 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum, unique
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    import hypothesis
-
-HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER = ":memory:"
-
-# Importing Hypothesis is expensive, hence we re-create the enums we need in CLI commands definitions
-# Hypothesis is stable, hence it should not be a problem and adding new variants should not be automatic
-
-
-@unique
-class HealthCheck(str, Enum):
-    # We remove not relevant checks
-    data_too_large = "data_too_large"
-    filter_too_much = "filter_too_much"
-    too_slow = "too_slow"
-    large_base_example = "large_base_example"
-    all = "all"
-
-    def as_hypothesis(self) -> list[hypothesis.HealthCheck]:
-        from hypothesis import HealthCheck
-
-        if self.name == "all":
-            return list(HealthCheck)
-
-        return [HealthCheck[self.name]]
-
-
-def prepare_health_checks(
-    hypothesis_suppress_health_check: list[HealthCheck] | None,
-) -> list[hypothesis.HealthCheck] | None:
-    if hypothesis_suppress_health_check is None:
-        return None
-
-    return [entry for health_check in hypothesis_suppress_health_check for entry in health_check.as_hypothesis()]
-
-
-def prepare_phases(no_shrink: bool = False) -> list[hypothesis.Phase] | None:
-    from hypothesis import Phase
-
-    phases = set(Phase) - {Phase.explain}
-    if no_shrink:
-        return list(phases - {Phase.shrink})
-    return list(phases)
-
-
-def prepare_settings(
-    database: str | None = None,
-    derandomize: bool | None = None,
-    max_examples: int | None = None,
-    phases: list[hypothesis.Phase] | None = None,
-    suppress_health_check: list[hypothesis.HealthCheck] | None = None,
-) -> hypothesis.settings:
-    import hypothesis
-    from hypothesis.database import DirectoryBasedExampleDatabase, InMemoryExampleDatabase
-
-    kwargs: dict[str, Any] = {
-        key: value
-        for key, value in (
-            ("derandomize", derandomize),
-            ("max_examples", max_examples),
-            ("phases", phases),
-            ("suppress_health_check", suppress_health_check),
-        )
-        if value is not None
-    }
-    if database is not None:
-        if database.lower() == "none":
-            kwargs["database"] = None
-        elif database == HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER:
-            kwargs["database"] = InMemoryExampleDatabase()
-        else:
-            kwargs["database"] = DirectoryBasedExampleDatabase(database)
-    return hypothesis.settings(print_blob=False, deadline=None, verbosity=hypothesis.Verbosity.quiet, **kwargs)