schemathesis 4.3.14__tar.gz → 4.3.16__tar.gz

{schemathesis-4.3.14 → schemathesis-4.3.16}/.pre-commit-config.yaml

@@ -36,8 +36,4 @@ repos:
     rev: v0.14.2
     hooks:
       - id: ruff-format
-
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.2
-    hooks:
       - id: ruff-check

{schemathesis-4.3.14 → schemathesis-4.3.16}/CHANGELOG.md

@@ -1,6 +1,29 @@
 # Changelog
 
-## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.14...HEAD) - TBD
+## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.16...HEAD) - TBD
+
+## [4.3.16](https://github.com/schemathesis/schemathesis/compare/v4.3.15...v4.3.16) - 2025-10-30
+
+### :wrench: Changed
+
+- Improve error message when remote reference is not JSON / YAML.
+
+### :racing_car: Performance
+
+- ~10x faster data generation for schemas with `readOnly` / `writeOnly`.
+
+## [4.3.15](https://github.com/schemathesis/schemathesis/compare/v4.3.14...v4.3.15) - 2025-10-29
+
+### :bug: Fixed
+
+- Override order for explicit transport arguments to `Case.call` and `Case.call_and_validate`.
+- Generating `required` properties when they are absent from `properties` and `additionalProperties` is set to `false`.
+
+### :wrench: Changed
+
+- Health check failure errors now show the specific parameter and its schema causing slow generation or filtering issues.
+- Allow accessing all registered check functions via `schemathesis.checks` by using a module-level `__getattr__`.
+- Improve error messages for the `unsupported_method` check.
 
 ## [4.3.14](https://github.com/schemathesis/schemathesis/compare/v4.3.13...v4.3.14) - 2025-10-28
 

{schemathesis-4.3.14 → schemathesis-4.3.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.3.14
+Version: 4.3.16
 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://github.com/schemathesis/schemathesis/blob/master/CHANGELOG.md

{schemathesis-4.3.14 → schemathesis-4.3.16}/corpus/tools.py

@@ -48,7 +48,7 @@ Loader.add_implicit_resolver(  # type: ignore
                     |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*
                     |[-+]?\.(?:inf|Inf|INF)
                     |\.(?:nan|NaN|NAN))$""",
-        re.X,
+        re.VERBOSE,
     ),
     list("-+0123456789."),
 )

{schemathesis-4.3.14 → schemathesis-4.3.16}/docs/configuration.md

@@ -1,10 +1,10 @@
 # Configuration
 
-Most Schemathesis usage works without configuration. Use a config file for authentication, adjusting test generation, or customizing behavior for specific API operations.
+You don’t need a config file to get started. Add one when you need auth, different test volumes, per-operation overrides, or environment-specific settings.
 
 ## Quick Start
 
-### Creating Your First Config File
+### Create your first config file
 
 Create `schemathesis.toml` in your project directory:
 
@@ -13,53 +13,56 @@ Create `schemathesis.toml` in your project directory:
 generation.max-examples = 500
 
 # Increase timeout for slow APIs
-request-timeout = 10.0
+request-timeout = 10.0  # seconds
 
 # Basic authentication
 [auth]
 basic = { username = "${USERNAME}", password = "${PASSWORD}" }
 ```
 
+!!! note ""
+    Variables like `${USERNAME}` are read from your environment when Schemathesis loads the config.
+
 Set environment variables:
 ```bash
 export USERNAME="your_username"
 export PASSWORD="your_password"
 ```
 
-Run Schemathesis - it automatically finds and uses the config:
+Run Schemathesis. It automatically loads `schemathesis.toml`.
 ```bash
 schemathesis run https://api.example.com/openapi.json
 ```
 
-### Config File Location
+### Config file location
 
 Schemathesis looks for `schemathesis.toml` in:
 
 1. Current directory
-2. Parent directories (up to project root)
-3. Path specified with `--config-file`
+2. Parent directories (up to repository root)
+3. A path you pass with `--config-file` (this takes precedence)
 
-## Common Configuration Scenarios
+## Common configuration scenarios
 
 ### Authentication
 
-**API Key in Headers:**
+API key in a header:
 ```toml
 headers = { "X-API-Key" = "${API_KEY}" }
 ```
 
-**Bearer Token:**
+Bearer token in the `Authorization` header:
 ```toml
 headers = { Authorization = "Bearer ${TOKEN}" }
 ```
 
-**Basic Authentication:**
+Basic auth:
 ```toml
 [auth]
 basic = { username = "${USERNAME}", password = "${PASSWORD}" }
 ```
 
-**Different Auth for Specific Operations:**
+Different auth for specific operations:
 ```toml
 # Default auth for most operations
 headers = { Authorization = "Bearer ${TOKEN}" }
@@ -70,51 +73,54 @@ include-tag = "admin"
 headers = { Authorization = "Bearer ${ADMIN_TOKEN}" }
 ```
 
-### Adjusting Test Generation
+### Adjusting test generation
 
-**Run More Tests (Better Coverage, Slower):**
+More tests (better coverage, slower):
 ```toml
 generation.max-examples = 1000
 ```
 
-**Run Fewer Tests (Faster Feedback):**
+Fewer tests (faster feedback):
 ```toml
 generation.max-examples = 50
 ```
 
-**Thorough Testing for Important Endpoints:**
+Deeper testing for important API operations:
 ```toml
-# Default: fast testing
+# Default: fast feedback
 generation.max-examples = 100
 
-# Critical endpoints: more testing
+# Important operations: more depth
 [[operations]]
 include-path-regex = "/(payments|users)/"
 generation.max-examples = 500
 ```
 
-### Handling Slow APIs
+### Slow APIs
+
+If you see timeouts or flaky failures, increase per-operation timeouts.
 
-**Increase Timeouts:**
+Increase timeouts:
 ```toml
-request-timeout = 30.0  # 30 seconds
+request-timeout = 30.0  # seconds
 ```
 
-**Different Timeouts by Operation:**
+Different timeouts by operation:
 ```toml
 # Default timeout
 request-timeout = 5.0
 
-# Slow operations need more time
+# Give slow operations more time
 [[operations]]
 include-tag = "slow"
 request-timeout = 30.0
 ```
 
-### Environment-Specific Configuration
+### Environment-specific configuration
 
-**Different Base URLs per Environment:**
+Different base URLs per environment:
 ```toml
+# Switch base URL by environment variable
 base-url = "https://${ENVIRONMENT}.api.example.com"
 ```
 
@@ -122,22 +128,22 @@ base-url = "https://${ENVIRONMENT}.api.example.com"
 # Development
 export ENVIRONMENT="dev"
 
-# Production  
+# Production
 export ENVIRONMENT="prod"
 ```
 
-**Skip Problematic Endpoints in Development:**
+Skip problematic endpoints in development:
 ```toml
 [[operations]]
 include-path = "/billing/charge"
 enabled = false
 ```
 
-## Advanced Configuration
+## Advanced configuration
 
-**Advanced Filtering with Expressions:**
+Advanced filtering with expressions:
 ```toml
-# Operations without operationId
+# Ignore operations that lack operationId
 [[operations]]
 include-by = "operationId == null"
 enabled = false
@@ -148,9 +154,9 @@ exclude-by = "responses/200/description != 'Success'"
 checks.response_schema_conformance.enabled = false
 ```
 
-### Test Phase Control
+### Test phase control
 
-**Disable Specific Testing Phases:**
+Disable specific testing phases:
 ```toml
 [phases]
 # Skip stateful testing for faster runs
@@ -160,7 +166,7 @@ stateful.enabled = false
 stateful.generation.max-examples = 10
 ```
 
-**Phase-Specific Settings per Operation:**
+Phase-specific settings per operation:
 ```toml
 [[operations]]
 include-name = "POST /orders"
@@ -170,9 +176,10 @@ phases.fuzzing.generation.max-examples = 500
 phases.stateful.generation.max-examples = 20
 ```
 
-### Multi-Project Configuration
+### Multi-project configuration
+
+Top-level options act as defaults for all projects. Each `[[project]]` can override them.
 
-**Testing Multiple APIs:**
 ```toml
 # Global defaults
 generation.max-examples = 100
@@ -192,9 +199,9 @@ base-url = "https://users.example.com"
 request-timeout = 2.0
 ```
 
-### Custom Check Configuration
+### Custom check configuration
 
-**Disable Problematic Checks:**
+Disable noisy checks:
 ```toml
 [checks]
 # Disable globally
@@ -206,7 +213,7 @@ include-name = "POST /uploads"
 checks.positive_data_acceptance.expected-statuses = [200, 201, 202]
 ```
 
-**Enable Only Specific Checks:**
+Enable only specific checks:
 ```toml
 [checks]
 enabled = false

{schemathesis-4.3.14 → schemathesis-4.3.16}/docs/reference/configuration.md

@@ -1,19 +1,19 @@
 # Configuration Options
 
-This reference covers all the configuration options available in `schemathesis.toml`. The settings are organized into two main categories:
+This page lists every `schemathesis.toml` option and how it is resolved at runtime. The settings are organized into two main categories:
 
 - **Global**: These control CLI behavior, output formatting, and overall test execution. They are defined at the top level and affect the CLI invocation.
-- **Per-Project**: These let you customize configurations for individual API projects. If project-level settings are placed at the top level (without a `[[project]]` namespace), they are used as defaults for any tested project.
+- **Project**: Settings under `[[project]]` customize a single API. If you place project settings at the top level (without `[[project]]`), they become defaults for all projects.
 
 ## Configuration Resolution
 
-Schemathesis applies settings in the following hierarchy (from highest to lowest precedence):
+Schemathesis applies settings from highest to lowest precedence:
 
 1. CLI options
 2. Operation-specific phase settings
 3. Global phase settings (e.g., `[phases.fuzzing]`)
-4. Operation-level settings (e.g., `[[operations]]`)
-5. Project-level settings (e.g., `[[project]]`)
+4. Operation settings (e.g., `[[operations]]`)
+5. Project settings (e.g., `[[project]]`)
 6. Global settings
 
 ## Environment Variable Substitution
@@ -28,7 +28,7 @@ headers = { Authorization = "Bearer ${API_TOKEN}" }
 This allows you to maintain a single configuration file across different environments by changing environment variables rather than the configuration itself.
 
 !!! note ""
-    If you use `pytest`, environment variables are resolved when the `SchemathesisConfig` object is initialized, which usually happens inside schema loaders like `schemathesis.openapi.from_url`.
+    With `pytest`, variables are resolved when `SchemathesisConfig` is created (typically inside `schemathesis.openapi.from_url`).
 
 ## Operation-Specific Configuration
 
@@ -42,9 +42,9 @@ include-path = "/users"
 exclude-method = "POST"
 # By full operation name
 # include-name = "POST /users/"
-# By Open API tag
+# By OpenAPI tag
 # include-tag = "admin"
-# By Open API operation ID
+# By OpenAPI operation ID
 # include-operation-id = "delete-user"
 enabled = false
 ```
@@ -81,7 +81,7 @@ parameters = { "path.user_id" = 42, "query.user_id" = 100 }
     **Type**: `Boolean or None`  
     **Default**: `null`  
 
-    Controls ANSI color output in the CLI. Schemathesis auto-detects color support by default. Set to `true` to force color output or `false` to disable it.
+    Use color in CLI output. Schemathesis auto-detects color support by default Set `true` to force color, `false` to disable.
 
     ```toml
     color = false
@@ -133,7 +133,7 @@ parameters = { "path.user_id" = 42, "query.user_id" = 100 }
     **Type**: `Boolean` or `Array[String]`  
     **Default**: `true` (all warnings enabled)  
 
-    Controls which warnings are displayed during test execution. Warnings highlight issues that could prevent tests from reaching your API's core logic.
+    Warnings flag conditions that may keep tests from exercising core logic. Set `false` to disable all, or list specific warnings to enable only those.
 
     ```toml
     # Disable all warnings

{schemathesis-4.3.14 → schemathesis-4.3.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "4.3.14"
+version = "4.3.16"
 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" }]
@@ -120,14 +120,15 @@ target-version = "py39"
 
 [tool.ruff.lint]
 select = [
-  "E", # pycodestyle errors
-  "W", # pycodestyle warnings
-  "F", # pyflakes
-  "C", # flake8-comprehensions
-  "B", # flake8-bugbear
-  "D", # pydocstyle
-  "T201",
-  "I",
+  "E",     # pycodestyle errors
+  "W",     # pycodestyle warnings
+  "F",     # pyflakes
+  "C",     # flake8-comprehensions
+  "B",     # flake8-bugbear
+  "D",     # pydocstyle
+  "T201",  # flake8-print
+  "I",     # isort
+  "FURB",  # refurb
 ]
 ignore = [
   "E501", # Line too long

{schemathesis-4.3.14 → schemathesis-4.3.16}/src/schemathesis/checks.py

@@ -93,7 +93,7 @@ CHECKS = Registry[CheckFunction]()
 
 def load_all_checks() -> None:
     # NOTE: Trigger registering all Open API checks
-    from schemathesis.specs.openapi.checks import status_code_conformance  # noqa: F401, F403
+    from schemathesis.specs.openapi.checks import status_code_conformance  # noqa: F401
 
 
 def check(func: CheckFunction) -> CheckFunction:
@@ -187,3 +187,14 @@ def run_checks(
                 on_failure(name, collected, sub_failure)
 
     return collected
+
+
+def __getattr__(name: str) -> Any:
+    try:
+        return CHECKS.get_one(name)
+    except KeyError:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from None
+
+
+def __dir__() -> list[str]:
+    return sorted(list(globals().keys()) + CHECKS.get_all_names())

{schemathesis-4.3.14 → schemathesis-4.3.16}/src/schemathesis/cli/commands/run/handlers/cassettes.py

@@ -123,8 +123,7 @@ def vcr_writer(output: TextOutput, config: ProjectConfig, queue: Queue) -> None:
     current_id = 1
 
     def write_header_values(stream: IO, values: list[str]) -> None:
-        for v in values:
-            stream.write(f"      - {json.dumps(v)}\n")
+        stream.writelines(f"      - {json.dumps(v)}\n" for v in values)
 
     if config.output.sanitization.enabled:
         sanitization_keys = config.output.sanitization.keys_to_sanitize

{schemathesis-4.3.14 → schemathesis-4.3.16}/src/schemathesis/config/_error.py

@@ -142,7 +142,7 @@ def _format_anyof_error(error: ValidationError) -> str:
         )
     elif list(error.schema_path) == ["properties", "workers", "anyOf"]:
         return (
-            f"Invalid value for 'workers': {repr(error.instance)}\n\n"
+            f"Invalid value for 'workers': {error.instance!r}\n\n"
             f"Expected either:\n"
             f"  - A positive integer (e.g., workers = 4)\n"
             f'  - The string "auto" for automatic detection (workers = "auto")'

{schemathesis-4.3.14 → schemathesis-4.3.16}/src/schemathesis/core/errors.py

@@ -161,6 +161,8 @@ class InvalidSchema(SchemathesisError):
             message += "\n    File reference could not be resolved. Check that the file exists."
         elif reference.startswith(("#/components", "#/definitions")):
             message += "\n    Component does not exist in the schema."
+        elif isinstance(error.__cause__, RemoteDocumentError):
+            message += f"\n    {error.__cause__}"
         return cls(message, path=path, method=method)
 
     def as_failing_test_function(self) -> Callable:
@@ -176,6 +178,13 @@ class InvalidSchema(SchemathesisError):
         return actual_test
 
 
+class RemoteDocumentError(SchemathesisError):
+    """Remote reference resolution failed.
+
+    This exception carries more context than the default one in `jsonschema`.
+    """
+
+
 class HookError(SchemathesisError):
     """Happens during hooks loading."""
 

{schemathesis-4.3.14 → schemathesis-4.3.16}/src/schemathesis/core/registries.py

@@ -26,6 +26,9 @@ class Registry(Generic[T]):
     def get_all(self) -> list[T]:
         return list(self._items.values())
 
+    def get_one(self, name: str) -> T:
+        return self._items[name]
+
     def get_by_names(self, names: Sequence[str]) -> list[T]:
         """Get items by their names."""
         return [self._items[name] for name in names]

{schemathesis-4.3.14 → schemathesis-4.3.16}/src/schemathesis/engine/errors.py

@@ -12,6 +12,8 @@ from dataclasses import dataclass
 from functools import cached_property
 from typing import TYPE_CHECKING, Callable, Iterator, Sequence, cast
 
+from hypothesis import HealthCheck
+
 from schemathesis import errors
 from schemathesis.core.errors import (
     InfiniteRecursiveReference,
@@ -23,6 +25,7 @@ from schemathesis.core.errors import (
     get_request_error_message,
     split_traceback,
 )
+from schemathesis.generation.hypothesis.reporting import HEALTH_CHECK_ACTIONS, HEALTH_CHECK_TITLES
 
 if TYPE_CHECKING:
     import hypothesis.errors
@@ -119,15 +122,6 @@ class EngineErrorInfo:
             scalar_name = scalar_name_from_error(self._error)
             return f"Scalar type '{scalar_name}' is not recognized"
 
-        if self._kind == RuntimeErrorKind.HYPOTHESIS_HEALTH_CHECK_DATA_TOO_LARGE:
-            return HEALTH_CHECK_MESSAGE_DATA_TOO_LARGE
-        if self._kind == RuntimeErrorKind.HYPOTHESIS_HEALTH_CHECK_FILTER_TOO_MUCH:
-            return HEALTH_CHECK_MESSAGE_FILTER_TOO_MUCH
-        if self._kind == RuntimeErrorKind.HYPOTHESIS_HEALTH_CHECK_TOO_SLOW:
-            return HEALTH_CHECK_MESSAGE_TOO_SLOW
-        if self._kind == RuntimeErrorKind.HYPOTHESIS_HEALTH_CHECK_LARGE_BASE_EXAMPLE:
-            return HEALTH_CHECK_MESSAGE_LARGE_BASE_EXAMPLE
-
         if self._kind in (
             RuntimeErrorKind.SCHEMA_INVALID_REGULAR_EXPRESSION,
             RuntimeErrorKind.SCHEMA_GENERIC,
@@ -216,16 +210,9 @@ def scalar_name_from_error(exception: hypothesis.errors.InvalidArgument) -> str:
 
 
 def extract_health_check_error(error: hypothesis.errors.FailedHealthCheck) -> hypothesis.HealthCheck | None:
-    from hypothesis import HealthCheck
-
-    match = re.search(r"add HealthCheck\.(\w+) to the suppress_health_check ", str(error))
-    if match:
-        return {
-            "data_too_large": HealthCheck.data_too_large,
-            "filter_too_much": HealthCheck.filter_too_much,
-            "too_slow": HealthCheck.too_slow,
-            "large_base_example": HealthCheck.large_base_example,
-        }.get(match.group(1))
+    for key, title in HEALTH_CHECK_TITLES.items():
+        if title in str(error):
+            return key
     return None
 
 
@@ -233,7 +220,13 @@ def get_runtime_error_suggestion(error_type: RuntimeErrorKind, bold: Callable[[s
     """Get a user-friendly suggestion for handling the error."""
 
     def _format_health_check_suggestion(label: str) -> str:
-        return f"Bypass this health check using {bold(f'`--suppress-health-check={label}`')}."
+        base = {
+            "data_too_large": HEALTH_CHECK_ACTIONS[HealthCheck.data_too_large],
+            "filter_too_much": HEALTH_CHECK_ACTIONS[HealthCheck.filter_too_much],
+            "too_slow": HEALTH_CHECK_ACTIONS[HealthCheck.too_slow],
+            "large_base_example": HEALTH_CHECK_ACTIONS[HealthCheck.large_base_example],
+        }[label]
+        return f"{base} or bypass this health check using {bold(f'`--suppress-health-check={label}`')}."
 
     return {
         RuntimeErrorKind.CONNECTION_SSL: f"Bypass SSL verification with {bold('`--tls-verify=false`')}.",
@@ -252,28 +245,6 @@ def get_runtime_error_suggestion(error_type: RuntimeErrorKind, bold: Callable[[s
     }.get(error_type)
 
 
-HEALTH_CHECK_MESSAGE_DATA_TOO_LARGE = """There's a notable occurrence of examples surpassing the maximum size limit.
-Typically, generating excessively large examples can compromise the quality of test outcomes.
-
-Consider revising the schema to more accurately represent typical use cases
-or applying constraints to reduce the data size."""
-HEALTH_CHECK_MESSAGE_FILTER_TOO_MUCH = """A significant number of generated examples are being filtered out, indicating
-that the schema's constraints may be too complex.
-
-This level of filtration can slow down testing and affect the distribution
-of generated data. Review and simplify the schema constraints where
-possible to mitigate this issue."""
-HEALTH_CHECK_MESSAGE_TOO_SLOW = "Data generation is extremely slow. Consider reducing the complexity of the schema."
-HEALTH_CHECK_MESSAGE_LARGE_BASE_EXAMPLE = """A health check has identified that the smallest example derived from the schema
-is excessively large, potentially leading to inefficient test execution.
-
-This is commonly due to schemas that specify large-scale data structures by
-default, such as an array with an extensive number of elements.
-
-Consider revising the schema to more accurately represent typical use cases
-or applying constraints to reduce the data size."""
-
-
 @enum.unique
 class RuntimeErrorKind(str, enum.Enum):
     """Classification of runtime errors."""

{schemathesis-4.3.14 → schemathesis-4.3.16}/src/schemathesis/engine/phases/unit/_executor.py

@@ -54,7 +54,11 @@ from schemathesis.generation.hypothesis.builder import (
     UnresolvableReferenceMark,
     UnsatisfiableExampleMark,
 )
-from schemathesis.generation.hypothesis.reporting import build_unsatisfiable_error, ignore_hypothesis_output
+from schemathesis.generation.hypothesis.reporting import (
+    build_health_check_error,
+    build_unsatisfiable_error,
+    ignore_hypothesis_output,
+)
 
 if TYPE_CHECKING:
     from schemathesis.schemas import APIOperation
@@ -162,6 +166,9 @@ def run_test(
             status = Status.FAILURE
     except BaseExceptionGroup:
         status = Status.ERROR
+    except hypothesis.errors.FailedHealthCheck as exc:
+        status = Status.ERROR
+        yield non_fatal_error(build_health_check_error(operation, exc, with_tip=False))
     except hypothesis.errors.Unsatisfiable:
         # We need more clear error message here
         status = Status.ERROR
@@ -211,7 +218,11 @@ def run_test(
             # `hypothesis-jsonschema` emits a warning on invalid regular expression syntax
             yield non_fatal_error(InvalidRegexPattern.from_hypothesis_jsonschema_message(message))
         else:
-            yield non_fatal_error(exc)
+            health_check = build_health_check_error(operation, exc, with_tip=False)
+            if isinstance(health_check, hypothesis.errors.FailedHealthCheck):
+                yield non_fatal_error(health_check)
+            else:
+                yield non_fatal_error(exc)
     except hypothesis.errors.DeadlineExceeded as exc:
         status = Status.ERROR
         yield non_fatal_error(DeadlineExceeded.from_exc(exc))

{schemathesis-4.3.14 → schemathesis-4.3.16}/src/schemathesis/generation/hypothesis/examples.py

@@ -28,17 +28,23 @@ def default_settings() -> settings:
 T = TypeVar("T")
 
 
-def generate_one(strategy: st.SearchStrategy[T]) -> T:  # type: ignore[type-var]
+def generate_one(strategy: st.SearchStrategy[T], suppress_health_check: list | None = None) -> T:  # type: ignore[type-var]
     examples: list[T] = []
-    add_single_example(strategy, examples)
+    add_single_example(strategy, examples, suppress_health_check)
     return examples[0]
 
 
-def add_single_example(strategy: st.SearchStrategy[T], examples: list[T]) -> None:
-    from hypothesis import given, seed
+def add_single_example(
+    strategy: st.SearchStrategy[T], examples: list[T], suppress_health_check: list | None = None
+) -> None:
+    from hypothesis import given, seed, settings
+
+    applied_settings = default_settings()
+    if suppress_health_check is not None:
+        applied_settings = settings(applied_settings, suppress_health_check=suppress_health_check)
 
     @given(strategy)  # type: ignore
-    @default_settings()  # type: ignore
+    @applied_settings  # type: ignore
     def example_generating_inner_function(ex: T) -> None:
         examples.append(ex)