schemathesis 3.35.4__tar.gz → 3.36.0__tar.gz

{schemathesis-3.35.4 → schemathesis-3.36.0}/.github/workflows/update-pre-commit.yml

@@ -20,7 +20,7 @@ jobs:
       - run: uvx pre-commit autoupdate
 
       - name: Open pull request
-        uses: peter-evans/create-pull-request@v6
+        uses: peter-evans/create-pull-request@v7
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           delete-branch: true

{schemathesis-3.35.4 → schemathesis-3.36.0}/.pre-commit-config.yaml

@@ -38,12 +38,12 @@ repos:
         additional_dependencies: [types-click, types-requests, types-PyYAML]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.6.3
+    rev: v0.6.5
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.6.3
+    rev: v0.6.5
     hooks:
       - id: ruff
 

{schemathesis-3.35.4 → schemathesis-3.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.35.4
+Version: 3.36.0
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://schemathesis.readthedocs.io/en/stable/changelog.html

{schemathesis-3.35.4 → schemathesis-3.36.0}/docs/auth.rst

@@ -443,6 +443,8 @@ For example, you can use refresh tokens for authentication.
             case.headers = case.headers or {}
             case.headers = {"Authorization": f"Bearer {data}"}
 
+.. _third-party-auth:
+
 Third-party implementation
 --------------------------
 

{schemathesis-3.35.4 → schemathesis-3.36.0}/docs/changelog.rst

@@ -1,9 +1,52 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.35.4...HEAD>` - TBD
+:version:`Unreleased <v3.36.0...HEAD>` - TBD
 --------------------------------------------
 
+.. _v3.36.0:
+
+:version:`3.36.0 <v3.35.5...v3.36.0>` - 2024-09-15
+--------------------------------------------------
+
+**Added**
+
+- Reimplementation of test case deduplication in CLI. It effectively un-deprecates the ``--contrib-unique-data`` CLI option.
+- Extend ``ignored_auth`` to check for incorrect auth.
+- More ``properties`` combinations for the coverage phase.
+- Use the `default` field as a source of valid inputs during the coverage phase.
+
+**Changed**
+
+- Add ``ctx`` as the first argument for all checks. 
+  This is a step towards checks that cover multiple responses at once. 
+- Validate custom check function signatures.
+
+**Deprecated**
+
+- Custom checks that do not accept ``ctx`` as the first argument.
+
+**Fixed**
+
+- Avoid running checks twice in new-style stateful tests.
+- Missing ``timeout`` in certain situations when loading the schema from the network.
+- Ignoring ``with_security_parameters`` in runner in some cases.
+
+.. _v3.35.5:
+
+:version:`3.35.5 <v3.35.4...v3.35.5>` - 2024-09-08
+--------------------------------------------------
+
+**Changed**
+
+- Extend explicit examples discovery mechanism by checking response examples.
+- Saving the generated data into a cassette when ``--dry-run`` is provided. :issue:`1423`
+- Saving timeouted requests into a cassette.
+
+**Fixed**
+
+- Support non-Starlette ASGI apps in more places.
+
 .. _v3.35.4:
 
 :version:`3.35.4 <v3.35.3...v3.35.4>` - 2024-09-05

{schemathesis-3.35.4 → schemathesis-3.36.0}/docs/cli.rst

@@ -677,11 +677,11 @@ To use your custom checks with Schemathesis CLI, you need to register them via t
 
 
     @schemathesis.check
-    def new_check(response, case):
+    def new_check(ctx, response, case):
         # some awesome assertions!
         pass
 
-The registered check should accept a ``response`` with ``requests.Response`` / ``schemathesis.utils.WSGIResponse`` type and
+The registered check should accept ``ctx``, a ``response`` with ``requests.Response`` / ``schemathesis.utils.WSGIResponse`` type and
 ``case`` with ``schemathesis.models.Case`` type. This code should be placed in the module you pass to the ``SCHEMATHESIS_HOOKS`` environment variable.
 
 Then your checks will be available in Schemathesis CLI, and you can use them via the ``-c`` command-line option.
@@ -700,7 +700,7 @@ response code is ``200``.
 
 
     @schemathesis.check
-    def conditional_check(response, case):
+    def conditional_check(ctx, response, case):
         if response.status_code == 200:
             ...  # some awesome assertions!
         else:

{schemathesis-3.35.4 → schemathesis-3.36.0}/docs/contrib.rst

@@ -6,13 +6,6 @@ Schemathesis ships a set of optional features that could help to tune your tests
 Unique data generation
 ~~~~~~~~~~~~~~~~~~~~~~
 
-.. important::
-
-    The ``--contrib-unique-data`` CLI option and the corresponding ``schemathesis.contrib.unique_data`` hook are **DEPRECATED**. The concept of this feature
-    does not fit the core principles of Hypothesis where strategies are configurable on a per-example basis but this feature implies
-    uniqueness across examples. This leads to cryptic error messages about external state and flaky test runs, therefore it will be removed in
-    Schemathesis 4.0
-
 By default, Schemathesis may generate the same test cases as all data is randomized. If this behavior does not match your expectations, or
 your test budges, you can force Schemathesis to generate unique test cases.
 
@@ -22,6 +15,13 @@ In CLI:
 
     $ st run --contrib-unique-data https://example.schemathesis.io/openapi.json
 
+.. important::
+
+    The ``schemathesis.contrib.unique_data`` hook is **DEPRECATED**. The concept of this feature
+    does not fit the core principles of Hypothesis where strategies are configurable on a per-example basis but this feature implies
+    uniqueness across examples. This leads to cryptic error messages about external state and flaky test runs, therefore it will be removed in
+    Schemathesis 4.0
+
 In Python tests:
 
 .. code:: python

{schemathesis-3.35.4 → schemathesis-3.36.0}/docs/extending.rst

@@ -667,7 +667,7 @@ Checks
 Checks in Schemathesis allow you to validate responses from your API, ensuring they adhere to both general and application-specific expectations. 
 They can be particularly useful for checking behaviors that are specific to your application and go beyond the built-in checks provided by Schemathesis.
 
-Define a check as a function taking two parameters: ``response`` and ``case``, and register it using the ``@schemathesis.check`` decorator.
+Define a check as a function taking three parameters: ``ctx``, ``response`` and ``case``, and register it using the ``@schemathesis.check`` decorator.
 
 .. code-block:: python
 
@@ -675,9 +675,10 @@ Define a check as a function taking two parameters: ``response`` and ``case``, a
 
 
     @schemathesis.check
-    def my_check(response, case) -> None:
+    def my_check(ctx, response, case) -> None:
         ...
 
+- ``ctx`` holds a context relevant to the current check. Currently unused and is placed here for future-compatibility.
 - ``response`` is the API response, an instance of ``requests.Response`` or ``schemathesis.utils.WSGIResponse``, based on your integration method.
 - ``case`` is the ``schemathesis.Case`` instance used to send data to the application.
 
@@ -691,7 +692,7 @@ Here’s an example of a check that ensures that when an ``item_id`` of 42 is us
 
 
     @schemathesis.check
-    def my_check(response, case) -> None:
+    def my_check(ctx, response, case) -> None:
         if case.path_parameters.get("item_id") == 42 and ANSWER not in response.text:
             raise AssertionError("The ultimate answer not found!")
 

{schemathesis-3.35.4 → schemathesis-3.36.0}/docs/faq.rst

@@ -322,6 +322,14 @@ Python:
 
 This adjustment ensures that Schemathesis does not include NULL bytes in strings for all your tests, making them compatible with systems that reject such inputs.
 
+How can I use custom authentication methods with Schemathesis?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Schemathesis supports custom authentication through its extensions system.
+
+For detailed instructions on implementing custom authentication methods or using existing libraries for that, 
+refer to our :ref:`Custom Authentication <custom-auth>` and :ref:`Third-party Authentication <third-party-auth>` sections.
+
 Working with API schemas
 ------------------------
 

{schemathesis-3.35.4 → schemathesis-3.36.0}/example/tests/extensions.py

@@ -17,18 +17,18 @@ schemathesis.openapi.format("fullname", fullname())
 
 
 @schemathesis.hook
-def filter_body(context, body):
+def filter_body(ctx, body):
     """Modification over the default strategy for payload generation."""
     return body.get("id", 10001) > 10000
 
 
 @schemathesis.check
-def not_so_slow(response, case):
+def not_so_slow(ctx, response, case):
     """Custom response check."""
     assert response.elapsed < timedelta(milliseconds=100), "Response is slow!"
 
 
 @schemathesis.target
-def big_response(context):
+def big_response(ctx):
     """Custom data generation target."""
-    return float(len(context.response.content))
+    return float(len(ctx.response.content))

{schemathesis-3.35.4 → schemathesis-3.36.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.35.4"
+version = "3.36.0"
 description = "Property-based testing framework for Open API and GraphQL based apps"
 keywords = ["pytest", "hypothesis", "openapi", "graphql", "testing"]
 authors = [{ name = "Dmitry Dygalo", email = "dmitry@dygalo.dev" }]

{schemathesis-3.35.4 → schemathesis-3.36.0}/src/schemathesis/__init__.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 from typing import Any
 
-from . import auths, checks, contrib, experimental, fixups, graphql, hooks, runner, serializers, targets  # noqa: E402
+from . import auths, checks, contrib, experimental, fixups, graphql, hooks, runner, serializers, targets
 from ._lazy_import import lazy_import
-from .constants import SCHEMATHESIS_VERSION  # noqa: E402
-from .generation import DataGenerationMethod, GenerationConfig, HeaderConfig  # noqa: E402
-from .models import Case  # noqa: E402
-from .specs import openapi  # noqa: E402
+from .constants import SCHEMATHESIS_VERSION
+from .generation import DataGenerationMethod, GenerationConfig, HeaderConfig
+from .models import Case
+from .specs import openapi
 
 __version__ = SCHEMATHESIS_VERSION
 

{schemathesis-3.35.4 → schemathesis-3.36.0}/src/schemathesis/_hypothesis.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 import json
 import warnings
-from typing import Any, Callable, Generator, Mapping, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Callable, Generator, Mapping
 
 import hypothesis
 from hypothesis import Phase
@@ -24,7 +24,9 @@ from .models import APIOperation, Case, GenerationMetadata, TestPhase
 from .transports.content_types import parse_content_type
 from .transports.headers import has_invalid_characters, is_latin_1_encodable
 from .types import NotSet
-from .utils import GivenInput
+
+if TYPE_CHECKING:
+    from .utils import GivenInput
 
 # Forcefully initializes Hypothesis' global PRNG to avoid races that initilize it
 # if e.g. Schemathesis CLI is used with multiple workers
@@ -215,6 +217,7 @@ def _iter_coverage_cases(
     operation: APIOperation, data_generation_methods: list[DataGenerationMethod]
 ) -> Generator[Case, None, None]:
     from .specs.openapi.constants import LOCATION_TO_CONTAINER
+    from .specs.openapi.examples import find_in_responses, find_matching_in_responses
 
     ctx = coverage.CoverageContext(data_generation_methods=data_generation_methods)
     meta = GenerationMetadata(
@@ -222,8 +225,11 @@ def _iter_coverage_cases(
     )
     generators: dict[tuple[str, str], Generator[coverage.GeneratedValue, None, None]] = {}
     template: dict[str, Any] = {}
+    responses = find_in_responses(operation)
     for parameter in operation.iter_parameters():
         schema = parameter.as_json_schema(operation)
+        for value in find_matching_in_responses(responses, parameter.name):
+            schema.setdefault("examples", []).append(value)
         gen = coverage.cover_schema_iter(ctx, schema)
         value = next(gen, NOT_SET)
         if isinstance(value, NotSet):
@@ -274,7 +280,7 @@ def _iter_coverage_cases(
             yield case
 
 
-def find_invalid_headers(headers: Mapping) -> Generator[Tuple[str, str], None, None]:
+def find_invalid_headers(headers: Mapping) -> Generator[tuple[str, str], None, None]:
     for name, value in headers.items():
         if not is_latin_1_encodable(value) or has_invalid_characters(name, value):
             yield name, value
@@ -305,11 +311,11 @@ def add_non_serializable_mark(test: Callable, exc: SerializationNotPossible) ->
     test._schemathesis_non_serializable = exc  # type: ignore
 
 
-def get_non_serializable_mark(test: Callable) -> Optional[SerializationNotPossible]:
+def get_non_serializable_mark(test: Callable) -> SerializationNotPossible | None:
     return getattr(test, "_schemathesis_non_serializable", None)
 
 
-def get_invalid_regex_mark(test: Callable) -> Optional[SchemaError]:
+def get_invalid_regex_mark(test: Callable) -> SchemaError | None:
     return getattr(test, "_schemathesis_invalid_regex", None)
 
 
@@ -317,7 +323,7 @@ def add_invalid_regex_mark(test: Callable, exc: SchemaError) -> None:
     test._schemathesis_invalid_regex = exc  # type: ignore
 
 
-def get_invalid_example_headers_mark(test: Callable) -> Optional[dict[str, str]]:
+def get_invalid_example_headers_mark(test: Callable) -> dict[str, str] | None:
     return getattr(test, "_schemathesis_invalid_example_headers", None)
 
 

{schemathesis-3.35.4 → schemathesis-3.36.0}/src/schemathesis/_override.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from .exceptions import UsageError
-from .parameters import ParameterSet
-from .types import GenericTest
 
 if TYPE_CHECKING:
     from .models import APIOperation
+    from .parameters import ParameterSet
+    from .types import GenericTest
 
 
 @dataclass
@@ -37,7 +37,7 @@ def _for_parameters(overridden: dict[str, str], defined: ParameterSet) -> dict[s
     return output
 
 
-def get_override_from_mark(test: GenericTest) -> Optional[CaseOverride]:
+def get_override_from_mark(test: GenericTest) -> CaseOverride | None:
     return getattr(test, "_schemathesis_override", None)
 
 

{schemathesis-3.35.4 → schemathesis-3.36.0}/src/schemathesis/auths.py

@@ -21,12 +21,12 @@ from typing import (
 
 from .exceptions import UsageError
 from .filters import FilterSet, FilterValue, MatcherFunc, attach_filter_chain
-from .types import GenericTest
 
 if TYPE_CHECKING:
     import requests.auth
 
     from .models import APIOperation, Case
+    from .types import GenericTest
 
 DEFAULT_REFRESH_INTERVAL = 300
 AUTH_STORAGE_ATTRIBUTE_NAME = "_schemathesis_auth"

{schemathesis-3.35.4 → schemathesis-3.36.0}/src/schemathesis/checks.py

@@ -15,11 +15,12 @@ from .specs.openapi.checks import (
 )
 
 if TYPE_CHECKING:
-    from .models import Case, CheckFunction
+    from .internal.checks import CheckContext, CheckFunction
+    from .models import Case
     from .transports.responses import GenericResponse
 
 
-def not_a_server_error(response: GenericResponse, case: Case) -> bool | None:
+def not_a_server_error(ctx: CheckContext, response: GenericResponse, case: Case) -> bool | None:
     """A check to verify that the response is not a server-side error."""
     from .specs.graphql.schemas import GraphQLCase
     from .specs.graphql.validation import validate_graphql_response
@@ -64,14 +65,16 @@ def register(check: CheckFunction) -> CheckFunction:
     .. code-block:: python
 
         @schemathesis.check
-        def new_check(response, case):
+        def new_check(ctx, response, case):
             # some awesome assertions!
             ...
     """
     from . import cli
+    from .internal.checks import wrap_check
 
+    _check = wrap_check(check)
     global ALL_CHECKS
 
-    ALL_CHECKS += (check,)
-    cli.CHECKS_TYPE.choices += (check.__name__,)  # type: ignore
+    ALL_CHECKS += (_check,)
+    cli.CHECKS_TYPE.choices += (_check.__name__,)  # type: ignore
     return check

{schemathesis-3.35.4 → schemathesis-3.36.0}/src/schemathesis/cli/__init__.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import base64
-import io
 import os
 import sys
 import traceback
@@ -41,38 +40,45 @@ from ..internal.datetime import current_datetime
 from ..internal.output import OutputConfig
 from ..internal.validation import file_exists
 from ..loaders import load_app, load_yaml
-from ..models import Case, CheckFunction
 from ..runner import events, prepare_hypothesis_settings, probes
 from ..specs.graphql import loaders as gql_loaders
 from ..specs.openapi import loaders as oas_loaders
 from ..stateful import Stateful
-from ..targets import Target
 from ..transports import RequestConfig
 from ..transports.auth import get_requests_auth
-from ..types import PathLike, RequestCert
 from . import callbacks, cassettes, output
 from .constants import DEFAULT_WORKERS, MAX_WORKERS, MIN_WORKERS, HealthCheck, Phase, Verbosity
 from .context import ExecutionContext, FileReportContext, ServiceReportContext
 from .debug import DebugOutputHandler
 from .handlers import EventHandler
 from .junitxml import JunitXMLHandler
-from .options import CsvChoice, CsvEnumChoice, CustomHelpMessageChoice, NotSet, OptionalInt
+from .options import CsvChoice, CsvEnumChoice, CustomHelpMessageChoice, OptionalInt
 from .sanitization import SanitizationHandler
 
 if TYPE_CHECKING:
+    import io
+
     import hypothesis
     import requests
 
+    from ..models import Case, CheckFunction
     from ..schemas import BaseSchema
     from ..service.client import ServiceClient
     from ..specs.graphql.schemas import GraphQLSchema
+    from ..targets import Target
+    from ..types import NotSet, PathLike, RequestCert
+
+
+__all__ = [
+    "EventHandler",
+]
 
 
 def _get_callable_names(items: tuple[Callable, ...]) -> tuple[str, ...]:
     return tuple(item.__name__ for item in items)
 
 
-CUSTOM_HANDLERS: list[Type[EventHandler]] = []
+CUSTOM_HANDLERS: list[type[EventHandler]] = []
 CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
 
 DEFAULT_CHECKS_NAMES = _get_callable_names(checks_module.DEFAULT_CHECKS)
@@ -98,13 +104,6 @@ DEPRECATED_SHOW_ERROR_TRACEBACKS_OPTION_WARNING = (
     "Warning: Option `--show-errors-tracebacks` is deprecated and will be removed in Schemathesis 4.0. "
     "Use `--show-trace` instead"
 )
-DEPRECATED_CONTRIB_UNIQUE_DATA_OPTION_WARNING = (
-    "The `--contrib-unique-data` CLI option and the corresponding `schemathesis.contrib.unique_data` hook "
-    "are **DEPRECATED**. The concept of this feature does not fit the core principles of Hypothesis where "
-    "strategies are configurable on a per-example basis but this feature implies uniqueness across examples. "
-    "This leads to cryptic error messages about external state and flaky test runs, "
-    "therefore it will be removed in Schemathesis 4.0"
-)
 CASSETTES_PATH_INVALID_USAGE_MESSAGE = "Can't use `--store-network-log` and `--cassette-path` simultaneously"
 COLOR_OPTIONS_INVALID_USAGE_MESSAGE = "Can't use `--no-color` and `--force-color` simultaneously"
 PHASES_INVALID_USAGE_MESSAGE = "Can't use `--hypothesis-phases` and `--hypothesis-no-phases` simultaneously"
@@ -114,14 +113,14 @@ def reset_checks() -> None:
     """Get checks list to their default state."""
     # Useful in tests
     checks_module.ALL_CHECKS = checks_module.DEFAULT_CHECKS + checks_module.OPTIONAL_CHECKS
-    CHECKS_TYPE.choices = _get_callable_names(checks_module.ALL_CHECKS) + ("all",)
+    CHECKS_TYPE.choices = (*_get_callable_names(checks_module.ALL_CHECKS), "all")
 
 
 def reset_targets() -> None:
     """Get targets list to their default state."""
     # Useful in tests
     targets_module.ALL_TARGETS = targets_module.DEFAULT_TARGETS + targets_module.OPTIONAL_TARGETS
-    TARGETS_TYPE.choices = _get_callable_names(targets_module.ALL_TARGETS) + ("all",)
+    TARGETS_TYPE.choices = (*_get_callable_names(targets_module.ALL_TARGETS), "all")
 
 
 @click.group(context_settings=CONTEXT_SETTINGS)
@@ -282,7 +281,7 @@ REPORT_TO_SERVICE = ReportToService()
     "workers_num",
     help="Number of concurrent workers for testing. Auto-adjusts if 'auto' is specified",
     type=CustomHelpMessageChoice(
-        ["auto"] + list(map(str, range(MIN_WORKERS, MAX_WORKERS + 1))),
+        ["auto", *list(map(str, range(MIN_WORKERS, MAX_WORKERS + 1)))],
         choices_repr=f"[auto, {MIN_WORKERS}-{MAX_WORKERS}]",
     ),
     default=str(DEFAULT_WORKERS),
@@ -318,7 +317,7 @@ REPORT_TO_SERVICE = ReportToService()
     "--fixups",
     help="Apply compatibility adjustments",
     multiple=True,
-    type=click.Choice(list(ALL_FIXUPS) + ["all"]),
+    type=click.Choice([*ALL_FIXUPS, "all"]),
     metavar="",
 )
 @group("API validation options")
@@ -433,7 +432,7 @@ REPORT_TO_SERVICE = ReportToService()
     "-A",
     type=click.Choice(["basic", "digest"], case_sensitive=False),
     default="basic",
-    help="Specify the authentication method",
+    help="Specify the authentication method. For custom authentication methods, see our Authentication documentation: https://schemathesis.readthedocs.io/en/stable/auth.html#custom-auth",
     show_default=True,
     metavar="",
 )
@@ -943,9 +942,6 @@ def run(
             entry for health_check in hypothesis_suppress_health_check for entry in health_check.as_hypothesis()
         ]
 
-    if contrib_unique_data:
-        click.secho(DEPRECATED_CONTRIB_UNIQUE_DATA_OPTION_WARNING, fg="yellow")
-
     if show_errors_tracebacks:
         click.secho(DEPRECATED_SHOW_ERROR_TRACEBACKS_OPTION_WARNING, fg="yellow")
         show_trace = show_errors_tracebacks
@@ -1154,8 +1150,6 @@ def run(
         else:
             _fixups.install(fixups)
 
-    if contrib_unique_data:
-        contrib.unique_data.install()
     if contrib_openapi_formats_uuid:
         contrib.openapi.formats.uuid.install()
     if contrib_openapi_fill_missing_examples:
@@ -1191,6 +1185,7 @@ def run(
         seed=hypothesis_seed,
         exit_first=exit_first,
         max_failures=max_failures,
+        unique_data=contrib_unique_data,
         dry_run=dry_run,
         store_interactions=cassette_path is not None,
         checks=selected_checks,
@@ -1315,6 +1310,7 @@ def into_event_stream(
     exit_first: bool,
     max_failures: int | None,
     rate_limit: str | None,
+    unique_data: bool,
     dry_run: bool,
     store_interactions: bool,
     stateful: Stateful | None,
@@ -1358,6 +1354,7 @@ def into_event_stream(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             checks=checks,
@@ -2000,7 +1997,7 @@ def decide_color_output(ctx: click.Context, no_color: bool, force_color: bool) -
         ctx.color = False
 
 
-def add_option(*args: Any, cls: Type = click.Option, **kwargs: Any) -> None:
+def add_option(*args: Any, cls: type = click.Option, **kwargs: Any) -> None:
     """Add a new CLI option to `st run`."""
     run.params.append(cls(args, **kwargs))
 
@@ -2024,10 +2021,10 @@ def add_group(name: str, *, index: int | None = None) -> Group:
     return Group(name)
 
 
-def handler() -> Callable[[Type], None]:
+def handler() -> Callable[[type], None]:
     """Register a new CLI event handler."""
 
-    def _wrapper(cls: Type) -> None:
+    def _wrapper(cls: type) -> None:
         CUSTOM_HANDLERS.append(cls)
 
     return _wrapper

{schemathesis-3.35.4 → schemathesis-3.36.0}/src/schemathesis/cli/callbacks.py

@@ -2,16 +2,16 @@ from __future__ import annotations
 
 import codecs
 import enum
+import operator
 import os
 import re
 import traceback
 from contextlib import contextmanager
-from functools import partial
+from functools import partial, reduce
 from typing import TYPE_CHECKING, Callable, Generator
 from urllib.parse import urlparse
 
 import click
-from click.types import LazyFile  # type: ignore
 
 from .. import exceptions, experimental, throttling
 from ..code_samples import CodeSampleStyle
@@ -24,12 +24,14 @@ from ..loaders import load_app
 from ..service.hosts import get_temporary_hosts_file
 from ..stateful import Stateful
 from ..transports.headers import has_invalid_characters, is_latin_1_encodable
-from ..types import PathLike
 from .cassettes import CassetteFormat
 from .constants import DEFAULT_WORKERS
 
 if TYPE_CHECKING:
     import hypothesis
+    from click.types import LazyFile  # type: ignore[attr-defined]
+
+    from ..types import PathLike
 
 INVALID_DERANDOMIZE_MESSAGE = (
     "`--hypothesis-derandomize` implies no database, so passing `--hypothesis-database` too is invalid."
@@ -339,7 +341,7 @@ def convert_experimental(
 
 
 def convert_checks(ctx: click.core.Context, param: click.core.Parameter, value: tuple[list[str]]) -> list[str]:
-    return sum(value, [])
+    return reduce(operator.iadd, value, [])
 
 
 def convert_code_sample_style(ctx: click.core.Context, param: click.core.Parameter, value: str) -> CodeSampleStyle: