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

schemathesis/schemas.py

@@ -16,18 +16,12 @@ from typing import (
     Any,
     Callable,
     ContextManager,
-    Dict,
     Generator,
     Iterable,
     Iterator,
-    List,
     NoReturn,
-    Optional,
     Sequence,
-    Tuple,
-    Type,
     TypeVar,
-    Union,
     TYPE_CHECKING,
 )
 from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
@@ -41,7 +35,12 @@ from .constants import NOT_SET
 from ._hypothesis import create_test
 from .auths import AuthStorage
 from .code_samples import CodeSampleStyle
-from .generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod, DataGenerationMethodInput
+from .generation import (
+    DEFAULT_DATA_GENERATION_METHODS,
+    DataGenerationMethod,
+    DataGenerationMethodInput,
+    GenerationConfig,
+)
 from .exceptions import OperationSchemaError, UsageError
 from .hooks import HookContext, HookDispatcher, HookScope, dispatch
 from .internal.result import Result, Ok
@@ -84,31 +83,32 @@ class MethodsDict(CaseInsensitiveDict):
 C = TypeVar("C", bound=Case)
 
 
-@lru_cache()
+@lru_cache
 def get_full_path(base_path: str, path: str) -> str:
     return unquote(urljoin(base_path, quote(path.lstrip("/"))))
 
 
 @dataclass(eq=False)
 class BaseSchema(Mapping):
-    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
+    raw_schema: dict[str, Any]
+    location: str | None = None
+    base_url: str | None = None
+    method: Filter | None = None
+    endpoint: Filter | None = None
+    tag: Filter | None = None
+    operation_id: Filter | None = 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
+    test_function: GenericTest | None = None
     validate_schema: bool = True
     skip_deprecated_operations: bool = False
-    data_generation_methods: List[DataGenerationMethod] = field(
+    data_generation_methods: list[DataGenerationMethod] = field(
         default_factory=lambda: list(DEFAULT_DATA_GENERATION_METHODS)
     )
+    generation_config: GenerationConfig = field(default_factory=GenerationConfig)
     code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
-    rate_limiter: Optional[Limiter] = None
+    rate_limiter: Limiter | None = None
     sanitize_output: bool = True
 
     def __iter__(self) -> Iterator[str]:
@@ -127,7 +127,7 @@ class BaseSchema(Mapping):
     def __len__(self) -> int:
         return len(self.operations)
 
-    def hook(self, hook: Union[str, Callable]) -> Callable:
+    def hook(self, hook: str | Callable) -> Callable:
         return self.hooks.register(hook)
 
     @property
@@ -169,7 +169,7 @@ class BaseSchema(Mapping):
         raise NotImplementedError
 
     @property
-    def operations(self) -> Dict[str, MethodsDict]:
+    def operations(self) -> dict[str, MethodsDict]:
         if not hasattr(self, "_operations"):
             operations = self.get_all_operations()
             self._operations = operations_to_dict(operations)
@@ -179,38 +179,43 @@ class BaseSchema(Mapping):
     def operations_count(self) -> int:
         raise NotImplementedError
 
+    @property
+    def links_count(self) -> int:
+        raise NotImplementedError
+
     def get_all_operations(
-        self, hooks: Optional[HookDispatcher] = None
+        self, hooks: HookDispatcher | None = None
     ) -> Generator[Result[APIOperation, OperationSchemaError], None, None]:
         raise NotImplementedError
 
-    def get_strategies_from_examples(self, operation: APIOperation) -> List[SearchStrategy[Case]]:
+    def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
         raise NotImplementedError
 
-    def get_security_requirements(self, operation: APIOperation) -> List[str]:
+    def get_security_requirements(self, operation: APIOperation) -> list[str]:
         """Get applied security requirements for the given API operation."""
         raise NotImplementedError
 
     def get_stateful_tests(
-        self, response: GenericResponse, operation: APIOperation, stateful: Optional[Stateful]
+        self, response: GenericResponse, operation: APIOperation, stateful: Stateful | None
     ) -> Sequence[StatefulTest]:
         """Get a list of additional tests, that should be executed after this response from the API operation."""
         raise NotImplementedError
 
-    def get_parameter_serializer(self, operation: APIOperation, location: str) -> Optional[Callable]:
+    def get_parameter_serializer(self, operation: APIOperation, location: str) -> Callable | None:
         """Get a function that serializes parameters for the given location."""
         raise NotImplementedError
 
     def get_all_tests(
         self,
         func: Callable,
-        settings: Optional[hypothesis.settings] = None,
-        seed: Optional[int] = None,
-        as_strategy_kwargs: Optional[Dict[str, Any]] = None,
-        hooks: Optional[HookDispatcher] = None,
-        _given_kwargs: Optional[Dict[str, GivenInput]] = None,
-    ) -> Generator[Result[Tuple[APIOperation, Callable], OperationSchemaError], None, None]:
+        settings: hypothesis.settings | None = None,
+        generation_config: GenerationConfig | None = None,
+        seed: int | None = None,
+        as_strategy_kwargs: dict[str, Any] | None = None,
+        hooks: HookDispatcher | None = None,
+        _given_kwargs: dict[str, GivenInput] | None = None,
+    ) -> Generator[Result[tuple[APIOperation, Callable], OperationSchemaError], None, None]:
         """Generate all operations and Hypothesis tests for them."""
         for result in self.get_all_operations(hooks=hooks):
             if isinstance(result, Ok):
@@ -220,6 +225,7 @@ class BaseSchema(Mapping):
                     settings=settings,
                     seed=seed,
                     data_generation_methods=self.data_generation_methods,
+                    generation_config=generation_config,
                     as_strategy_kwargs=as_strategy_kwargs,
                     _given_kwargs=_given_kwargs,
                 )
@@ -229,14 +235,14 @@ class BaseSchema(Mapping):
 
     def parametrize(
         self,
-        method: Optional[Filter] = NOT_SET,
-        endpoint: Optional[Filter] = NOT_SET,
-        tag: Optional[Filter] = NOT_SET,
-        operation_id: Optional[Filter] = NOT_SET,
-        validate_schema: Union[bool, NotSet] = NOT_SET,
-        skip_deprecated_operations: Union[bool, NotSet] = NOT_SET,
-        data_generation_methods: Union[Iterable[DataGenerationMethod], NotSet] = NOT_SET,
-        code_sample_style: Union[str, NotSet] = NOT_SET,
+        method: Filter | None = NOT_SET,
+        endpoint: Filter | None = NOT_SET,
+        tag: Filter | None = NOT_SET,
+        operation_id: Filter | None = NOT_SET,
+        validate_schema: bool | NotSet = NOT_SET,
+        skip_deprecated_operations: bool | NotSet = NOT_SET,
+        data_generation_methods: Iterable[DataGenerationMethod] | NotSet = NOT_SET,
+        code_sample_style: str | NotSet = NOT_SET,
     ) -> Callable:
         """Mark a test function as a parametrized one."""
         _code_sample_style = (
@@ -278,22 +284,23 @@ class BaseSchema(Mapping):
     def clone(
         self,
         *,
-        base_url: Union[Optional[str], NotSet] = NOT_SET,
-        test_function: Optional[GenericTest] = None,
-        method: Optional[Filter] = NOT_SET,
-        endpoint: Optional[Filter] = NOT_SET,
-        tag: Optional[Filter] = NOT_SET,
-        operation_id: Optional[Filter] = NOT_SET,
+        base_url: str | None | NotSet = NOT_SET,
+        test_function: GenericTest | None = None,
+        method: Filter | None = NOT_SET,
+        endpoint: Filter | None = NOT_SET,
+        tag: Filter | None = NOT_SET,
+        operation_id: Filter | None = NOT_SET,
         app: Any = NOT_SET,
-        hooks: Union[HookDispatcher, NotSet] = NOT_SET,
-        auth: Union[AuthStorage, NotSet] = NOT_SET,
-        validate_schema: Union[bool, NotSet] = NOT_SET,
-        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,
-        sanitize_output: Optional[Union[bool, NotSet]] = NOT_SET,
-    ) -> "BaseSchema":
+        hooks: HookDispatcher | NotSet = NOT_SET,
+        auth: AuthStorage | NotSet = NOT_SET,
+        validate_schema: bool | NotSet = NOT_SET,
+        skip_deprecated_operations: bool | NotSet = NOT_SET,
+        data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
+        generation_config: GenerationConfig | NotSet = NOT_SET,
+        code_sample_style: CodeSampleStyle | NotSet = NOT_SET,
+        rate_limiter: Limiter | None = NOT_SET,
+        sanitize_output: bool | NotSet | None = NOT_SET,
+    ) -> BaseSchema:
         if base_url is NOT_SET:
             base_url = self.base_url
         if method is NOT_SET:
@@ -316,6 +323,8 @@ class BaseSchema(Mapping):
             auth = self.auth
         if data_generation_methods is NOT_SET:
             data_generation_methods = self.data_generation_methods
+        if generation_config is NOT_SET:
+            generation_config = self.generation_config
         if code_sample_style is NOT_SET:
             code_sample_style = self.code_sample_style
         if rate_limiter is NOT_SET:
@@ -338,12 +347,13 @@ class BaseSchema(Mapping):
             validate_schema=validate_schema,  # type: ignore
             skip_deprecated_operations=skip_deprecated_operations,  # type: ignore
             data_generation_methods=data_generation_methods,  # type: ignore
+            generation_config=generation_config,  # type: ignore
             code_sample_style=code_sample_style,  # type: ignore
             rate_limiter=rate_limiter,  # type: ignore
             sanitize_output=sanitize_output,  # type: ignore
         )
 
-    def get_local_hook_dispatcher(self) -> Optional[HookDispatcher]:
+    def get_local_hook_dispatcher(self) -> HookDispatcher | None:
         """Get a HookDispatcher instance bound to the test if present."""
         # It might be not present when it is used without pytest via `APIOperation.as_strategy()`
         if self.test_function is not None:
@@ -361,51 +371,52 @@ class BaseSchema(Mapping):
 
     def prepare_multipart(
         self, form_data: FormData, operation: APIOperation
-    ) -> Tuple[Optional[List], Optional[Dict[str, Any]]]:
+    ) -> tuple[list | None, dict[str, Any] | None]:
         """Split content of `form_data` into files & data.
 
         Forms may contain file fields, that we should send via `files` argument in `requests`.
         """
         raise NotImplementedError
 
-    def get_request_payload_content_types(self, operation: APIOperation) -> List[str]:
+    def get_request_payload_content_types(self, operation: APIOperation) -> list[str]:
         raise NotImplementedError
 
     def make_case(
         self,
         *,
-        case_cls: Type[C],
+        case_cls: type[C],
         operation: APIOperation,
-        path_parameters: Optional[PathParameters] = None,
-        headers: Optional[Headers] = None,
-        cookies: Optional[Cookies] = None,
-        query: Optional[Query] = None,
-        body: Union[Body, NotSet] = NOT_SET,
-        media_type: Optional[str] = None,
+        path_parameters: PathParameters | None = None,
+        headers: Headers | None = None,
+        cookies: Cookies | None = None,
+        query: Query | None = None,
+        body: Body | NotSet = NOT_SET,
+        media_type: str | None = None,
     ) -> C:
         raise NotImplementedError
 
     def get_case_strategy(
         self,
         operation: APIOperation,
-        hooks: Optional[HookDispatcher] = None,
-        auth_storage: Optional[AuthStorage] = None,
+        hooks: HookDispatcher | None = None,
+        auth_storage: AuthStorage | None = None,
         data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),
+        generation_config: GenerationConfig | None = None,
         **kwargs: Any,
     ) -> SearchStrategy:
         raise NotImplementedError
 
-    def as_state_machine(self) -> Type[APIStateMachine]:
+    def as_state_machine(self) -> type[APIStateMachine]:
         """Create a state machine class.
 
         Use it for stateful testing.
         """
         raise NotImplementedError
 
-    def get_links(self, operation: APIOperation) -> Dict[str, Dict[str, Any]]:
+    def get_links(self, operation: APIOperation) -> dict[str, dict[str, Any]]:
         raise NotImplementedError
 
-    def validate_response(self, operation: APIOperation, response: GenericResponse) -> None:
+    def validate_response(self, operation: APIOperation, response: GenericResponse) -> bool | None:
         raise NotImplementedError
 
     def prepare_schema(self, schema: Any) -> Any:
@@ -418,14 +429,14 @@ class BaseSchema(Mapping):
             return self.rate_limiter.ratelimit(label, delay=True, max_delay=0)
         return nullcontext()
 
-    def _get_payload_schema(self, definition: Dict[str, Any], media_type: str) -> Optional[Dict[str, Any]]:
+    def _get_payload_schema(self, definition: dict[str, Any], media_type: str) -> dict[str, Any] | None:
         raise NotImplementedError
 
 
 def operations_to_dict(
     operations: Generator[Result[APIOperation, OperationSchemaError], None, None]
-) -> Dict[str, MethodsDict]:
-    output: Dict[str, MethodsDict] = {}
+) -> dict[str, MethodsDict]:
+    output: dict[str, MethodsDict] = {}
     for result in operations:
         if isinstance(result, Ok):
             operation = result.ok()

schemathesis/serializers.py

@@ -1,10 +1,19 @@
+from __future__ import annotations
 import binascii
 import os
 from dataclasses import dataclass
 from io import BytesIO
-from typing import TYPE_CHECKING, Any, Callable, Collection, Dict, Generator, Optional, Type, cast
-
-from typing_extensions import Protocol, runtime_checkable
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Collection,
+    Dict,
+    Generator,
+    cast,
+    Protocol,
+    runtime_checkable,
+)
 
 from .internal.copy import fast_deepcopy
 from ._xml import _to_xml
@@ -19,7 +28,7 @@ if TYPE_CHECKING:
     from .models import Case
 
 
-SERIALIZERS: Dict[str, Type["Serializer"]] = {}
+SERIALIZERS: dict[str, type[Serializer]] = {}
 
 
 @dataclass
@@ -40,7 +49,7 @@ class SerializerContext:
     :ivar Case case: Generated example that is being processed.
     """
 
-    case: "Case"
+    case: Case
 
     @property
     def media_type(self) -> str:
@@ -52,11 +61,11 @@ class SerializerContext:
     # Therefore `schema` is never `None` if called from here. However, `APIOperation.get_raw_payload_schema` is
     # generic and can be called from other places where it may return `None`
 
-    def get_raw_payload_schema(self) -> Dict[str, Any]:
+    def get_raw_payload_schema(self) -> dict[str, Any]:
         schema = self.case.operation.get_raw_payload_schema(self.media_type)
         return cast(Dict[str, Any], schema)
 
-    def get_resolved_payload_schema(self) -> Dict[str, Any]:
+    def get_resolved_payload_schema(self) -> dict[str, Any]:
         schema = self.case.operation.get_resolved_payload_schema(self.media_type)
         return cast(Dict[str, Any], schema)
 
@@ -69,14 +78,14 @@ class Serializer(Protocol):
     `requests` and `werkzeug` transports.
     """
 
-    def as_requests(self, context: SerializerContext, payload: Any) -> Dict[str, Any]:
+    def as_requests(self, context: SerializerContext, payload: Any) -> dict[str, Any]:
         raise NotImplementedError
 
-    def as_werkzeug(self, context: SerializerContext, payload: Any) -> Dict[str, Any]:
+    def as_werkzeug(self, context: SerializerContext, payload: Any) -> dict[str, Any]:
         raise NotImplementedError
 
 
-def register(media_type: str, *, aliases: Collection[str] = ()) -> Callable[[Type[Serializer]], Type[Serializer]]:
+def register(media_type: str, *, aliases: Collection[str] = ()) -> Callable[[type[Serializer]], type[Serializer]]:
     """Register a serializer for the given media type.
 
     Schemathesis uses ``requests`` for regular network calls and ``werkzeug`` for WSGI applications. Your serializer
@@ -99,7 +108,7 @@ def register(media_type: str, *, aliases: Collection[str] = ()) -> Callable[[Typ
 
     """
 
-    def wrapper(serializer: Type[Serializer]) -> Type[Serializer]:
+    def wrapper(serializer: type[Serializer]) -> type[Serializer]:
         if not issubclass(serializer, Serializer):
             raise TypeError(
                 f"`{serializer.__name__}` is not a valid serializer. "
@@ -118,7 +127,7 @@ def unregister(media_type: str) -> None:
     del SERIALIZERS[media_type]
 
 
-def _to_json(value: Any) -> Dict[str, Any]:
+def _to_json(value: Any) -> dict[str, Any]:
     if isinstance(value, bytes):
         # Possible to get via explicit examples, e.g. `externalValue`
         return {"data": value}
@@ -132,14 +141,14 @@ def _to_json(value: Any) -> Dict[str, Any]:
 
 @register("application/json")
 class JSONSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
+    def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         return _to_json(value)
 
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
+    def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         return _to_json(value)
 
 
-def _to_yaml(value: Any) -> Dict[str, Any]:
+def _to_yaml(value: Any) -> dict[str, Any]:
     import yaml
 
     try:
@@ -154,19 +163,19 @@ def _to_yaml(value: Any) -> Dict[str, Any]:
 
 @register("text/yaml", aliases=("text/x-yaml", "application/x-yaml", "text/vnd.yaml"))
 class YAMLSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
+    def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         return _to_yaml(value)
 
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
+    def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         return _to_yaml(value)
 
 
 @register("application/xml")
 class XMLSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
+    def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         return _to_xml(value, context.get_raw_payload_schema(), context.get_resolved_payload_schema())
 
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
+    def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         return _to_xml(value, context.get_raw_payload_schema(), context.get_resolved_payload_schema())
 
 
@@ -176,7 +185,7 @@ def _should_coerce_to_bytes(item: Any) -> bool:
     return isinstance(item, Binary) or not isinstance(item, (bytes, str, int))
 
 
-def _prepare_form_data(data: Dict[str, Any]) -> Dict[str, Any]:
+def _prepare_form_data(data: dict[str, Any]) -> dict[str, Any]:
     """Make the generated data suitable for sending as multipart.
 
     If the schema is loose, Schemathesis can generate data that can't be sent as multipart. In these cases,
@@ -222,7 +231,7 @@ def _encode_multipart(value: Any, boundary: str) -> bytes:
 
 @register("multipart/form-data")
 class MultipartSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
+    def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         if isinstance(value, bytes):
             return {"data": value}
         if isinstance(value, dict):
@@ -236,27 +245,27 @@ class MultipartSerializer:
         content_type = f"multipart/form-data; boundary={boundary}"
         return {"data": raw_data, "headers": {"Content-Type": content_type}}
 
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
+    def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         return {"data": value}
 
 
 @register("application/x-www-form-urlencoded")
 class URLEncodedFormSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
+    def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         return {"data": value}
 
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
+    def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         return {"data": value}
 
 
 @register("text/plain")
 class TextSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
+    def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         if isinstance(value, bytes):
             return {"data": value}
         return {"data": str(value).encode("utf8")}
 
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
+    def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         if isinstance(value, bytes):
             return {"data": value}
         return {"data": str(value)}
@@ -264,10 +273,10 @@ class TextSerializer:
 
 @register("application/octet-stream")
 class OctetStreamSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
+    def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         return {"data": _to_bytes(value)}
 
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
+    def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         return {"data": _to_bytes(value)}
 
 
@@ -287,11 +296,11 @@ def get_matching_media_types(media_type: str) -> Generator[str, None, None]:
                     yield registered_media_type
 
 
-def get_first_matching_media_type(media_type: str) -> Optional[str]:
+def get_first_matching_media_type(media_type: str) -> str | None:
     return next(get_matching_media_types(media_type), None)
 
 
-def get(media_type: str) -> Optional[Type[Serializer]]:
+def get(media_type: str) -> type[Serializer] | None:
     """Get an appropriate serializer for the given media type."""
     if is_json_media_type(media_type):
         media_type = "application/json"

schemathesis/service/ci.py

@@ -1,9 +1,8 @@
+from __future__ import annotations
 import enum
 import os
 from dataclasses import asdict, dataclass
-from typing import Dict, Optional
-
-from typing_extensions import Protocol, runtime_checkable
+from typing import Protocol, runtime_checkable
 
 
 @enum.unique
@@ -25,17 +24,17 @@ class Environment(Protocol):
         pass
 
     @classmethod
-    def from_env(cls) -> "Environment":
+    def from_env(cls) -> Environment:
         pass
 
-    def asdict(self) -> Dict[str, Optional[str]]:
+    def asdict(self) -> dict[str, str | None]:
         pass
 
-    def as_env(self) -> Dict[str, Optional[str]]:
+    def as_env(self) -> dict[str, str | None]:
         pass
 
 
-def environment() -> Optional[Environment]:
+def environment() -> Environment | None:
     """Collect environment data for a supported CI provider."""
     provider = detect()
     if provider == CIProvider.GITHUB:
@@ -45,7 +44,7 @@ def environment() -> Optional[Environment]:
     return None
 
 
-def detect() -> Optional[CIProvider]:
+def detect() -> CIProvider | None:
     """Detect the current CI provider."""
     if GitHubActionsEnvironment.is_set():
         return GitHubActionsEnvironment.provider
@@ -54,7 +53,7 @@ def detect() -> Optional[CIProvider]:
     return None
 
 
-def _asdict(env: Environment) -> Dict[str, Optional[str]]:
+def _asdict(env: Environment) -> dict[str, str | None]:
     data = asdict(env)  # type: ignore
     data["provider"] = env.provider.value
     return data
@@ -89,24 +88,24 @@ class GitHubActionsEnvironment:
     workflow: str
     # The head ref or source branch of the pull request in a workflow run.
     # For example, `dd/report-ci`.
-    head_ref: Optional[str]
+    head_ref: str | None
     # The name of the base ref or target branch of the pull request in a workflow run.
     # For example, `main`.
-    base_ref: Optional[str]
+    base_ref: str | None
     # The branch or tag ref that triggered the workflow run.
     # This is only set if a branch or tag is available for the event type.
     # For example, `refs/pull/1533/merge`
-    ref: Optional[str]
+    ref: str | None
     # The Schemathesis GitHub Action version.
     # For example `v1.0.1`
-    action_ref: Optional[str]
+    action_ref: str | None
 
     @classmethod
     def is_set(cls) -> bool:
         return os.getenv(cls.variable_name) == "true"
 
     @classmethod
-    def from_env(cls) -> "GitHubActionsEnvironment":
+    def from_env(cls) -> GitHubActionsEnvironment:
         return cls(
             api_url=os.environ["GITHUB_API_URL"],
             repository=os.environ["GITHUB_REPOSITORY"],
@@ -120,7 +119,7 @@ class GitHubActionsEnvironment:
             action_ref=os.getenv("SCHEMATHESIS_ACTION_REF"),
         )
 
-    def as_env(self) -> Dict[str, Optional[str]]:
+    def as_env(self) -> dict[str, str | None]:
         return {
             "GITHUB_API_URL": self.api_url,
             "GITHUB_REPOSITORY": self.repository,
@@ -161,23 +160,23 @@ class GitLabCIEnvironment:
     # not documented.
     # The commit branch name. Not available in merge request pipelines or tag pipelines.
     # For example, `dd/report-ci`.
-    commit_branch: Optional[str]
+    commit_branch: str | None
     # The source branch name of the merge request. Only available in merge request pipelines.
     # For example, `dd/report-ci`.
-    merge_request_source_branch_name: Optional[str]
+    merge_request_source_branch_name: str | None
     # The target branch name of the merge request.
     # For example, `main`.
-    merge_request_target_branch_name: Optional[str]
+    merge_request_target_branch_name: str | None
     # The project-level internal ID of the merge request.
     # For example, `42`.
-    merge_request_iid: Optional[str]
+    merge_request_iid: str | None
 
     @classmethod
     def is_set(cls) -> bool:
         return os.getenv(cls.variable_name) == "true"
 
     @classmethod
-    def from_env(cls) -> "GitLabCIEnvironment":
+    def from_env(cls) -> GitLabCIEnvironment:
         return cls(
             api_v4_url=os.environ["CI_API_V4_URL"],
             project_id=os.environ["CI_PROJECT_ID"],
@@ -189,7 +188,7 @@ class GitLabCIEnvironment:
             merge_request_iid=os.getenv("CI_MERGE_REQUEST_IID"),
         )
 
-    def as_env(self) -> Dict[str, Optional[str]]:
+    def as_env(self) -> dict[str, str | None]:
         return {
             "CI_API_V4_URL": self.api_v4_url,
             "CI_PROJECT_ID": self.project_id,