schemathesis 3.21.2__py3-none-any.whl → 3.22.1__py3-none-any.whl

schemathesis/specs/openapi/serialization.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
 import json
-from typing import Any, Callable, Dict, Generator, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, Generator, List
 
 from ...utils import compose
 
@@ -10,11 +11,11 @@ MapFunction = Callable[[Generated], Generated]
 
 
 def make_serializer(
-    func: Callable[[DefinitionList], Generator[Optional[Callable], None, None]]
-) -> Callable[[DefinitionList], Optional[Callable]]:
+    func: Callable[[DefinitionList], Generator[Callable | None, None, None]]
+) -> Callable[[DefinitionList], Callable | None]:
     """A maker function to avoid code duplication."""
 
-    def _wrapper(definitions: DefinitionList) -> Optional[Callable]:
+    def _wrapper(definitions: DefinitionList) -> Callable | None:
         conversions = list(func(definitions))
         if conversions:
             return compose(*[conv for conv in conversions if conv is not None])
@@ -23,7 +24,7 @@ def make_serializer(
     return _wrapper
 
 
-def _serialize_openapi3(definitions: DefinitionList) -> Generator[Optional[Callable], None, None]:
+def _serialize_openapi3(definitions: DefinitionList) -> Generator[Callable | None, None, None]:
     """Different collection styles for Open API 3.0."""
     for definition in definitions:
         name = definition["name"]
@@ -49,8 +50,8 @@ def _serialize_openapi3(definitions: DefinitionList) -> Generator[Optional[Calla
 
 
 def _serialize_path_openapi3(
-    name: str, type_: str, style: Optional[str], explode: Optional[bool]
-) -> Generator[Optional[Callable], None, None]:
+    name: str, type_: str, style: str | None, explode: bool | None
+) -> Generator[Callable | None, None, None]:
     if style == "simple":
         if type_ == "object":
             if explode is False:
@@ -76,8 +77,8 @@ def _serialize_path_openapi3(
 
 
 def _serialize_query_openapi3(
-    name: str, type_: str, style: Optional[str], explode: Optional[bool]
-) -> Generator[Optional[Callable], None, None]:
+    name: str, type_: str, style: str | None, explode: bool | None
+) -> Generator[Callable | None, None, None]:
     if type_ == "object":
         if style == "deepObject":
             yield deep_object(name)
@@ -95,9 +96,7 @@ def _serialize_query_openapi3(
             yield delimited(name, delimiter=",")
 
 
-def _serialize_header_openapi3(
-    name: str, type_: str, explode: Optional[bool]
-) -> Generator[Optional[Callable], None, None]:
+def _serialize_header_openapi3(name: str, type_: str, explode: bool | None) -> Generator[Callable | None, None, None]:
     # Headers should be coerced to a string so we can check it for validity later
     yield to_string(name)
     # Header parameters always use the "simple" style, that is, comma-separated values
@@ -110,9 +109,7 @@ def _serialize_header_openapi3(
             yield delimited_object(name)
 
 
-def _serialize_cookie_openapi3(
-    name: str, type_: str, explode: Optional[bool]
-) -> Generator[Optional[Callable], None, None]:
+def _serialize_cookie_openapi3(name: str, type_: str, explode: bool | None) -> Generator[Callable | None, None, None]:
     # Cookies should be coerced to a string so we can check it for validity later
     yield to_string(name)
     # Cookie parameters always use the "form" style
@@ -129,7 +126,7 @@ def _serialize_cookie_openapi3(
             yield comma_delimited_object(name)
 
 
-def _serialize_swagger2(definitions: DefinitionList) -> Generator[Optional[Callable], None, None]:
+def _serialize_swagger2(definitions: DefinitionList) -> Generator[Callable | None, None, None]:
     """Different collection formats for Open API 2.0."""
     for definition in definitions:
         name = definition["name"]
@@ -165,11 +162,11 @@ def conversion(func: Callable[..., None]) -> Callable:
     return _wrapper
 
 
-def make_delimited(data: Optional[Dict[str, Any]], delimiter: str = ",") -> str:
+def make_delimited(data: dict[str, Any] | None, delimiter: str = ",") -> str:
     return delimiter.join(f"{key}={value}" for key, value in force_dict(data or {}).items())
 
 
-def force_iterable(value: Any) -> Union[List, Tuple]:
+def force_iterable(value: Any) -> list | tuple:
     """Converts the value to a list or a tuple.
 
     Only relevant for negative test scenarios where the original types might be changed.
@@ -179,7 +176,7 @@ def force_iterable(value: Any) -> Union[List, Tuple]:
     return [value]
 
 
-def force_dict(value: Any) -> Dict:
+def force_dict(value: Any) -> dict:
     """Converts the value to a dictionary.
 
     Only relevant for negative test scenarios where the original types might be changed.
@@ -247,7 +244,7 @@ def label_primitive(item: Generated, name: str) -> None:
 
 
 @conversion
-def label_array(item: Generated, name: str, explode: Optional[bool]) -> None:
+def label_array(item: Generated, name: str, explode: bool | None) -> None:
     """Serialize an array with the `label` style.
 
     Explode=True
@@ -270,7 +267,7 @@ def label_array(item: Generated, name: str, explode: Optional[bool]) -> None:
 
 
 @conversion
-def label_object(item: Generated, name: str, explode: Optional[bool]) -> None:
+def label_object(item: Generated, name: str, explode: bool | None) -> None:
     """Serialize an object with the `label` style.
 
     Explode=True
@@ -306,7 +303,7 @@ def matrix_primitive(item: Generated, name: str) -> None:
 
 
 @conversion
-def matrix_array(item: Generated, name: str, explode: Optional[bool]) -> None:
+def matrix_array(item: Generated, name: str, explode: bool | None) -> None:
     """Serialize an array with the `matrix` style.
 
     Explode=True
@@ -328,7 +325,7 @@ def matrix_array(item: Generated, name: str, explode: Optional[bool]) -> None:
 
 
 @conversion
-def matrix_object(item: Generated, name: str, explode: Optional[bool]) -> None:
+def matrix_object(item: Generated, name: str, explode: bool | None) -> None:
     """Serialize an object with the `matrix` style.
 
     Explode=True

schemathesis/specs/openapi/stateful/__init__.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
 from collections import defaultdict
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, cast
+from typing import TYPE_CHECKING, Any, List, cast
 
 from hypothesis import strategies as st
 from hypothesis.stateful import Bundle, Rule, precondition, rule
@@ -18,13 +19,13 @@ if TYPE_CHECKING:
 
 
 class OpenAPIStateMachine(APIStateMachine):
-    def transform(self, result: StepResult, direction: Direction, case: "Case") -> "Case":
+    def transform(self, result: StepResult, direction: Direction, case: Case) -> Case:
         context = expressions.ExpressionContext(case=result.case, response=result.response)
         direction.set_data(case, elapsed=result.elapsed, context=context)
         return case
 
 
-def create_state_machine(schema: "BaseOpenAPISchema") -> Type[APIStateMachine]:
+def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
     """Create a state machine class.
 
     It aims to avoid making calls that are not likely to lead to a stateful call later. For example:
@@ -42,17 +43,17 @@ def create_state_machine(schema: "BaseOpenAPISchema") -> Type[APIStateMachine]:
 
     rules = make_all_rules(operations, bundles, connections)
 
-    kwargs: Dict[str, Any] = {"bundles": bundles, "schema": schema}
+    kwargs: dict[str, Any] = {"bundles": bundles, "schema": schema}
     return type("APIWorkflow", (OpenAPIStateMachine,), {**kwargs, **rules})
 
 
-def init_bundles(schema: "BaseOpenAPISchema") -> Dict[str, CaseInsensitiveDict]:
+def init_bundles(schema: BaseOpenAPISchema) -> dict[str, CaseInsensitiveDict]:
     """Create bundles for all operations in the given schema.
 
     Each API operation has a bundle that stores all responses from that operation.
     We need to create bundles first, so they can be referred when building connections between operations.
     """
-    output: Dict[str, CaseInsensitiveDict] = {}
+    output: dict[str, CaseInsensitiveDict] = {}
     for result in schema.get_all_operations():
         if isinstance(result, Ok):
             operation = result.ok()
@@ -62,10 +63,10 @@ def init_bundles(schema: "BaseOpenAPISchema") -> Dict[str, CaseInsensitiveDict]:
 
 
 def make_all_rules(
-    operations: List["APIOperation"],
-    bundles: Dict[str, CaseInsensitiveDict],
+    operations: list[APIOperation],
+    bundles: dict[str, CaseInsensitiveDict],
     connections: APIOperationConnections,
-) -> Dict[str, Rule]:
+) -> dict[str, Rule]:
     """Create rules for all API operations, based on the provided connections."""
     rules = {}
     for operation in operations:
@@ -76,10 +77,10 @@ def make_all_rules(
 
 
 def make_rule(
-    operation: "APIOperation",
+    operation: APIOperation,
     bundle: Bundle,
     connections: APIOperationConnections,
-) -> Optional[Rule]:
+) -> Rule | None:
     """Create a rule for an API operation."""
 
     def _make_rule(previous: st.SearchStrategy) -> Rule:

schemathesis/specs/openapi/stateful/links.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Callable, Dict, List, Tuple
+from typing import TYPE_CHECKING, Callable, Dict, List
 
 import hypothesis.strategies as st
 from requests.structures import CaseInsensitiveDict
@@ -18,15 +18,15 @@ FilterFunction = Callable[["StepResult"], bool]
 @dataclass
 class Connection:
     source: str
-    strategy: st.SearchStrategy[Tuple[StepResult, OpenAPILink]]
+    strategy: st.SearchStrategy[tuple[StepResult, OpenAPILink]]
 
 
 APIOperationConnections = Dict[str, List[Connection]]
 
 
 def apply(
-    operation: "APIOperation",
-    bundles: Dict[str, CaseInsensitiveDict],
+    operation: APIOperation,
+    bundles: dict[str, CaseInsensitiveDict],
     connections: APIOperationConnections,
 ) -> None:
     """Gather all connections based on Open API links definitions."""
@@ -42,12 +42,12 @@ def apply(
 
 def _convert_strategy(
     strategy: st.SearchStrategy[StepResult], link: OpenAPILink
-) -> st.SearchStrategy[Tuple[StepResult, OpenAPILink]]:
+) -> st.SearchStrategy[tuple[StepResult, OpenAPILink]]:
     # This function is required to capture values properly (it won't work properly when lambda is defined in a loop)
     return strategy.map(lambda out: (out, link))
 
 
-def make_response_filter(status_code: str, all_status_codes: List[str]) -> FilterFunction:
+def make_response_filter(status_code: str, all_status_codes: list[str]) -> FilterFunction:
     """Create a filter for stored responses.
 
     This filter will decide whether some response is suitable to use as a source for requesting some API operation.
@@ -76,7 +76,7 @@ def match_status_code(status_code: str) -> FilterFunction:
     return compare
 
 
-def default_status_code(status_codes: List[str]) -> FilterFunction:
+def default_status_code(status_codes: list[str]) -> FilterFunction:
     """Create a filter that matches all "default" responses.
 
     In Open API, the "default" response is the one that is used if no other options were matched.

schemathesis/specs/openapi/utils.py

@@ -1,9 +1,10 @@
+from __future__ import annotations
 import string
 from itertools import product
-from typing import Any, Dict, Generator, List, Union
+from typing import Any, Generator
 
 
-def expand_status_code(status_code: Union[str, int]) -> Generator[int, None, None]:
+def expand_status_code(status_code: str | int) -> Generator[int, None, None]:
     chars = [list(string.digits) if digit == "X" else [digit] for digit in str(status_code).upper()]
     for expanded in product(*chars):
         yield int("".join(expanded))
@@ -14,7 +15,7 @@ def is_header_location(location: str) -> bool:
     return location in ("header", "cookie")
 
 
-def get_type(schema: Dict[str, Any]) -> List[str]:
+def get_type(schema: dict[str, Any]) -> list[str]:
     type_ = schema.get("type", ["null", "boolean", "integer", "number", "string", "array", "object"])
     if isinstance(type_, str):
         return [type_]

schemathesis/specs/openapi/validation.py

@@ -1,4 +1,5 @@
-from typing import Any, List, Tuple, Union
+from __future__ import annotations
+from typing import Any
 
 from ...constants import HTTP_METHODS
 
@@ -9,7 +10,7 @@ def is_pattern_error(exception: TypeError) -> bool:
     return "expected string or bytes-like object" in str(exception)
 
 
-def find_numeric_http_status_codes(schema: Any) -> List[Tuple[int, List[Union[str, int]]]]:
+def find_numeric_http_status_codes(schema: Any) -> list[tuple[int, list[str | int]]]:
     if not isinstance(schema, dict):
         return []
     found = []

schemathesis/stateful/__init__.py

@@ -2,9 +2,9 @@ from __future__ import annotations
 import enum
 import json
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Callable, Dict, Generator, List, Optional, Tuple, Type
+from typing import TYPE_CHECKING, Any, Callable, Generator
 
-from .._dependency_versions import IS_HYPOTHESIS_ABOVE_6_68_1
+from .. import GenerationConfig
 from ..exceptions import OperationSchemaError
 from ..models import APIOperation, Case
 from ..constants import NOT_SET
@@ -29,7 +29,7 @@ class ParsedData:
     It is used later to create a new version of an API operation that will reuse this data.
     """
 
-    parameters: Dict[str, Any]
+    parameters: dict[str, Any]
     body: Any = NOT_SET
 
     def __hash__(self) -> int:
@@ -54,7 +54,7 @@ class StatefulTest:
     def parse(self, case: Case, response: GenericResponse) -> ParsedData:
         raise NotImplementedError
 
-    def make_operation(self, collected: List[ParsedData]) -> APIOperation:
+    def make_operation(self, collected: list[ParsedData]) -> APIOperation:
         raise NotImplementedError
 
 
@@ -63,7 +63,7 @@ class StatefulData:
     """Storage for data that will be used in later tests."""
 
     stateful_test: StatefulTest
-    container: List[ParsedData] = field(default_factory=list)
+    container: list[ParsedData] = field(default_factory=list)
 
     def make_operation(self) -> APIOperation:
         return self.stateful_test.make_operation(self.container)
@@ -81,9 +81,9 @@ class Feedback:
     Provides a way to control runner's behavior from tests.
     """
 
-    stateful: Optional[Stateful]
+    stateful: Stateful | None
     operation: APIOperation = field(repr=False)
-    stateful_tests: Dict[str, StatefulData] = field(default_factory=dict, repr=False)
+    stateful_tests: dict[str, StatefulData] = field(default_factory=dict, repr=False)
 
     def add_test_case(self, case: Case, response: GenericResponse) -> None:
         """Store test data to reuse it in the future additional tests."""
@@ -94,10 +94,11 @@ class Feedback:
     def get_stateful_tests(
         self,
         test: Callable,
-        settings: Optional[hypothesis.settings],
-        seed: Optional[int],
-        as_strategy_kwargs: Optional[Dict[str, Any]],
-    ) -> Generator[Result[Tuple[APIOperation, Callable], OperationSchemaError], None, None]:
+        settings: hypothesis.settings | None,
+        generation_config: GenerationConfig | None,
+        seed: int | None,
+        as_strategy_kwargs: dict[str, Any] | None,
+    ) -> Generator[Result[tuple[APIOperation, Callable], OperationSchemaError], None, None]:
         """Generate additional tests that use data from the previous ones."""
         from .._hypothesis import create_test
 
@@ -109,13 +110,14 @@ class Feedback:
                 settings=settings,
                 seed=seed,
                 data_generation_methods=operation.schema.data_generation_methods,
+                generation_config=generation_config,
                 as_strategy_kwargs=as_strategy_kwargs,
             )
             yield Ok((operation, test_function))
 
 
 def run_state_machine_as_test(
-    state_machine_factory: Type[APIStateMachine], *, settings: Optional[hypothesis.settings] = None
+    state_machine_factory: type[APIStateMachine], *, settings: hypothesis.settings | None = None
 ) -> None:
     """Run a state machine as a test.
 
@@ -123,7 +125,4 @@ def run_state_machine_as_test(
     """
     from hypothesis.stateful import run_state_machine_as_test as _run_state_machine_as_test
 
-    if IS_HYPOTHESIS_ABOVE_6_68_1:
-        # Newer Hypothesis contains an argument to set the minimum number of steps for a state machine execution
-        return _run_state_machine_as_test(state_machine_factory, settings=settings, _min_steps=2)
-    return _run_state_machine_as_test(state_machine_factory, settings=settings)
+    return _run_state_machine_as_test(state_machine_factory, settings=settings, _min_steps=2)

schemathesis/stateful/state_machine.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import time
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Optional, Callable, Tuple, ClassVar
+from typing import TYPE_CHECKING, Any, Callable, ClassVar
 
 from hypothesis.stateful import RuleBasedStateMachine
 
@@ -34,8 +34,8 @@ class APIStateMachine(RuleBasedStateMachine):
     # This is a convenience attribute, which happened to clash with `RuleBasedStateMachine` instance level attribute
     # They don't interfere, since it is properly overridden on the Hypothesis side, but it is likely that this
     # attribute will be renamed in the future
-    bundles: ClassVar[Dict[str, CaseInsensitiveDict]]  # type: ignore
-    schema: "BaseSchema"
+    bundles: ClassVar[dict[str, CaseInsensitiveDict]]  # type: ignore
+    schema: BaseSchema
 
     def __init__(self) -> None:
         super().__init__()  # type: ignore
@@ -53,7 +53,7 @@ class APIStateMachine(RuleBasedStateMachine):
         return super()._pretty_print(value)  # type: ignore
 
     @classmethod
-    def run(cls, *, settings: Optional[hypothesis.settings] = None) -> None:
+    def run(cls, *, settings: hypothesis.settings | None = None) -> None:
         """Run state machine as a test."""
         from . import run_state_machine_as_test
 
@@ -74,14 +74,14 @@ class APIStateMachine(RuleBasedStateMachine):
     def transform(self, result: StepResult, direction: Direction, case: Case) -> Case:
         raise NotImplementedError
 
-    def _step(self, case: Case, previous: Optional[Tuple[StepResult, Direction]] = None) -> StepResult:
+    def _step(self, case: Case, previous: tuple[StepResult, Direction] | None = None) -> StepResult:
         # This method is a proxy that is used under the hood during the state machine initialization.
         # The whole point of having it is to make it possible to override `step`; otherwise, custom "step" is ignored.
         # It happens because, at the point of initialization, the final class is not yet created.
         __tracebackhide__ = True
         return self.step(case, previous)
 
-    def step(self, case: Case, previous: Optional[Tuple[StepResult, Direction]] = None) -> StepResult:
+    def step(self, case: Case, previous: tuple[StepResult, Direction] | None = None) -> StepResult:
         """A single state machine step.
 
         :param Case case: Generated test case data that should be sent in an API call to the tested API operation.
@@ -177,7 +177,7 @@ class APIStateMachine(RuleBasedStateMachine):
         method = self._get_call_method(case)
         return method(**kwargs)
 
-    def get_call_kwargs(self, case: Case) -> Dict[str, Any]:
+    def get_call_kwargs(self, case: Case) -> dict[str, Any]:
         """Create custom keyword arguments that will be passed to the :meth:`Case.call` method.
 
         Mostly they are proxied to the :func:`requests.request` call.
@@ -204,7 +204,7 @@ class APIStateMachine(RuleBasedStateMachine):
         return case.call
 
     def validate_response(
-        self, response: GenericResponse, case: Case, additional_checks: Tuple[CheckFunction, ...] = ()
+        self, response: GenericResponse, case: Case, additional_checks: tuple[CheckFunction, ...] = ()
     ) -> None:
         """Validate an API response.
 
@@ -242,7 +242,7 @@ class APIStateMachine(RuleBasedStateMachine):
         return StepResult(response, case, elapsed)
 
 
-def _print_case(case: Case, kwargs: Dict[str, Any]) -> str:
+def _print_case(case: Case, kwargs: dict[str, Any]) -> str:
     from requests.structures import CaseInsensitiveDict
 
     operation = f"state.schema['{case.operation.path}']['{case.operation.method.upper()}']"

schemathesis/targets.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Callable, Tuple
+from typing import TYPE_CHECKING, Callable
 
 if TYPE_CHECKING:
     from .models import Case
@@ -16,7 +16,7 @@ class TargetContext:
     :ivar float response_time: API response time.
     """
 
-    case: "Case"
+    case: Case
     response: GenericResponse
     response_time: float
 
@@ -28,7 +28,7 @@ def response_time(context: TargetContext) -> float:
 Target = Callable[[TargetContext], float]
 DEFAULT_TARGETS = ()
 OPTIONAL_TARGETS = (response_time,)
-ALL_TARGETS: Tuple[Target, ...] = DEFAULT_TARGETS + OPTIONAL_TARGETS
+ALL_TARGETS: tuple[Target, ...] = DEFAULT_TARGETS + OPTIONAL_TARGETS
 
 
 def register(target: Target) -> Target:

schemathesis/throttling.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Tuple, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from .exceptions import UsageError
 
@@ -8,7 +8,7 @@ if TYPE_CHECKING:
     from pyrate_limiter import Limiter
 
 
-def parse_units(rate: str) -> Tuple[int, int]:
+def parse_units(rate: str) -> tuple[int, int]:
     from pyrate_limiter import Duration
 
     try:

schemathesis/transports/auth.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Optional, Union, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from ..types import RawAuth
 
@@ -7,7 +7,7 @@ if TYPE_CHECKING:
     from requests.auth import HTTPDigestAuth
 
 
-def get_requests_auth(auth: Optional[RawAuth], auth_type: Optional[str]) -> Optional[Union[HTTPDigestAuth, RawAuth]]:
+def get_requests_auth(auth: RawAuth | None, auth_type: str | None) -> HTTPDigestAuth | RawAuth | None:
     from requests.auth import HTTPDigestAuth
 
     if auth and auth_type == "digest":

schemathesis/transports/content_types.py

@@ -21,6 +21,11 @@ def is_json_media_type(value: str) -> bool:
     return main == "application" and (sub == "json" or sub.endswith("+json"))
 
 
+def is_yaml_media_type(value: str) -> bool:
+    """Detect whether the content type is YAML-compatible."""
+    return value in ("text/yaml", "text/x-yaml", "application/x-yaml", "text/vnd.yaml")
+
+
 def is_plain_text_media_type(value: str) -> bool:
     """Detect variations of the ``text/plain`` media type."""
     return parse_content_type(value) == ("text", "plain")

schemathesis/transports/headers.py

@@ -1,10 +1,11 @@
+from __future__ import annotations
 import re
-from typing import Dict, Any
+from typing import Any
 
 from ..constants import USER_AGENT
 
 
-def setup_default_headers(kwargs: Dict[str, Any]) -> None:
+def setup_default_headers(kwargs: dict[str, Any]) -> None:
     headers = kwargs.setdefault("headers", {})
     if "user-agent" not in {header.lower() for header in headers}:
         kwargs["headers"]["User-Agent"] = USER_AGENT

schemathesis/transports/responses.py

@@ -58,7 +58,7 @@ def copy_response(response: GenericResponse) -> GenericResponse:
 
 def get_reason(status_code: int) -> str:
     if sys.version_info < (3, 9) and status_code == 418:
-        # Python 3.7 & 3.8 do not have 418 status in the `HTTPStatus` enum
+        # Python 3.8 does not have 418 status in the `HTTPStatus` enum
         return "I'm a Teapot"
 
     import http.client

schemathesis/utils.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import functools
 import operator
 from contextlib import contextmanager
@@ -5,12 +6,8 @@ from inspect import getfullargspec
 from typing import (
     Any,
     Callable,
-    Dict,
     Generator,
-    List,
     NoReturn,
-    Optional,
-    Tuple,
     Union,
 )
 
@@ -57,7 +54,7 @@ IGNORED_PATTERNS = (
 
 
 @contextmanager
-def capture_hypothesis_output() -> Generator[List[str], None, None]:
+def capture_hypothesis_output() -> Generator[list[str], None, None]:
     """Capture all output of Hypothesis into a list of strings.
 
     It allows us to have more granular control over Schemathesis output.
@@ -91,11 +88,11 @@ GIVEN_ARGS_MARKER = "_schemathesis_given_args"
 GIVEN_KWARGS_MARKER = "_schemathesis_given_kwargs"
 
 
-def get_given_args(func: GenericTest) -> Tuple:
+def get_given_args(func: GenericTest) -> tuple:
     return getattr(func, GIVEN_ARGS_MARKER, ())
 
 
-def get_given_kwargs(func: GenericTest) -> Dict[str, Any]:
+def get_given_kwargs(func: GenericTest) -> dict[str, Any]:
     return getattr(func, GIVEN_KWARGS_MARKER, {})
 
 
@@ -124,7 +121,7 @@ def given_proxy(*args: GivenInput, **kwargs: GivenInput) -> Callable[[GenericTes
     return wrapper
 
 
-def merge_given_args(func: GenericTest, args: Tuple, kwargs: Dict[str, Any]) -> Dict[str, Any]:
+def merge_given_args(func: GenericTest, args: tuple, kwargs: dict[str, Any]) -> dict[str, Any]:
     """Merge positional arguments to ``@schema.given`` into a dictionary with keyword arguments.
 
     Kwargs are modified inplace.
@@ -136,7 +133,7 @@ def merge_given_args(func: GenericTest, args: Tuple, kwargs: Dict[str, Any]) ->
     return kwargs
 
 
-def validate_given_args(func: GenericTest, args: Tuple, kwargs: Dict[str, Any]) -> Optional[Callable]:
+def validate_given_args(func: GenericTest, args: tuple, kwargs: dict[str, Any]) -> Callable | None:
     signature = get_signature(func)
     return is_invalid_test(func, signature, args, kwargs)  # type: ignore
 
@@ -150,7 +147,7 @@ def compose(*functions: Callable) -> Callable:
     return functools.reduce(lambda f, g: lambda x: f(g(x)), functions, noop)
 
 
-def combine_strategies(strategies: List[st.SearchStrategy]) -> st.SearchStrategy:
+def combine_strategies(strategies: list[st.SearchStrategy]) -> st.SearchStrategy:
     """Combine a list of strategies into a single one.
 
     If the input is `[a, b, c]`, then the result is equivalent to `a | b | c`.