schemathesis 3.18.5__py3-none-any.whl → 3.19.1__py3-none-any.whl

schemathesis/runner/events.py

@@ -1,8 +1,8 @@
 import threading
 import time
+from dataclasses import asdict, dataclass, field
 from typing import Any, Dict, List, Optional, Union
 
-import attr
 from requests import exceptions
 
 from ..constants import USE_WAIT_FOR_SCHEMA_SUGGESTION_MESSAGE, DataGenerationMethod
@@ -13,7 +13,7 @@ from ..utils import current_datetime, format_exception
 from .serialization import SerializedError, SerializedTestResult
 
 
-@attr.s()  # pragma: no mutate
+@dataclass
 class ExecutionEvent:
     """Generic execution event."""
 
@@ -21,31 +21,31 @@ class ExecutionEvent:
     is_terminal = False
 
     def asdict(self, **kwargs: Any) -> Dict[str, Any]:
-        data = attr.asdict(self, **kwargs)
+        data = asdict(self, **kwargs)
         # An internal tag for simpler type identification
         data["event_type"] = self.__class__.__name__
         return data
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Initialized(ExecutionEvent):
     """Runner is initialized, settings are prepared, requests session is ready."""
 
-    schema: Dict[str, Any] = attr.ib()  # pragma: no mutate
+    schema: Dict[str, Any]
     # Total number of operations in the schema
-    operations_count: Optional[int] = attr.ib()  # pragma: no mutate
+    operations_count: Optional[int]
     # The place, where the API schema is located
-    location: Optional[str] = attr.ib()  # pragma: no mutate
+    location: Optional[str]
     # The base URL against which the tests are running
-    base_url: str = attr.ib()  # pragma: no mutate
+    base_url: str
     # API schema specification name
-    specification_name: str = attr.ib()  # pragma: no mutate
+    specification_name: str
     # Monotonic clock value when the test run started. Used to properly calculate run duration, since this clock
     # can't go backwards.
-    start_time: float = attr.ib(factory=time.monotonic)  # pragma: no mutate
+    start_time: float = field(default_factory=time.monotonic)
     # Datetime of the test run start
-    started_at: str = attr.ib(factory=current_datetime)  # pragma: no mutate
-    thread_id: int = attr.ib(factory=threading.get_ident)  # pragma: no mutate
+    started_at: str = field(default_factory=current_datetime)
+    thread_id: int = field(default_factory=threading.get_ident)
 
     @classmethod
     def from_schema(
@@ -71,7 +71,7 @@ class CurrentOperationMixin:
         return f"{self.method} {self.path}"
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class BeforeExecution(CurrentOperationMixin, ExecutionEvent):
     """Happens before each tested API operation.
 
@@ -79,21 +79,21 @@ class BeforeExecution(CurrentOperationMixin, ExecutionEvent):
     """
 
     # HTTP method
-    method: str = attr.ib()  # pragma: no mutate
+    method: str
     # Full path, including the base path
-    path: str = attr.ib()  # pragma: no mutate
+    path: str
     # Specification-specific operation name
-    verbose_name: str = attr.ib()  # pragma: no mutate
+    verbose_name: str
     # Path without the base path
-    relative_path: str = attr.ib()  # pragma: no mutate
+    relative_path: str
     # The current level of recursion during stateful testing
-    recursion_level: int = attr.ib()  # pragma: no mutate
+    recursion_level: int
     # The way data will be generated
-    data_generation_method: List[DataGenerationMethod] = attr.ib()  # pragma: no mutate
+    data_generation_method: List[DataGenerationMethod]
     # A unique ID which connects events that happen during testing of the same API operation
     # It may be useful when multiple threads are involved where incoming events are not ordered
-    correlation_id: str = attr.ib()  # pragma: no mutate
-    thread_id: int = attr.ib(factory=threading.get_ident)  # pragma: no mutate
+    correlation_id: str
+    thread_id: int = field(default_factory=threading.get_ident)
 
     @classmethod
     def from_operation(
@@ -114,27 +114,27 @@ class BeforeExecution(CurrentOperationMixin, ExecutionEvent):
         )
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class AfterExecution(CurrentOperationMixin, ExecutionEvent):
     """Happens after each tested API operation."""
 
-    method: str = attr.ib()  # pragma: no mutate
-    path: str = attr.ib()  # pragma: no mutate
-    relative_path: str = attr.ib()  # pragma: no mutate
+    method: str
+    path: str
+    relative_path: str
     # Specification-specific operation name
-    verbose_name: str = attr.ib()  # pragma: no mutate
+    verbose_name: str
 
     # APIOperation test status - success / failure / error
-    status: Status = attr.ib()  # pragma: no mutate
+    status: Status
     # The way data was generated
-    data_generation_method: List[DataGenerationMethod] = attr.ib()  # pragma: no mutate
-    result: SerializedTestResult = attr.ib()  # pragma: no mutate
+    data_generation_method: List[DataGenerationMethod]
+    result: SerializedTestResult
     # Test running time
-    elapsed_time: float = attr.ib()  # pragma: no mutate
-    correlation_id: str = attr.ib()  # pragma: no mutate
-    thread_id: int = attr.ib(factory=threading.get_ident)  # pragma: no mutate
+    elapsed_time: float
+    correlation_id: str
+    thread_id: int = field(default_factory=threading.get_ident)
     # Captured hypothesis stdout
-    hypothesis_output: List[str] = attr.ib(factory=list)  # pragma: no mutate
+    hypothesis_output: List[str] = field(default_factory=list)
 
     @classmethod
     def from_result(
@@ -161,24 +161,24 @@ class AfterExecution(CurrentOperationMixin, ExecutionEvent):
         )
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Interrupted(ExecutionEvent):
     """If execution was interrupted by Ctrl-C, or a received SIGTERM."""
 
-    thread_id: int = attr.ib(factory=threading.get_ident)  # pragma: no mutate
+    thread_id: int = field(default_factory=threading.get_ident)
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class InternalError(ExecutionEvent):
     """An error that happened inside the runner."""
 
     is_terminal = True
 
-    message: str = attr.ib()  # pragma: no mutate
-    exception_type: str = attr.ib()  # pragma: no mutate
-    exception: Optional[str] = attr.ib(default=None)  # pragma: no mutate
-    exception_with_traceback: Optional[str] = attr.ib(default=None)  # pragma: no mutate
-    thread_id: int = attr.ib(factory=threading.get_ident)  # pragma: no mutate
+    message: str
+    exception_type: str
+    exception: Optional[str] = None
+    exception_with_traceback: Optional[str] = None
+    thread_id: int = field(default_factory=threading.get_ident)
 
     @classmethod
     def from_exc(cls, exc: Exception, wait_for_schema: Optional[float] = None) -> "InternalError":
@@ -205,7 +205,7 @@ class InternalError(ExecutionEvent):
         )
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Finished(ExecutionEvent):
     """The final event of the run.
 
@@ -214,23 +214,23 @@ class Finished(ExecutionEvent):
 
     is_terminal = True
 
-    passed_count: int = attr.ib()  # pragma: no mutate
-    skipped_count: int = attr.ib()  # pragma: no mutate
-    failed_count: int = attr.ib()  # pragma: no mutate
-    errored_count: int = attr.ib()  # pragma: no mutate
+    passed_count: int
+    skipped_count: int
+    failed_count: int
+    errored_count: int
 
-    has_failures: bool = attr.ib()  # pragma: no mutate
-    has_errors: bool = attr.ib()  # pragma: no mutate
-    has_logs: bool = attr.ib()  # pragma: no mutate
-    is_empty: bool = attr.ib()  # pragma: no mutate
-    generic_errors: List[SerializedError] = attr.ib()  # pragma: no mutate
-    warnings: List[str] = attr.ib()  # pragma: no mutate
+    has_failures: bool
+    has_errors: bool
+    has_logs: bool
+    is_empty: bool
+    generic_errors: List[SerializedError]
+    warnings: List[str]
 
-    total: Dict[str, Dict[Union[str, Status], int]] = attr.ib()  # pragma: no mutate
+    total: Dict[str, Dict[Union[str, Status], int]]
 
     # Total test run execution time
-    running_time: float = attr.ib()  # pragma: no mutate
-    thread_id: int = attr.ib(factory=threading.get_ident)  # pragma: no mutate
+    running_time: float
+    thread_id: int = field(default_factory=threading.get_ident)
 
     @classmethod
     def from_results(cls, results: TestResultSet, running_time: float) -> "Finished":

schemathesis/runner/impl/core.py

@@ -4,11 +4,11 @@ import time
 import unittest
 import uuid
 from contextlib import contextmanager
+from dataclasses import dataclass, field
 from types import TracebackType
 from typing import Any, Callable, Dict, Generator, Iterable, List, Optional, Type, Union, cast
 from warnings import WarningMessage, catch_warnings
 
-import attr
 import hypothesis
 import requests
 from _pytest.logging import LogCaptureHandler, catching_logs
@@ -58,27 +58,27 @@ def _should_count_towards_stop(event: events.ExecutionEvent) -> bool:
     return isinstance(event, events.AfterExecution) and event.status in (Status.error, Status.failure)
 
 
-@attr.s  # pragma: no mutate
+@dataclass
 class BaseRunner:
-    schema: BaseSchema = attr.ib()  # pragma: no mutate
-    checks: Iterable[CheckFunction] = attr.ib()  # pragma: no mutate
-    max_response_time: Optional[int] = attr.ib()  # pragma: no mutate
-    targets: Iterable[Target] = attr.ib()  # pragma: no mutate
-    hypothesis_settings: hypothesis.settings = attr.ib()  # pragma: no mutate
-    auth: Optional[RawAuth] = attr.ib(default=None)  # pragma: no mutate
-    auth_type: Optional[str] = attr.ib(default=None)  # pragma: no mutate
-    headers: Optional[Dict[str, Any]] = attr.ib(default=None)  # pragma: no mutate
-    request_timeout: Optional[int] = attr.ib(default=None)  # pragma: no mutate
-    store_interactions: bool = attr.ib(default=False)  # pragma: no mutate
-    seed: Optional[int] = attr.ib(default=None)  # pragma: no mutate
-    exit_first: bool = attr.ib(default=False)  # pragma: no mutate
-    max_failures: Optional[int] = attr.ib(default=None)  # pragma: no mutate
-    started_at: str = attr.ib(factory=current_datetime)  # pragma: no mutate
-    dry_run: bool = attr.ib(default=False)  # pragma: no mutate
-    stateful: Optional[Stateful] = attr.ib(default=None)  # pragma: no mutate
-    stateful_recursion_limit: int = attr.ib(default=DEFAULT_STATEFUL_RECURSION_LIMIT)  # pragma: no mutate
-    count_operations: bool = attr.ib(default=True)  # pragma: no mutate
-    _failures_counter: int = attr.ib(default=0)
+    schema: BaseSchema
+    checks: Iterable[CheckFunction]
+    max_response_time: Optional[int]
+    targets: Iterable[Target]
+    hypothesis_settings: hypothesis.settings
+    auth: Optional[RawAuth] = None
+    auth_type: Optional[str] = None
+    headers: Optional[Dict[str, Any]] = None
+    request_timeout: Optional[int] = None
+    store_interactions: bool = False
+    seed: Optional[int] = None
+    exit_first: bool = False
+    max_failures: Optional[int] = None
+    started_at: str = field(default_factory=current_datetime)
+    dry_run: bool = False
+    stateful: Optional[Stateful] = None
+    stateful_recursion_limit: int = DEFAULT_STATEFUL_RECURSION_LIMIT
+    count_operations: bool = True
+    _failures_counter: int = 0
 
     def execute(self) -> "EventStream":
         """Common logic for all runners."""
@@ -199,15 +199,15 @@ class BaseRunner:
                 )
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class EventStream:
     """Schemathesis event stream.
 
     Provides an API to control the execution flow.
     """
 
-    generator: Generator[events.ExecutionEvent, None, None] = attr.ib()  # pragma: no mutate
-    stop_event: threading.Event = attr.ib()  # pragma: no mutate
+    generator: Generator[events.ExecutionEvent, None, None]
+    stop_event: threading.Event
 
     def __next__(self) -> events.ExecutionEvent:
         return next(self.generator)
@@ -553,7 +553,7 @@ def add_cases(case: Case, response: GenericResponse, test: Callable, *args: Any)
             test(_case, *args)
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class ErrorCollector:
     """Collect exceptions that are not related to failed checks.
 
@@ -566,7 +566,7 @@ class ErrorCollector:
     function signatures, which are used by Hypothesis.
     """
 
-    errors: List[Exception] = attr.ib()  # pragma: no mutate
+    errors: List[Exception]
 
     def __enter__(self) -> "ErrorCollector":
         return self

schemathesis/runner/impl/solo.py

@@ -1,8 +1,7 @@
 import threading
+from dataclasses import dataclass
 from typing import Generator, Optional, Union
 
-import attr
-
 from ...models import TestResultSet
 from ...types import RequestCert
 from ...utils import get_requests_auth
@@ -10,12 +9,12 @@ from .. import events
 from .core import BaseRunner, asgi_test, get_session, network_test, wsgi_test
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class SingleThreadRunner(BaseRunner):
     """Fast runner that runs tests sequentially in the main thread."""
 
-    request_tls_verify: Union[bool, str] = attr.ib(default=True)  # pragma: no mutate
-    request_cert: Optional[RequestCert] = attr.ib(default=None)  # pragma: no mutate
+    request_tls_verify: Union[bool, str] = True
+    request_cert: Optional[RequestCert] = None
 
     def _execute(
         self, results: TestResultSet, stop_event: threading.Event
@@ -47,7 +46,7 @@ class SingleThreadRunner(BaseRunner):
             )
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class SingleThreadWSGIRunner(SingleThreadRunner):
     def _execute_impl(self, results: TestResultSet) -> Generator[events.ExecutionEvent, None, None]:
         yield from self._run_tests(
@@ -67,7 +66,7 @@ class SingleThreadWSGIRunner(SingleThreadRunner):
         )
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class SingleThreadASGIRunner(SingleThreadRunner):
     def _execute_impl(self, results: TestResultSet) -> Generator[events.ExecutionEvent, None, None]:
         yield from self._run_tests(

schemathesis/runner/impl/threadpool.py

@@ -2,10 +2,10 @@ import ctypes
 import queue
 import threading
 import time
+from dataclasses import dataclass
 from queue import Queue
 from typing import Any, Callable, Dict, Generator, Iterable, List, Optional, Union, cast
 
-import attr
 import hypothesis
 
 from ..._hypothesis import create_test
@@ -201,13 +201,13 @@ def stop_worker(thread_id: int) -> None:
     ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(thread_id), ctypes.py_object(SystemExit))
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class ThreadPoolRunner(BaseRunner):
     """Spread different tests among multiple worker threads."""
 
-    workers_num: int = attr.ib(default=2)  # pragma: no mutate
-    request_tls_verify: Union[bool, str] = attr.ib(default=True)  # pragma: no mutate
-    request_cert: Optional[RequestCert] = attr.ib(default=None)  # pragma: no mutate
+    workers_num: int = 2
+    request_tls_verify: Union[bool, str] = True
+    request_cert: Optional[RequestCert] = None
 
     def _execute(
         self, results: TestResultSet, stop_event: threading.Event

schemathesis/runner/serialization.py

@@ -3,9 +3,9 @@
 They all consist of primitive types and don't have references to schemas, app, etc.
 """
 import logging
+from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Set, Tuple
 
-import attr
 import requests
 
 from ..exceptions import FailureContext, InternalError, make_unique_by_key
@@ -13,17 +13,17 @@ from ..models import Case, Check, Interaction, Request, Response, Status, TestRe
 from ..utils import IGNORED_HEADERS, WSGIResponse, format_exception
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class SerializedCase:
-    requests_code: str = attr.ib()
-    curl_code: str = attr.ib()
-    path_template: str = attr.ib()
-    path_parameters: Optional[Dict[str, Any]] = attr.ib()
-    query: Optional[Dict[str, Any]] = attr.ib()
-    cookies: Optional[Dict[str, Any]] = attr.ib()
-    verbose_name: str = attr.ib()
-    data_generation_method: Optional[str] = attr.ib()
-    media_type: Optional[str] = attr.ib()
+    requests_code: str
+    curl_code: str
+    path_template: str
+    path_parameters: Optional[Dict[str, Any]]
+    query: Optional[Dict[str, Any]]
+    cookies: Optional[Dict[str, Any]]
+    verbose_name: str
+    data_generation_method: Optional[str]
+    media_type: Optional[str]
 
     @classmethod
     def from_case(cls, case: Case, headers: Optional[Dict[str, Any]]) -> "SerializedCase":
@@ -42,21 +42,21 @@ class SerializedCase:
         )
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class SerializedCheck:
     # Check name
-    name: str = attr.ib()  # pragma: no mutate
+    name: str
     # Check result
-    value: Status = attr.ib()  # pragma: no mutate
-    request: Request = attr.ib()  # pragma: no mutate
-    response: Optional[Response] = attr.ib()  # pragma: no mutate
+    value: Status
+    request: Request
+    response: Optional[Response]
     # Generated example
-    example: SerializedCase = attr.ib()  # pragma: no mutate
-    message: Optional[str] = attr.ib(default=None)  # pragma: no mutate
+    example: SerializedCase
+    message: Optional[str] = None
     # Failure-specific context
-    context: Optional[FailureContext] = attr.ib(default=None)  # pragma: no mutate
+    context: Optional[FailureContext] = None
     # Cases & responses that were made before this one
-    history: List["SerializedHistoryEntry"] = attr.ib(factory=list)  # pragma: no mutate
+    history: List["SerializedHistoryEntry"] = field(default_factory=list)
 
     @classmethod
     def from_check(cls, check: Check) -> "SerializedCheck":
@@ -100,18 +100,18 @@ class SerializedCheck:
         )
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class SerializedHistoryEntry:
-    case: SerializedCase = attr.ib()
-    response: Response = attr.ib()
+    case: SerializedCase
+    response: Response
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class SerializedError:
-    exception: str = attr.ib()  # pragma: no mutate
-    exception_with_traceback: str = attr.ib()  # pragma: no mutate
-    example: Optional[SerializedCase] = attr.ib()  # pragma: no mutate
-    title: Optional[str] = attr.ib()  # pragma: no mutate
+    exception: str
+    exception_with_traceback: str
+    example: Optional[SerializedCase]
+    title: Optional[str]
 
     @classmethod
     def from_error(
@@ -125,13 +125,13 @@ class SerializedError:
         )
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class SerializedInteraction:
-    request: Request = attr.ib()  # pragma: no mutate
-    response: Response = attr.ib()  # pragma: no mutate
-    checks: List[SerializedCheck] = attr.ib()  # pragma: no mutate
-    status: Status = attr.ib()  # pragma: no mutate
-    recorded_at: str = attr.ib()  # pragma: no mutate
+    request: Request
+    response: Response
+    checks: List[SerializedCheck]
+    status: Status
+    recorded_at: str
 
     @classmethod
     def from_interaction(cls, interaction: Interaction) -> "SerializedInteraction":
@@ -144,23 +144,23 @@ class SerializedInteraction:
         )
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class SerializedTestResult:
-    method: str = attr.ib()  # pragma: no mutate
-    path: str = attr.ib()  # pragma: no mutate
-    verbose_name: str = attr.ib()  # pragma: no mutate
-    has_failures: bool = attr.ib()  # pragma: no mutate
-    has_errors: bool = attr.ib()  # pragma: no mutate
-    has_logs: bool = attr.ib()  # pragma: no mutate
-    is_errored: bool = attr.ib()  # pragma: no mutate
-    is_flaky: bool = attr.ib()  # pragma: no mutate
-    is_skipped: bool = attr.ib()  # pragma: no mutate
-    seed: Optional[int] = attr.ib()  # pragma: no mutate
-    data_generation_method: List[str] = attr.ib()  # pragma: no mutate
-    checks: List[SerializedCheck] = attr.ib()  # pragma: no mutate
-    logs: List[str] = attr.ib()  # pragma: no mutate
-    errors: List[SerializedError] = attr.ib()  # pragma: no mutate
-    interactions: List[SerializedInteraction] = attr.ib()  # pragma: no mutate
+    method: str
+    path: str
+    verbose_name: str
+    has_failures: bool
+    has_errors: bool
+    has_logs: bool
+    is_errored: bool
+    is_flaky: bool
+    is_skipped: bool
+    seed: Optional[int]
+    data_generation_method: List[str]
+    checks: List[SerializedCheck]
+    logs: List[str]
+    errors: List[SerializedError]
+    interactions: List[SerializedInteraction]
 
     @classmethod
     def from_test_result(cls, result: TestResult) -> "SerializedTestResult":

schemathesis/schemas.py

@@ -7,11 +7,14 @@ Their responsibilities:
 They give only static definitions of paths.
 """
 from collections.abc import Mapping
+from contextlib import nullcontext
+from dataclasses import dataclass, field
 from difflib import get_close_matches
 from functools import lru_cache
 from typing import (
     Any,
     Callable,
+    ContextManager,
     Dict,
     Generator,
     Iterable,
@@ -25,11 +28,11 @@ from typing import (
     TypeVar,
     Union,
 )
-from urllib.parse import quote, unquote, urljoin, urlsplit, urlunsplit
+from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
 
-import attr
 import hypothesis
 from hypothesis.strategies import SearchStrategy
+from pyrate_limiter import Limiter
 from requests.structures import CaseInsensitiveDict
 
 from ._hypothesis import create_test
@@ -74,28 +77,29 @@ C = TypeVar("C", bound=Case)
 
 @lru_cache()
 def get_full_path(base_path: str, path: str) -> str:
-    return unquote(urljoin(base_path, quote(path.lstrip("/"))))  # pragma: no mutate
+    return unquote(urljoin(base_path, quote(path.lstrip("/"))))
 
 
-@attr.s(eq=False)  # pragma: no mutate
+@dataclass(eq=False)
 class BaseSchema(Mapping):
-    raw_schema: Dict[str, Any] = attr.ib()  # pragma: no mutate
-    location: Optional[str] = attr.ib(default=None)  # pragma: no mutate
-    base_url: Optional[str] = attr.ib(default=None)  # pragma: no mutate
-    method: Optional[Filter] = attr.ib(default=None)  # pragma: no mutate
-    endpoint: Optional[Filter] = attr.ib(default=None)  # pragma: no mutate
-    tag: Optional[Filter] = attr.ib(default=None)  # pragma: no mutate
-    operation_id: Optional[Filter] = attr.ib(default=None)  # pragma: no mutate
-    app: Any = attr.ib(default=None)  # pragma: no mutate
-    hooks: HookDispatcher = attr.ib(factory=lambda: HookDispatcher(scope=HookScope.SCHEMA))  # pragma: no mutate
-    auth: AuthStorage = attr.ib(factory=AuthStorage)  # pragma: no mutate
-    test_function: Optional[GenericTest] = attr.ib(default=None)  # pragma: no mutate
-    validate_schema: bool = attr.ib(default=True)  # pragma: no mutate
-    skip_deprecated_operations: bool = attr.ib(default=False)  # pragma: no mutate
-    data_generation_methods: List[DataGenerationMethod] = attr.ib(
-        default=DEFAULT_DATA_GENERATION_METHODS
-    )  # pragma: no mutate
-    code_sample_style: CodeSampleStyle = attr.ib(default=CodeSampleStyle.default())  # pragma: no mutate
+    raw_schema: Dict[str, Any]
+    location: Optional[str] = None
+    base_url: Optional[str] = None
+    method: Optional[Filter] = None
+    endpoint: Optional[Filter] = None
+    tag: Optional[Filter] = None
+    operation_id: Optional[Filter] = None
+    app: Any = None
+    hooks: HookDispatcher = field(default_factory=lambda: HookDispatcher(scope=HookScope.SCHEMA))
+    auth: AuthStorage = field(default_factory=AuthStorage)
+    test_function: Optional[GenericTest] = None
+    validate_schema: bool = True
+    skip_deprecated_operations: bool = False
+    data_generation_methods: List[DataGenerationMethod] = field(
+        default_factory=lambda: list(DEFAULT_DATA_GENERATION_METHODS)
+    )
+    code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
+    rate_limiter: Optional[Limiter] = None
 
     def __iter__(self) -> Iterator[str]:
         return iter(self.operations)
@@ -116,7 +120,7 @@ class BaseSchema(Mapping):
     def hook(self, hook: Union[str, Callable]) -> Callable:
         return self.hooks.register(hook)
 
-    @property  # pragma: no mutate
+    @property
     def verbose_name(self) -> str:
         raise NotImplementedError
 
@@ -148,7 +152,7 @@ class BaseSchema(Mapping):
     def get_base_url(self) -> str:
         base_url = self.base_url
         if base_url is not None:
-            return base_url.rstrip("/")  # pragma: no mutate
+            return base_url.rstrip("/")
         return self._build_base_url()
 
     @property
@@ -271,6 +275,7 @@ class BaseSchema(Mapping):
         skip_deprecated_operations: Union[bool, NotSet] = NOT_SET,
         data_generation_methods: Union[DataGenerationMethodInput, NotSet] = NOT_SET,
         code_sample_style: Union[CodeSampleStyle, NotSet] = NOT_SET,
+        rate_limiter: Optional[Limiter] = NOT_SET,
     ) -> "BaseSchema":
         if base_url is NOT_SET:
             base_url = self.base_url
@@ -296,6 +301,8 @@ class BaseSchema(Mapping):
             data_generation_methods = self.data_generation_methods
         if code_sample_style is NOT_SET:
             code_sample_style = self.code_sample_style
+        if rate_limiter is NOT_SET:
+            rate_limiter = self.rate_limiter
 
         return self.__class__(
             self.raw_schema,
@@ -313,6 +320,7 @@ class BaseSchema(Mapping):
             skip_deprecated_operations=skip_deprecated_operations,  # type: ignore
             data_generation_methods=data_generation_methods,  # type: ignore
             code_sample_style=code_sample_style,  # type: ignore
+            rate_limiter=rate_limiter,  # type: ignore
         )
 
     def get_local_hook_dispatcher(self) -> Optional[HookDispatcher]:
@@ -383,6 +391,13 @@ class BaseSchema(Mapping):
     def prepare_schema(self, schema: Any) -> Any:
         raise NotImplementedError
 
+    def ratelimit(self) -> ContextManager:
+        """Limit the rate of sending generated requests."""
+        label = urlparse(self.base_url).netloc
+        if self.rate_limiter is not None:
+            return self.rate_limiter.ratelimit(label, delay=True, max_delay=0)
+        return nullcontext()
+
 
 def operations_to_dict(
     operations: Generator[Result[APIOperation, InvalidSchema], None, None]