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

schemathesis/extra/_aiohttp.py

@@ -1,5 +1,5 @@
+from __future__ import annotations
 import asyncio
-from typing import Optional
 
 from aiohttp import web
 
@@ -22,6 +22,6 @@ def _run_server(app: web.Application, port: int) -> None:
     loop.run_forever()
 
 
-def run_server(app: web.Application, port: Optional[int] = None, timeout: float = 0.05) -> int:
+def run_server(app: web.Application, port: int | None = None, timeout: float = 0.05) -> int:
     """Start a thread with the given aiohttp application."""
     return _server.run(_run_server, app=app, port=port, timeout=timeout)

schemathesis/extra/_flask.py

@@ -1,10 +1,10 @@
-from typing import Optional
+from __future__ import annotations
 
 from flask import Flask
 
 from . import _server
 
 
-def run_server(app: Flask, port: Optional[int] = None, timeout: float = 0.05) -> int:
+def run_server(app: Flask, port: int | None = None, timeout: float = 0.05) -> int:
     """Start a thread with the given aiohttp application."""
     return _server.run(app.run, port=port, timeout=timeout)

schemathesis/extra/_server.py

@@ -1,11 +1,12 @@
+from __future__ import annotations
 import threading
 from time import sleep
-from typing import Any, Callable, Optional
+from typing import Any, Callable
 
 from aiohttp.test_utils import unused_port
 
 
-def run(target: Callable, port: Optional[int] = None, timeout: float = 0.05, **kwargs: Any) -> int:
+def run(target: Callable, port: int | None = None, timeout: float = 0.05, **kwargs: Any) -> int:
     """Start a thread with the given aiohttp application."""
     if port is None:
         port = unused_port()

schemathesis/extra/pytest_plugin.py

@@ -1,6 +1,7 @@
+from __future__ import annotations
 from contextlib import contextmanager
 from functools import partial
-from typing import Any, Callable, Dict, Generator, List, Optional, Tuple, Type, TypeVar, cast
+from typing import Any, Callable, Generator, Type, TypeVar, cast
 
 import pytest
 from _pytest import fixtures, nodes
@@ -32,7 +33,7 @@ from ..utils import (
 T = TypeVar("T", bound=Node)
 
 
-def create(cls: Type[T], *args: Any, **kwargs: Any) -> T:
+def create(cls: type[T], *args: Any, **kwargs: Any) -> T:
     if IS_PYTEST_ABOVE_54:
         return cls.from_parent(*args, **kwargs)  # type: ignore
     return cls(*args, **kwargs)
@@ -43,7 +44,7 @@ class SchemathesisFunction(Function):
         self,
         *args: Any,
         test_func: Callable,
-        test_name: Optional[str] = None,
+        test_name: str | None = None,
         **kwargs: Any,
     ) -> None:
         super().__init__(*args, **kwargs)
@@ -62,11 +63,11 @@ class SchemathesisFunction(Function):
 
 class SchemathesisCase(PyCollector):
     def __init__(self, test_function: Callable, *args: Any, **kwargs: Any) -> None:
-        self.given_kwargs: Optional[Dict[str, Any]]
+        self.given_kwargs: dict[str, Any] | None
         given_args = get_given_args(test_function)
         given_kwargs = get_given_kwargs(test_function)
 
-        def _init_with_valid_test(_test_function: Callable, _args: Tuple, _kwargs: Dict[str, Any]) -> None:
+        def _init_with_valid_test(_test_function: Callable, _args: tuple, _kwargs: dict[str, Any]) -> None:
             self.test_function = _test_function
             self.is_invalid_test = False
             self.given_kwargs = merge_given_args(test_function, _args, _kwargs)
@@ -108,6 +109,7 @@ class SchemathesisCase(PyCollector):
                     test=self.test_function,
                     _given_kwargs=self.given_kwargs,
                     data_generation_methods=self.schemathesis_case.data_generation_methods,
+                    generation_config=self.schemathesis_case.generation_config,
                 )
             name = self._get_test_name(operation)
         else:
@@ -158,13 +160,11 @@ class SchemathesisCase(PyCollector):
                     test_func=self.test_function,
                 )
 
-    def _get_class_parent(self) -> Optional[Type]:
+    def _get_class_parent(self) -> type | None:
         clscol = self.getparent(Class)
         return clscol.obj if clscol else None
 
-    def _parametrize(
-        self, cls: Optional[Type], definition: FunctionDefinition, fixtureinfo: FuncFixtureInfo
-    ) -> Metafunc:
+    def _parametrize(self, cls: type | None, definition: FunctionDefinition, fixtureinfo: FuncFixtureInfo) -> Metafunc:
         parent = self.getparent(Module)
         module = parent.obj if parent is not None else parent
         kwargs = {"cls": cls, "module": module}
@@ -181,7 +181,7 @@ class SchemathesisCase(PyCollector):
         self.ihook.pytest_generate_tests.call_extra(methods, {"metafunc": metafunc})
         return metafunc
 
-    def collect(self) -> List[Function]:  # type: ignore
+    def collect(self) -> list[Function]:  # type: ignore
         """Generate different test items for all API operations available in the given schema."""
         try:
             items = [

schemathesis/failures.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 import textwrap
 from dataclasses import dataclass
 from json import JSONDecodeError
-from typing import Any, Dict, List, Optional, Tuple, Union, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from jsonschema import ValidationError
@@ -17,7 +17,7 @@ class FailureContext:
     message: str
     type: str
 
-    def unique_by_key(self, check_message: Optional[str]) -> Tuple[str, ...]:
+    def unique_by_key(self, check_message: str | None) -> tuple[str, ...]:
         """A key to distinguish different failure contexts."""
         return (check_message or self.message,)
 
@@ -27,20 +27,20 @@ class ValidationErrorContext(FailureContext):
     """Additional information about JSON Schema validation errors."""
 
     validation_message: str
-    schema_path: List[Union[str, int]]
-    schema: Union[Dict[str, Any], bool]
-    instance_path: List[Union[str, int]]
-    instance: Union[None, bool, float, str, list, Dict[str, Any]]
+    schema_path: list[str | int]
+    schema: dict[str, Any] | bool
+    instance_path: list[str | int]
+    instance: None | bool | float | str | list | dict[str, Any]
     message: str
     title: str = "Response violates schema"
     type: str = "json_schema"
 
-    def unique_by_key(self, check_message: Optional[str]) -> Tuple[str, ...]:
+    def unique_by_key(self, check_message: str | None) -> tuple[str, ...]:
         # Deduplicate by JSON Schema path. All errors that happened on this sub-schema will be deduplicated
         return ("/".join(map(str, self.schema_path)),)
 
     @classmethod
-    def from_exception(cls, exc: "ValidationError") -> "ValidationErrorContext":
+    def from_exception(cls, exc: ValidationError) -> ValidationErrorContext:
         from .exceptions import truncated_json
 
         schema = textwrap.indent(truncated_json(exc.schema, max_lines=20), prefix="    ")
@@ -69,14 +69,14 @@ class JSONDecodeErrorContext(FailureContext):
     title: str = "JSON deserialization error"
     type: str = "json_decode"
 
-    def unique_by_key(self, check_message: Optional[str]) -> Tuple[str, ...]:
+    def unique_by_key(self, check_message: str | None) -> tuple[str, ...]:
         # Treat different JSON decoding failures as the same issue
         # Payloads often contain dynamic data and distinguishing it by the error location still would not be sufficient
         # as it may be different on different dynamic payloads
         return (self.title,)
 
     @classmethod
-    def from_exception(cls, exc: JSONDecodeError) -> "JSONDecodeErrorContext":
+    def from_exception(cls, exc: JSONDecodeError) -> JSONDecodeErrorContext:
         return cls(
             message=str(exc),
             validation_message=exc.msg,
@@ -99,7 +99,7 @@ class ServerError(FailureContext):
 class MissingContentType(FailureContext):
     """Content type header is missing."""
 
-    media_types: List[str]
+    media_types: list[str]
     message: str
     title: str = "Missing Content-Type header"
     type: str = "missing_content_type"
@@ -110,7 +110,7 @@ class UndefinedContentType(FailureContext):
     """Response has Content-Type that is not documented in the schema."""
 
     content_type: str
-    defined_content_types: List[str]
+    defined_content_types: list[str]
     message: str
     title: str = "Undocumented Content-Type"
     type: str = "undefined_content_type"
@@ -123,9 +123,9 @@ class UndefinedStatusCode(FailureContext):
     # Response's status code
     status_code: int
     # Status codes as defined in schema
-    defined_status_codes: List[str]
+    defined_status_codes: list[str]
     # Defined status code with expanded wildcards
-    allowed_status_codes: List[int]
+    allowed_status_codes: list[int]
     message: str
     title: str = "Undocumented HTTP status code"
     type: str = "undefined_status_code"
@@ -135,7 +135,7 @@ class UndefinedStatusCode(FailureContext):
 class MissingHeaders(FailureContext):
     """Some required headers are missing."""
 
-    missing_headers: List[str]
+    missing_headers: list[str]
     message: str
     title: str = "Missing required headers"
     type: str = "missing_headers"
@@ -165,7 +165,7 @@ class ResponseTimeExceeded(FailureContext):
     title: str = "Response time limit exceeded"
     type: str = "response_time_exceeded"
 
-    def unique_by_key(self, check_message: Optional[str]) -> Tuple[str, ...]:
+    def unique_by_key(self, check_message: str | None) -> tuple[str, ...]:
         return (self.title,)
 
 

schemathesis/filters.py

@@ -1,11 +1,10 @@
 """Filtering system that allows users to filter API operations based on certain criteria."""
+from __future__ import annotations
 import re
 from dataclasses import dataclass, field
 from functools import partial
 from types import SimpleNamespace
-from typing import TYPE_CHECKING, Callable, List, Optional, Set, Tuple, Union
-
-from typing_extensions import Protocol
+from typing import TYPE_CHECKING, Callable, List, Union, Protocol
 
 from .exceptions import UsageError
 
@@ -14,7 +13,7 @@ if TYPE_CHECKING:
 
 
 class HasAPIOperation(Protocol):
-    operation: "APIOperation"
+    operation: APIOperation
 
 
 MatcherFunc = Callable[[HasAPIOperation], bool]
@@ -39,12 +38,12 @@ class Matcher:
         return f"<{self.__class__.__name__}: {self.label}>"
 
     @classmethod
-    def for_function(cls, func: MatcherFunc) -> "Matcher":
+    def for_function(cls, func: MatcherFunc) -> Matcher:
         """Matcher that uses the given function for matching operations."""
         return cls(func, label=func.__name__, _hash=hash(func))
 
     @classmethod
-    def for_value(cls, attribute: str, expected: FilterValue) -> "Matcher":
+    def for_value(cls, attribute: str, expected: FilterValue) -> Matcher:
         """Matcher that checks whether the specified attribute has the expected value."""
         if isinstance(expected, list):
             func = partial(by_value_list, attribute=attribute, expected=expected)
@@ -54,7 +53,7 @@ class Matcher:
         return cls(func, label=label, _hash=hash(label))
 
     @classmethod
-    def for_regex(cls, attribute: str, regex: RegexValue) -> "Matcher":
+    def for_regex(cls, attribute: str, regex: RegexValue) -> Matcher:
         """Matcher that checks whether the specified attribute has the provided regex."""
         if isinstance(regex, str):
             regex = re.compile(regex)
@@ -67,7 +66,7 @@ class Matcher:
         return self.func(ctx)
 
 
-def get_operation_attribute(operation: "APIOperation", attribute: str) -> str:
+def get_operation_attribute(operation: APIOperation, attribute: str) -> str:
     # Just uppercase `method`
     value = getattr(operation, attribute)
     if attribute == "method":
@@ -79,7 +78,7 @@ def by_value(ctx: HasAPIOperation, attribute: str, expected: str) -> bool:
     return get_operation_attribute(ctx.operation, attribute) == expected
 
 
-def by_value_list(ctx: HasAPIOperation, attribute: str, expected: List[str]) -> bool:
+def by_value_list(ctx: HasAPIOperation, attribute: str, expected: list[str]) -> bool:
     return get_operation_attribute(ctx.operation, attribute) in expected
 
 
@@ -92,7 +91,7 @@ def by_regex(ctx: HasAPIOperation, attribute: str, regex: re.Pattern) -> bool:
 class Filter:
     """Match API operations against a list of matchers."""
 
-    matchers: Tuple[Matcher, ...]
+    matchers: tuple[Matcher, ...]
 
     def __repr__(self) -> str:
         inner = " && ".join(matcher.label for matcher in self.matchers)
@@ -110,10 +109,10 @@ class Filter:
 class FilterSet:
     """Combines multiple filters to apply inclusion and exclusion rules on API operations."""
 
-    _includes: Set[Filter] = field(default_factory=set)
-    _excludes: Set[Filter] = field(default_factory=set)
+    _includes: set[Filter] = field(default_factory=set)
+    _excludes: set[Filter] = field(default_factory=set)
 
-    def apply_to(self, operations: List["APIOperation"]) -> List["APIOperation"]:
+    def apply_to(self, operations: list[APIOperation]) -> list[APIOperation]:
         """Get a filtered list of the given operations that match the filters."""
         return [operation for operation in operations if self.match(SimpleNamespace(operation=operation))]
 
@@ -141,14 +140,14 @@ class FilterSet:
 
     def include(
         self,
-        func: Optional[MatcherFunc] = None,
+        func: MatcherFunc | None = None,
         *,
-        name: Optional[FilterValue] = None,
-        name_regex: Optional[RegexValue] = None,
-        method: Optional[FilterValue] = None,
-        method_regex: Optional[RegexValue] = None,
-        path: Optional[FilterValue] = None,
-        path_regex: Optional[RegexValue] = None,
+        name: FilterValue | None = None,
+        name_regex: RegexValue | None = None,
+        method: FilterValue | None = None,
+        method_regex: RegexValue | None = None,
+        path: FilterValue | None = None,
+        path_regex: RegexValue | None = None,
     ) -> None:
         """Add a new INCLUDE filter."""
         self._add_filter(
@@ -164,14 +163,14 @@ class FilterSet:
 
     def exclude(
         self,
-        func: Optional[MatcherFunc] = None,
+        func: MatcherFunc | None = None,
         *,
-        name: Optional[FilterValue] = None,
-        name_regex: Optional[RegexValue] = None,
-        method: Optional[FilterValue] = None,
-        method_regex: Optional[RegexValue] = None,
-        path: Optional[FilterValue] = None,
-        path_regex: Optional[RegexValue] = None,
+        name: FilterValue | None = None,
+        name_regex: RegexValue | None = None,
+        method: FilterValue | None = None,
+        method_regex: RegexValue | None = None,
+        path: FilterValue | None = None,
+        path_regex: RegexValue | None = None,
     ) -> None:
         """Add a new EXCLUDE filter."""
         self._add_filter(
@@ -189,13 +188,13 @@ class FilterSet:
         self,
         include: bool,
         *,
-        func: Optional[MatcherFunc] = None,
-        name: Optional[FilterValue] = None,
-        name_regex: Optional[RegexValue] = None,
-        method: Optional[FilterValue] = None,
-        method_regex: Optional[RegexValue] = None,
-        path: Optional[FilterValue] = None,
-        path_regex: Optional[RegexValue] = None,
+        func: MatcherFunc | None = None,
+        name: FilterValue | None = None,
+        name_regex: RegexValue | None = None,
+        method: FilterValue | None = None,
+        method_regex: RegexValue | None = None,
+        path: FilterValue | None = None,
+        path_regex: RegexValue | None = None,
     ) -> None:
         matchers = []
         if func is not None:
@@ -242,14 +241,14 @@ def attach_filter_chain(
     """
 
     def proxy(
-        func: Optional[MatcherFunc] = None,
+        func: MatcherFunc | None = None,
         *,
-        name: Optional[FilterValue] = None,
-        name_regex: Optional[str] = None,
-        method: Optional[FilterValue] = None,
-        method_regex: Optional[str] = None,
-        path: Optional[FilterValue] = None,
-        path_regex: Optional[str] = None,
+        name: FilterValue | None = None,
+        name_regex: str | None = None,
+        method: FilterValue | None = None,
+        method_regex: str | None = None,
+        path: FilterValue | None = None,
+        path_regex: str | None = None,
     ) -> Callable:
         __tracebackhide__ = True
         filter_func(

schemathesis/fixups/__init__.py

@@ -1,4 +1,5 @@
-from typing import Iterable, Optional
+from __future__ import annotations
+from typing import Iterable
 
 from . import fast_api, utf8_bom
 
@@ -6,7 +7,7 @@ ALL_FIXUPS = {"fast_api": fast_api, "utf8_bom": utf8_bom}
 ALL_FIXUP_NAMES = list(ALL_FIXUPS.keys())
 
 
-def install(fixups: Optional[Iterable[str]] = None) -> None:
+def install(fixups: Iterable[str] | None = None) -> None:
     """Install fixups.
 
     Without the first argument installs all available fixups.
@@ -18,7 +19,7 @@ def install(fixups: Optional[Iterable[str]] = None) -> None:
         ALL_FIXUPS[name].install()  # type: ignore
 
 
-def uninstall(fixups: Optional[Iterable[str]] = None) -> None:
+def uninstall(fixups: Iterable[str] | None = None) -> None:
     """Uninstall fixups.
 
     Without the first argument uninstalls all available fixups.

schemathesis/fixups/fast_api.py

@@ -1,4 +1,5 @@
-from typing import Any, Dict
+from __future__ import annotations
+from typing import Any
 
 from ..hooks import HookContext
 from ..hooks import is_installed as global_is_installed
@@ -18,15 +19,15 @@ def is_installed() -> bool:
     return global_is_installed("before_load_schema", before_load_schema)
 
 
-def before_load_schema(context: HookContext, schema: Dict[str, Any]) -> None:
+def before_load_schema(context: HookContext, schema: dict[str, Any]) -> None:
     adjust_schema(schema)
 
 
-def adjust_schema(schema: Dict[str, Any]) -> None:
+def adjust_schema(schema: dict[str, Any]) -> None:
     traverse_schema(schema, _handle_boundaries)
 
 
-def _handle_boundaries(schema: Dict[str, Any]) -> Dict[str, Any]:
+def _handle_boundaries(schema: dict[str, Any]) -> dict[str, Any]:
     """Convert Draft 7 keywords to Draft 4 compatible versions.
 
     FastAPI uses ``pydantic``, which generates Draft 7 compatible schemas.

schemathesis/generation/__init__.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
 import random
+from dataclasses import dataclass
 from enum import Enum
-from typing import List, Union, Iterable
+from typing import Union, Iterable
 
 
 class DataGenerationMethod(str, Enum):
@@ -12,11 +14,11 @@ class DataGenerationMethod(str, Enum):
     negative = "negative"
 
     @classmethod
-    def default(cls) -> "DataGenerationMethod":
+    def default(cls) -> DataGenerationMethod:
         return cls.positive
 
     @classmethod
-    def all(cls) -> List["DataGenerationMethod"]:
+    def all(cls) -> list[DataGenerationMethod]:
         return list(DataGenerationMethod)
 
     def as_short_name(self) -> str:
@@ -30,7 +32,7 @@ class DataGenerationMethod(str, Enum):
         return self == DataGenerationMethod.negative
 
     @classmethod
-    def ensure_list(cls, value: "DataGenerationMethodInput") -> List["DataGenerationMethod"]:
+    def ensure_list(cls, value: DataGenerationMethodInput) -> list[DataGenerationMethod]:
         if isinstance(value, DataGenerationMethod):
             return [value]
         return list(value)
@@ -54,3 +56,13 @@ def generate_random_case_id(length: int = 6) -> str:
         number, rem = divmod(number, BASE)
         output += CASE_ID_ALPHABET[rem]
     return output
+
+
+@dataclass
+class GenerationConfig:
+    """Holds various configuration options relevant for data generation."""
+
+    # Allow generating `\x00` bytes in strings
+    allow_x00: bool = True
+    # Generate strings using the given codec
+    codec: str | None = "utf-8"

schemathesis/hooks.py

@@ -5,7 +5,7 @@ from copy import deepcopy
 from dataclasses import dataclass, field
 from enum import Enum, unique
 from functools import partial
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, DefaultDict, Dict, List, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, DefaultDict, cast
 
 from .types import GenericTest
 from .internal.deprecation import deprecated_property
@@ -27,7 +27,7 @@ class HookScope(Enum):
 @dataclass
 class RegisteredHook:
     signature: inspect.Signature
-    scopes: List[HookScope]
+    scopes: list[HookScope]
 
 
 @dataclass
@@ -38,10 +38,10 @@ class HookContext:
                                             Might be absent in some cases.
     """
 
-    operation: Optional["APIOperation"] = None
+    operation: APIOperation | None = None
 
     @deprecated_property(removed_in="4.0", replacement="operation")
-    def endpoint(self) -> Optional["APIOperation"]:
+    def endpoint(self) -> APIOperation | None:
         return self.operation
 
 
@@ -53,10 +53,10 @@ class HookDispatcher:
     """
 
     scope: HookScope
-    _hooks: DefaultDict[str, List[Callable]] = field(default_factory=lambda: defaultdict(list))
-    _specs: ClassVar[Dict[str, RegisteredHook]] = {}
+    _hooks: DefaultDict[str, list[Callable]] = field(default_factory=lambda: defaultdict(list))
+    _specs: ClassVar[dict[str, RegisteredHook]] = {}
 
-    def register(self, hook: Union[str, Callable]) -> Callable:
+    def register(self, hook: str | Callable) -> Callable:
         """Register a new hook.
 
         :param hook: Either a hook function or a string.
@@ -87,7 +87,7 @@ class HookDispatcher:
             return decorator
         return self.register_hook_with_name(hook, hook.__name__)
 
-    def merge(self, other: "HookDispatcher") -> "HookDispatcher":
+    def merge(self, other: HookDispatcher) -> HookDispatcher:
         """Merge two dispatches together.
 
         The resulting dispatcher will call the `self` hooks first.
@@ -99,7 +99,7 @@ class HookDispatcher:
         instance._hooks = all_hooks
         return instance
 
-    def apply(self, hook: Callable, *, name: Optional[str] = None) -> Callable[[Callable], Callable]:
+    def apply(self, hook: Callable, *, name: str | None = None) -> Callable[[Callable], Callable]:
         """Register hook to run only on one test function.
 
         :param hook: A hook function.
@@ -130,7 +130,7 @@ class HookDispatcher:
         return decorator
 
     @classmethod
-    def add_dispatcher(cls, func: GenericTest) -> "HookDispatcher":
+    def add_dispatcher(cls, func: GenericTest) -> HookDispatcher:
         """Attach a new dispatcher instance to the test if it is not already present."""
         if not hasattr(func, "_schemathesis_hooks"):
             func._schemathesis_hooks = cls(scope=HookScope.TEST)  # type: ignore
@@ -143,7 +143,7 @@ class HookDispatcher:
         return hook
 
     @classmethod
-    def register_spec(cls, scopes: List[HookScope]) -> Callable:
+    def register_spec(cls, scopes: list[HookScope]) -> Callable:
         """Register hook specification.
 
         All hooks, registered with `register` should comply with corresponding registered specs.
@@ -173,10 +173,10 @@ class HookDispatcher:
                 f"Hook '{name}' takes {len(spec.signature.parameters)} arguments but {len(signature.parameters)} is defined"
             )
 
-    def collect_statistic(self) -> Dict[str, int]:
+    def collect_statistic(self) -> dict[str, int]:
         return {name: len(hooks) for name, hooks in self._hooks.items()}
 
-    def get_all_by_name(self, name: str) -> List[Callable]:
+    def get_all_by_name(self, name: str) -> list[Callable]:
         """Get a list of hooks registered for a name."""
         return self._hooks.get(name, [])
 
@@ -225,9 +225,9 @@ class HookDispatcher:
 
 
 def apply_to_all_dispatchers(
-    operation: "APIOperation",
+    operation: APIOperation,
     context: HookContext,
-    hooks: Optional[HookDispatcher],
+    hooks: HookDispatcher | None,
     strategy: st.SearchStrategy,
     container: str,
 ) -> st.SearchStrategy:
@@ -287,32 +287,32 @@ def before_generate_body(context: HookContext, strategy: st.SearchStrategy) -> s
 
 
 @all_scopes
-def before_generate_case(context: HookContext, strategy: st.SearchStrategy["Case"]) -> st.SearchStrategy["Case"]:
+def before_generate_case(context: HookContext, strategy: st.SearchStrategy[Case]) -> st.SearchStrategy[Case]:
     """Called on a strategy that generates ``Case`` instances."""
 
 
 @all_scopes
-def before_process_path(context: HookContext, path: str, methods: Dict[str, Any]) -> None:
+def before_process_path(context: HookContext, path: str, methods: dict[str, Any]) -> None:
     """Called before API path is processed."""
 
 
 @all_scopes
-def filter_operations(context: HookContext) -> Optional[bool]:
+def filter_operations(context: HookContext) -> bool | None:
     """Decide whether testing of this particular API operation should be skipped or not."""
 
 
 @HookDispatcher.register_spec([HookScope.GLOBAL])
-def before_load_schema(context: HookContext, raw_schema: Dict[str, Any]) -> None:
+def before_load_schema(context: HookContext, raw_schema: dict[str, Any]) -> None:
     """Called before schema instance is created."""
 
 
 @HookDispatcher.register_spec([HookScope.GLOBAL])
-def after_load_schema(context: HookContext, schema: "BaseSchema") -> None:
+def after_load_schema(context: HookContext, schema: BaseSchema) -> None:
     """Called after schema instance is created."""
 
 
 @all_scopes
-def before_add_examples(context: HookContext, examples: List["Case"]) -> None:
+def before_add_examples(context: HookContext, examples: list[Case]) -> None:
     """Called before explicit examples are added to a test via `@example` decorator.
 
     `examples` is a list that could be extended with examples provided by the user.
@@ -320,12 +320,12 @@ def before_add_examples(context: HookContext, examples: List["Case"]) -> None:
 
 
 @all_scopes
-def before_init_operation(context: HookContext, operation: "APIOperation") -> None:
+def before_init_operation(context: HookContext, operation: APIOperation) -> None:
     """Allows you to customize a newly created API operation."""
 
 
 @HookDispatcher.register_spec([HookScope.GLOBAL])
-def add_case(context: HookContext, case: "Case", response: GenericResponse) -> Optional["Case"]:
+def add_case(context: HookContext, case: Case, response: GenericResponse) -> Case | None:
     """Creates an additional test per API operation. If this hook returns None, no additional test created.
 
     Called with a copy of the original case object and the server's response to the original case.
@@ -333,7 +333,7 @@ def add_case(context: HookContext, case: "Case", response: GenericResponse) -> O
 
 
 @HookDispatcher.register_spec([HookScope.GLOBAL])
-def before_call(context: HookContext, case: "Case") -> None:
+def before_call(context: HookContext, case: Case) -> None:
     """Called before every network call in CLI tests.
 
     Use cases:
@@ -343,7 +343,7 @@ def before_call(context: HookContext, case: "Case") -> None:
 
 
 @HookDispatcher.register_spec([HookScope.GLOBAL])
-def after_call(context: HookContext, case: "Case", response: GenericResponse) -> None:
+def after_call(context: HookContext, case: Case, response: GenericResponse) -> None:
     """Called after every network call in CLI tests.
 
     Note that you need to modify the response in-place.