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

schemathesis/__init__.py

@@ -3,7 +3,7 @@ from typing import Any
 
 from . import auths, checks, experimental, contrib, fixups, graphql, hooks, runner, serializers, targets  # noqa: E402
 from ._lazy_import import lazy_import
-from .generation import DataGenerationMethod  # noqa: E402
+from .generation import DataGenerationMethod, GenerationConfig  # noqa: E402
 from .constants import SCHEMATHESIS_VERSION  # noqa: E402
 from .models import Case  # noqa: E402
 from .specs import openapi  # noqa: E402

schemathesis/_compat.py

@@ -1,11 +1,6 @@
 from typing import Any, Type, Callable
 from ._lazy_import import lazy_import
 
-try:
-    from importlib import metadata
-except ImportError:
-    import importlib_metadata as metadata  # type: ignore
-
 
 __all__ = [  # noqa: F822
     "JSONMixin",
@@ -13,7 +8,6 @@ __all__ = [  # noqa: F822
     "MultipleFailures",
     "get_signature",
     "get_interesting_origin",
-    "metadata",
     "_install_hypothesis_jsonschema_compatibility_shim",
 ]
 
@@ -52,26 +46,16 @@ def _load_get_interesting_origin() -> Callable:
 
 
 def _load_multiple_failures() -> Type:
-    from ._dependency_versions import IS_HYPOTHESIS_ABOVE_6_54
-
     try:
         return BaseExceptionGroup  # type: ignore
     except NameError:
-        if IS_HYPOTHESIS_ABOVE_6_54:
-            from exceptiongroup import BaseExceptionGroup as MultipleFailures  # type: ignore
-        else:
-            from hypothesis.errors import MultipleFailures  # type: ignore
+        from exceptiongroup import BaseExceptionGroup as MultipleFailures  # type: ignore
 
         return MultipleFailures
 
 
 def _load_get_signature() -> Callable:
-    from ._dependency_versions import IS_HYPOTHESIS_ABOVE_6_49
-
-    if IS_HYPOTHESIS_ABOVE_6_49:
-        from hypothesis.internal.reflection import get_signature
-    else:
-        from inspect import getfullargspec as get_signature
+    from hypothesis.internal.reflection import get_signature
 
     return get_signature
 

schemathesis/_dependency_versions.py

@@ -1,18 +1,13 @@
 """Compatibility flags based on installed dependency versions."""
 from packaging import version
 
-from ._compat import metadata
+from importlib import metadata
 
 
 WERKZEUG_VERSION = version.parse(metadata.version("werkzeug"))
 IS_WERKZEUG_ABOVE_3 = WERKZEUG_VERSION >= version.parse("3.0")
 IS_WERKZEUG_BELOW_2_1 = WERKZEUG_VERSION < version.parse("2.1.0")
 
-HYPOTHESIS_VERSION = version.parse(metadata.version("hypothesis"))
-IS_HYPOTHESIS_ABOVE_6_49 = HYPOTHESIS_VERSION >= version.parse("6.49.0")
-IS_HYPOTHESIS_ABOVE_6_54 = HYPOTHESIS_VERSION >= version.parse("6.54.0")
-IS_HYPOTHESIS_ABOVE_6_68_1 = HYPOTHESIS_VERSION >= version.parse("6.68.1")
-
 PYTEST_VERSION = version.parse(metadata.version("pytest"))
 IS_PYTEST_ABOVE_54 = PYTEST_VERSION >= version.parse("5.4.0")
 IS_PYTEST_ABOVE_7 = PYTEST_VERSION >= version.parse("7.0.0")

schemathesis/_hypothesis.py

@@ -1,7 +1,8 @@
 """High-level API for creating Hypothesis tests."""
+from __future__ import annotations
 import asyncio
 import warnings
-from typing import Any, Callable, Dict, List, Optional, Tuple
+from typing import Any, Callable
 
 import hypothesis
 from hypothesis import Phase
@@ -11,7 +12,7 @@ from hypothesis.internal.reflection import proxies
 from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
 
 from .auths import get_auth_storage_from_test
-from .generation import DataGenerationMethod
+from .generation import DataGenerationMethod, GenerationConfig
 from .constants import DEFAULT_DEADLINE
 from .exceptions import OperationSchemaError
 from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher
@@ -23,12 +24,13 @@ def create_test(
     *,
     operation: APIOperation,
     test: Callable,
-    settings: Optional[hypothesis.settings] = None,
-    seed: Optional[int] = None,
-    data_generation_methods: List[DataGenerationMethod],
-    as_strategy_kwargs: Optional[Dict[str, Any]] = None,
-    _given_args: Tuple[GivenInput, ...] = (),
-    _given_kwargs: Optional[Dict[str, GivenInput]] = None,
+    settings: hypothesis.settings | None = None,
+    seed: int | None = None,
+    data_generation_methods: list[DataGenerationMethod],
+    generation_config: GenerationConfig | None = None,
+    as_strategy_kwargs: dict[str, Any] | None = None,
+    _given_args: tuple[GivenInput, ...] = (),
+    _given_kwargs: dict[str, GivenInput] | None = None,
 ) -> Callable:
     """Create a Hypothesis test."""
     hook_dispatcher = getattr(test, "_schemathesis_hooks", None)
@@ -40,6 +42,7 @@ def create_test(
                 hooks=hook_dispatcher,
                 auth_storage=auth_storage,
                 data_generation_method=data_generation_method,
+                generation_config=generation_config,
                 **(as_strategy_kwargs or {}),
             )
         )
@@ -92,7 +95,7 @@ def remove_explain_phase(settings: hypothesis.settings) -> hypothesis.settings:
     return settings
 
 
-def _get_hypothesis_settings(test: Callable) -> Optional[hypothesis.settings]:
+def _get_hypothesis_settings(test: Callable) -> hypothesis.settings | None:
     return getattr(test, "_hypothesis_internal_use_settings", None)
 
 
@@ -106,10 +109,10 @@ def make_async_test(test: Callable) -> Callable:
     return async_run
 
 
-def add_examples(test: Callable, operation: APIOperation, hook_dispatcher: Optional[HookDispatcher] = None) -> Callable:
+def add_examples(test: Callable, operation: APIOperation, hook_dispatcher: HookDispatcher | None = None) -> Callable:
     """Add examples to the Hypothesis test, if they are specified in the schema."""
     try:
-        examples: List[Case] = [get_single_example(strategy) for strategy in operation.get_strategies_from_examples()]
+        examples: list[Case] = [get_single_example(strategy) for strategy in operation.get_strategies_from_examples()]
     except (OperationSchemaError, HypothesisRefResolutionError, Unsatisfiable):
         # Invalid schema:
         # In this case, the user didn't pass `--validate-schema=false` and see an error in the output anyway,
@@ -143,6 +146,6 @@ def get_single_example(strategy: st.SearchStrategy[Case]) -> Case:
     def example_generating_inner_function(ex: Case) -> None:
         examples.append(ex)
 
-    examples: List[Case] = []
+    examples: list[Case] = []
     example_generating_inner_function()
     return examples[0]

schemathesis/_lazy_import.py

@@ -1,7 +1,8 @@
-from typing import Dict, Any, Callable
+from __future__ import annotations
+from typing import Any, Callable
 
 
-def lazy_import(module: str, name: str, imports: Dict[str, Callable[[], Any]], _globals: Dict[str, Any]) -> Any:
+def lazy_import(module: str, name: str, imports: dict[str, Callable[[], Any]], _globals: dict[str, Any]) -> Any:
     value = _globals.get(name)
     if value is not None:
         return value

schemathesis/_xml.py

@@ -1,4 +1,5 @@
 """XML serialization."""
+from __future__ import annotations
 from io import StringIO
 from typing import Any, Dict, List, Union
 from xml.etree import ElementTree
@@ -12,7 +13,7 @@ DEFAULT_TAG_NAME = "data"
 NAMESPACE_URL = "http://example.com/schema"
 
 
-def _to_xml(value: Any, raw_schema: Dict[str, Any], resolved_schema: Dict[str, Any]) -> Dict[str, Any]:
+def _to_xml(value: Any, raw_schema: dict[str, Any], resolved_schema: dict[str, Any]) -> dict[str, Any]:
     """Serialize a generated Python object as an XML string.
 
     Schemas may contain additional information for fine-tuned XML serialization.
@@ -26,7 +27,7 @@ def _to_xml(value: Any, raw_schema: Dict[str, Any], resolved_schema: Dict[str, A
     tag = _get_xml_tag(raw_schema, resolved_schema)
     buffer = StringIO()
     # Collect all namespaces to ensure that all child nodes with prefixes have proper namespaces in their parent nodes
-    namespace_stack: List[str] = []
+    namespace_stack: list[str] = []
     _write_xml(buffer, value, tag, resolved_schema, namespace_stack)
     data = buffer.getvalue()
     if not is_valid_xml(data):
@@ -47,7 +48,7 @@ def is_valid_xml(data: str) -> bool:
         return False
 
 
-def _get_xml_tag(raw_schema: Dict[str, Any], resolved_schema: Dict[str, Any]) -> str:
+def _get_xml_tag(raw_schema: dict[str, Any], resolved_schema: dict[str, Any]) -> str:
     # On the top level we need to detect the proper XML tag, in other cases it is known from object properties
     if resolved_schema.get("xml", {}).get("name"):
         return resolved_schema["xml"]["name"]
@@ -60,7 +61,7 @@ def _get_xml_tag(raw_schema: Dict[str, Any], resolved_schema: Dict[str, Any]) ->
     return DEFAULT_TAG_NAME
 
 
-def _write_xml(buffer: StringIO, value: JSON, tag: str, schema: Dict[str, Any], namespace_stack: List[str]) -> None:
+def _write_xml(buffer: StringIO, value: JSON, tag: str, schema: dict[str, Any], namespace_stack: list[str]) -> None:
     if isinstance(value, dict):
         _write_object(buffer, value, tag, schema, namespace_stack)
     elif isinstance(value, list):
@@ -69,7 +70,7 @@ def _write_xml(buffer: StringIO, value: JSON, tag: str, schema: Dict[str, Any],
         _write_primitive(buffer, value, tag, schema, namespace_stack)
 
 
-def _validate_prefix(options: Dict[str, Any], namespace_stack: List[str]) -> None:
+def _validate_prefix(options: dict[str, Any], namespace_stack: list[str]) -> None:
     try:
         prefix = options["prefix"]
         if prefix not in namespace_stack:
@@ -78,17 +79,17 @@ def _validate_prefix(options: Dict[str, Any], namespace_stack: List[str]) -> Non
         pass
 
 
-def push_namespace_if_any(namespace_stack: List[str], options: Dict[str, Any]) -> None:
+def push_namespace_if_any(namespace_stack: list[str], options: dict[str, Any]) -> None:
     if "namespace" in options and "prefix" in options:
         namespace_stack.append(options["prefix"])
 
 
-def pop_namespace_if_any(namespace_stack: List[str], options: Dict[str, Any]) -> None:
+def pop_namespace_if_any(namespace_stack: list[str], options: dict[str, Any]) -> None:
     if "namespace" in options and "prefix" in options:
         namespace_stack.pop()
 
 
-def _write_object(buffer: StringIO, obj: Dict[str, JSON], tag: str, schema: Dict[str, Any], stack: List[str]) -> None:
+def _write_object(buffer: StringIO, obj: dict[str, JSON], tag: str, schema: dict[str, Any], stack: list[str]) -> None:
     options = schema.get("xml", {})
     push_namespace_if_any(stack, options)
     if "prefix" in options:
@@ -122,7 +123,7 @@ def _write_object(buffer: StringIO, obj: Dict[str, JSON], tag: str, schema: Dict
     pop_namespace_if_any(stack, options)
 
 
-def _write_array(buffer: StringIO, obj: List[JSON], tag: str, schema: Dict[str, Any], stack: List[str]) -> None:
+def _write_array(buffer: StringIO, obj: list[JSON], tag: str, schema: dict[str, Any], stack: list[str]) -> None:
     options = schema.get("xml", {})
     push_namespace_if_any(stack, options)
     if options.get("prefix"):
@@ -153,7 +154,7 @@ def _write_array(buffer: StringIO, obj: List[JSON], tag: str, schema: Dict[str,
 
 
 def _write_primitive(
-    buffer: StringIO, obj: Primitive, tag: str, schema: Dict[str, Any], namespace_stack: List[str]
+    buffer: StringIO, obj: Primitive, tag: str, schema: dict[str, Any], namespace_stack: list[str]
 ) -> None:
     xml_options = schema.get("xml", {})
     # There is no need for modifying the namespace stack, as we know that this function is terminal - it do not recurse
@@ -165,7 +166,7 @@ def _write_primitive(
     buffer.write(f">{obj}</{tag}>")
 
 
-def _write_namespace(buffer: StringIO, options: Dict[str, Any]) -> None:
+def _write_namespace(buffer: StringIO, options: dict[str, Any]) -> None:
     buffer.write(" xmlns")
     if "prefix" in options:
         buffer.write(f":{options['prefix']}")

schemathesis/auths.py

@@ -5,9 +5,16 @@ import threading
 import time
 import warnings
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Callable, Generic, List, Optional, Type, TypeVar, Union, overload
-
-from typing_extensions import Protocol, runtime_checkable
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Generic,
+    TypeVar,
+    overload,
+    runtime_checkable,
+    Protocol,
+)
 
 from .exceptions import UsageError
 from .filters import FilterSet, FilterValue, MatcherFunc, attach_filter_chain
@@ -30,15 +37,15 @@ class AuthContext:
     :ivar app: Optional Python application if the WSGI / ASGI integration is used.
     """
 
-    operation: "APIOperation"
-    app: Optional[Any]
+    operation: APIOperation
+    app: Any | None
 
 
 @runtime_checkable
 class AuthProvider(Generic[Auth], Protocol):
     """Get authentication data for an API and set it on the generated test cases."""
 
-    def get(self, case: "Case", context: AuthContext) -> Optional[Auth]:
+    def get(self, case: Case, context: AuthContext) -> Auth | None:
         """Get the authentication data.
 
         :param Case case: Generated test case.
@@ -46,7 +53,7 @@ class AuthProvider(Generic[Auth], Protocol):
         :return: Any authentication data you find useful for your use case. For example, it could be an access token.
         """
 
-    def set(self, case: "Case", data: Auth, context: AuthContext) -> None:
+    def set(self, case: Case, data: Auth, context: AuthContext) -> None:
         """Set authentication data on a generated test case.
 
         :param Optional[Auth] data: Authentication data you got from the ``get`` method.
@@ -69,10 +76,10 @@ class RequestsAuth(Generic[Auth]):
 
     auth: requests.auth.AuthBase
 
-    def get(self, _: "Case", __: AuthContext) -> Optional[Auth]:
+    def get(self, _: Case, __: AuthContext) -> Auth | None:
         return self.auth  # type: ignore[return-value]
 
-    def set(self, case: "Case", _: Auth, __: AuthContext) -> None:
+    def set(self, case: Case, _: Auth, __: AuthContext) -> None:
         case._auth = self.auth
 
 
@@ -82,12 +89,12 @@ class CachingAuthProvider(Generic[Auth]):
 
     provider: AuthProvider
     refresh_interval: int = DEFAULT_REFRESH_INTERVAL
-    cache_entry: Optional[CacheEntry[Auth]] = None
+    cache_entry: CacheEntry[Auth] | None = None
     # The timer exists here to simplify testing
     timer: Callable[[], float] = time.monotonic
     _refresh_lock: threading.Lock = field(default_factory=threading.Lock)
 
-    def get(self, case: "Case", context: AuthContext) -> Optional[Auth]:
+    def get(self, case: Case, context: AuthContext) -> Auth | None:
         """Get cached auth value."""
         if self.cache_entry is None or self.timer() >= self.cache_entry.expires:
             with self._refresh_lock:
@@ -100,7 +107,7 @@ class CachingAuthProvider(Generic[Auth]):
                 return data
         return self.cache_entry.data
 
-    def set(self, case: "Case", data: Auth, context: AuthContext) -> None:
+    def set(self, case: Case, data: Auth, context: AuthContext) -> None:
         """Set auth data on the `Case` instance.
 
         This implementation delegates this to the actual provider.
@@ -111,33 +118,33 @@ class CachingAuthProvider(Generic[Auth]):
 class FilterableRegisterAuth(Protocol):
     """Protocol that adds filters to the return value of `register`."""
 
-    def __call__(self, provider_class: Type[AuthProvider]) -> Type[AuthProvider]:
+    def __call__(self, provider_class: type[AuthProvider]) -> type[AuthProvider]:
         pass
 
     def apply_to(
         self,
-        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,
-    ) -> "FilterableRegisterAuth":
+        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,
+    ) -> FilterableRegisterAuth:
         pass
 
     def skip_for(
         self,
-        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,
-    ) -> "FilterableRegisterAuth":
+        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,
+    ) -> FilterableRegisterAuth:
         pass
 
 
@@ -149,28 +156,28 @@ class FilterableApplyAuth(Protocol):
 
     def apply_to(
         self,
-        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,
-    ) -> "FilterableApplyAuth":
+        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,
+    ) -> FilterableApplyAuth:
         pass
 
     def skip_for(
         self,
-        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,
-    ) -> "FilterableApplyAuth":
+        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,
+    ) -> FilterableApplyAuth:
         pass
 
 
@@ -179,28 +186,28 @@ class FilterableRequestsAuth(Protocol):
 
     def apply_to(
         self,
-        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,
-    ) -> "FilterableRequestsAuth":
+        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,
+    ) -> FilterableRequestsAuth:
         pass
 
     def skip_for(
         self,
-        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,
-    ) -> "FilterableRequestsAuth":
+        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,
+    ) -> FilterableRequestsAuth:
         pass
 
 
@@ -211,12 +218,12 @@ class SelectiveAuthProvider(Generic[Auth]):
     provider: AuthProvider
     filter_set: FilterSet
 
-    def get(self, case: "Case", context: AuthContext) -> Optional[Auth]:
+    def get(self, case: Case, context: AuthContext) -> Auth | None:
         if self.filter_set.match(context):
             return _provider_get(self.provider, case, context)
         return None
 
-    def set(self, case: "Case", data: Auth, context: AuthContext) -> None:
+    def set(self, case: Case, data: Auth, context: AuthContext) -> None:
         self.provider.set(case, data, context)
 
 
@@ -224,7 +231,7 @@ class SelectiveAuthProvider(Generic[Auth]):
 class AuthStorage(Generic[Auth]):
     """Store and manage API authentication."""
 
-    providers: List[AuthProvider] = field(default_factory=list)
+    providers: list[AuthProvider] = field(default_factory=list)
 
     @property
     def is_defined(self) -> bool:
@@ -235,25 +242,25 @@ class AuthStorage(Generic[Auth]):
     def __call__(
         self,
         *,
-        refresh_interval: Optional[int] = DEFAULT_REFRESH_INTERVAL,
+        refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL,
     ) -> FilterableRegisterAuth:
         pass
 
     @overload
     def __call__(
         self,
-        provider_class: Type[AuthProvider],
+        provider_class: type[AuthProvider],
         *,
-        refresh_interval: Optional[int] = DEFAULT_REFRESH_INTERVAL,
+        refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL,
     ) -> FilterableApplyAuth:
         pass
 
     def __call__(
         self,
-        provider_class: Optional[Type[AuthProvider]] = None,
+        provider_class: type[AuthProvider] | None = None,
         *,
-        refresh_interval: Optional[int] = DEFAULT_REFRESH_INTERVAL,
-    ) -> Union[FilterableRegisterAuth, FilterableApplyAuth]:
+        refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL,
+    ) -> FilterableRegisterAuth | FilterableApplyAuth:
         if provider_class is not None:
             return self.apply(provider_class, refresh_interval=refresh_interval)
         return self.register(refresh_interval=refresh_interval)
@@ -274,8 +281,8 @@ class AuthStorage(Generic[Auth]):
     def _set_provider(
         self,
         *,
-        provider_class: Type[AuthProvider],
-        refresh_interval: Optional[int] = DEFAULT_REFRESH_INTERVAL,
+        provider_class: type[AuthProvider],
+        refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL,
         filter_set: FilterSet,
     ) -> None:
         if not issubclass(provider_class, AuthProvider):
@@ -294,7 +301,7 @@ class AuthStorage(Generic[Auth]):
             provider = SelectiveAuthProvider(provider, filter_set)
         self.providers.append(provider)
 
-    def register(self, *, refresh_interval: Optional[int] = DEFAULT_REFRESH_INTERVAL) -> FilterableRegisterAuth:
+    def register(self, *, refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL) -> FilterableRegisterAuth:
         """Register a new auth provider.
 
         .. code-block:: python
@@ -315,7 +322,7 @@ class AuthStorage(Generic[Auth]):
         """
         filter_set = FilterSet()
 
-        def wrapper(provider_class: Type[AuthProvider]) -> Type[AuthProvider]:
+        def wrapper(provider_class: type[AuthProvider]) -> type[AuthProvider]:
             self._set_provider(provider_class=provider_class, refresh_interval=refresh_interval, filter_set=filter_set)
             return provider_class
 
@@ -332,7 +339,7 @@ class AuthStorage(Generic[Auth]):
         self.providers = []
 
     def apply(
-        self, provider_class: Type[AuthProvider], *, refresh_interval: Optional[int] = DEFAULT_REFRESH_INTERVAL
+        self, provider_class: type[AuthProvider], *, refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL
     ) -> FilterableApplyAuth:
         """Register auth provider only on one test function.
 
@@ -366,7 +373,7 @@ class AuthStorage(Generic[Auth]):
         return wrapper  # type: ignore[return-value]
 
     @classmethod
-    def add_auth_storage(cls, test: GenericTest) -> "AuthStorage":
+    def add_auth_storage(cls, test: GenericTest) -> AuthStorage:
         """Attach a new auth storage instance to the test if it is not already present."""
         if not hasattr(test, AUTH_STORAGE_ATTRIBUTE_NAME):
             setattr(test, AUTH_STORAGE_ATTRIBUTE_NAME, cls())
@@ -374,18 +381,18 @@ class AuthStorage(Generic[Auth]):
             raise UsageError(f"`{test.__name__}` has already been decorated with `apply`.")
         return getattr(test, AUTH_STORAGE_ATTRIBUTE_NAME)
 
-    def set(self, case: "Case", context: AuthContext) -> None:
+    def set(self, case: Case, context: AuthContext) -> None:
         """Set authentication data on a generated test case."""
         if not self.is_defined:
             raise UsageError("No auth provider is defined.")
         for provider in self.providers:
-            data: Optional[Auth] = _provider_get(provider, case, context)
+            data: Auth | None = _provider_get(provider, case, context)
             if data is not None:
                 provider.set(case, data, context)
                 break
 
 
-def _provider_get(auth_provider: AuthProvider, case: "Case", context: AuthContext) -> Optional[Auth]:
+def _provider_get(auth_provider: AuthProvider, case: Case, context: AuthContext) -> Auth | None:
     # A shim to provide a compatibility layer between previously used convention for `AuthProvider.get`
     # where it used to accept a single `context` argument
     method = auth_provider.get
@@ -404,7 +411,7 @@ def _provider_get(auth_provider: AuthProvider, case: "Case", context: AuthContex
     return method(case, context)
 
 
-def set_on_case(case: "Case", context: AuthContext, auth_storage: Optional[AuthStorage]) -> None:
+def set_on_case(case: Case, context: AuthContext, auth_storage: AuthStorage | None) -> None:
     """Set authentication data on this case.
 
     If there is no auth defined, then this function is no-op.
@@ -417,7 +424,7 @@ def set_on_case(case: "Case", context: AuthContext, auth_storage: Optional[AuthS
         GLOBAL_AUTH_STORAGE.set(case, context)
 
 
-def get_auth_storage_from_test(test: GenericTest) -> Optional[AuthStorage]:
+def get_auth_storage_from_test(test: GenericTest) -> AuthStorage | None:
     """Extract the currently attached auth storage from a test function."""
     return getattr(test, AUTH_STORAGE_ATTRIBUTE_NAME, None)
 

schemathesis/checks.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional, Tuple
+from typing import TYPE_CHECKING
 
 from . import failures
 from .exceptions import get_server_error
@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     from .models import Case, CheckFunction
 
 
-def not_a_server_error(response: GenericResponse, case: Case) -> Optional[bool]:
+def not_a_server_error(response: GenericResponse, case: Case) -> bool | None:
     """A check to verify that the response is not a server-side error."""
     status_code = response.status_code
     if status_code >= 500:
@@ -24,14 +24,14 @@ def not_a_server_error(response: GenericResponse, case: Case) -> Optional[bool]:
     return None
 
 
-DEFAULT_CHECKS: Tuple["CheckFunction", ...] = (not_a_server_error,)
+DEFAULT_CHECKS: tuple[CheckFunction, ...] = (not_a_server_error,)
 OPTIONAL_CHECKS = (
     status_code_conformance,
     content_type_conformance,
     response_headers_conformance,
     response_schema_conformance,
 )
-ALL_CHECKS: Tuple["CheckFunction", ...] = DEFAULT_CHECKS + OPTIONAL_CHECKS
+ALL_CHECKS: tuple[CheckFunction, ...] = DEFAULT_CHECKS + OPTIONAL_CHECKS
 
 
 def register(check: CheckFunction) -> CheckFunction: