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

schemathesis/service/client.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
 import hashlib
 import http
 from dataclasses import asdict
-from typing import Any, Optional, Union
+from typing import Any
 from urllib.parse import urljoin
 
 import requests
@@ -11,7 +12,15 @@ from ..constants import USER_AGENT
 from .ci import CIProvider
 from .constants import CI_PROVIDER_HEADER, REPORT_CORRELATION_ID_HEADER, REQUEST_TIMEOUT, UPLOAD_SOURCE_HEADER
 from .metadata import Metadata
-from .models import ApiDetails, AuthResponse, FailedUploadResponse, UploadResponse, UploadSource
+from .models import (
+    ProjectDetails,
+    AuthResponse,
+    FailedUploadResponse,
+    UploadResponse,
+    UploadSource,
+    ProjectEnvironment,
+    Specification,
+)
 
 
 def response_hook(response: requests.Response, **_kwargs: Any) -> None:
@@ -22,7 +31,7 @@ def response_hook(response: requests.Response, **_kwargs: Any) -> None:
 class ServiceClient(requests.Session):
     """A more convenient session to send requests to Schemathesis.io."""
 
-    def __init__(self, base_url: str, token: Optional[str], *, timeout: int = REQUEST_TIMEOUT, verify: bool = True):
+    def __init__(self, base_url: str, token: str | None, *, timeout: int = REQUEST_TIMEOUT, verify: bool = True):
         super().__init__()
         self.timeout = timeout
         self.verify = verify
@@ -43,11 +52,22 @@ class ServiceClient(requests.Session):
         url = urljoin(self.base_url, url)
         return super().request(method, url, *args, **kwargs)
 
-    def get_api_details(self, name: str) -> ApiDetails:
+    def get_api_details(self, name: str) -> ProjectDetails:
         """Get information about an API."""
-        response = self.get(f"/apis/{name}/")
+        response = self.get(f"/cli/projects/{name}/")
         data = response.json()
-        return ApiDetails(location=data["location"], base_url=data["base_url"])
+        return ProjectDetails(
+            environments=[
+                ProjectEnvironment(
+                    url=environment["url"],
+                    name=environment["name"],
+                    description=environment["description"],
+                    is_default=environment["is_default"],
+                )
+                for environment in data["environments"]
+            ],
+            specification=Specification(schema=data["specification"]["schema"]),
+        )
 
     def login(self, metadata: Metadata) -> AuthResponse:
         """Send a login request."""
@@ -58,10 +78,10 @@ class ServiceClient(requests.Session):
     def upload_report(
         self,
         report: bytes,
-        correlation_id: Optional[str] = None,
-        ci_provider: Optional[CIProvider] = None,
+        correlation_id: str | None = None,
+        ci_provider: CIProvider | None = None,
         source: UploadSource = UploadSource.DEFAULT,
-    ) -> Union[UploadResponse, FailedUploadResponse]:
+    ) -> UploadResponse | FailedUploadResponse:
         """Upload test run report to Schemathesis.io."""
         headers = {
             "Content-Type": "application/x-gtar",

schemathesis/service/constants.py

@@ -35,3 +35,4 @@ HOSTS_PATH_ENV_VAR = "SCHEMATHESIS_HOSTS_PATH"
 URL_ENV_VAR = "SCHEMATHESIS_URL"
 REPORT_ENV_VAR = "SCHEMATHESIS_REPORT"
 TELEMETRY_ENV_VAR = "SCHEMATHESIS_TELEMETRY"
+DOCKER_IMAGE_ENV_VAR = "SCHEMATHESIS_DOCKER_IMAGE"

schemathesis/service/events.py

@@ -1,5 +1,5 @@
+from __future__ import annotations
 from dataclasses import dataclass
-from typing import Optional
 
 from . import ci
 from ..exceptions import format_exception
@@ -21,7 +21,7 @@ class Metadata(Event):
     """Meta-information about the report."""
 
     size: int
-    ci_environment: Optional[ci.Environment]
+    ci_environment: ci.Environment | None
 
 
 @dataclass

schemathesis/service/hosts.py

@@ -1,9 +1,10 @@
 """Work with stored auth data."""
+from __future__ import annotations
 import enum
 import tempfile
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any
 
 import tomli
 import tomli_w
@@ -19,11 +20,11 @@ class HostData:
     hostname: str
     hosts_file: PathLike
 
-    def load(self) -> Dict[str, Any]:
+    def load(self) -> dict[str, Any]:
         return load(self.hosts_file).get(self.hostname, {})
 
     @property
-    def correlation_id(self) -> Optional[str]:
+    def correlation_id(self) -> str | None:
         return self.load().get("correlation_id")
 
     def store_correlation_id(self, correlation_id: str) -> None:
@@ -43,7 +44,7 @@ def store(token: str, hostname: str = DEFAULT_HOSTNAME, hosts_file: PathLike = D
     _dump_hosts(hosts_file, hosts)
 
 
-def load(path: PathLike) -> Dict[str, Any]:
+def load(path: PathLike) -> dict[str, Any]:
     """Load the given hosts file.
 
     Return an empty dict if it doesn't exist.
@@ -67,7 +68,7 @@ def _try_make_config_directory(path: PathLike) -> None:
         pass
 
 
-def load_for_host(hostname: str = DEFAULT_HOSTNAME, hosts_file: PathLike = DEFAULT_HOSTS_PATH) -> Dict[str, Any]:
+def load_for_host(hostname: str = DEFAULT_HOSTNAME, hosts_file: PathLike = DEFAULT_HOSTS_PATH) -> dict[str, Any]:
     """Load all data associated with a hostname."""
     return load(hosts_file).get(hostname, {})
 
@@ -97,7 +98,7 @@ def remove(hostname: str = DEFAULT_HOSTNAME, hosts_file: PathLike = DEFAULT_HOST
         return RemoveAuth.error
 
 
-def get_token(hostname: str = DEFAULT_HOSTNAME, hosts_file: PathLike = DEFAULT_HOSTS_PATH) -> Optional[str]:
+def get_token(hostname: str = DEFAULT_HOSTNAME, hosts_file: PathLike = DEFAULT_HOSTS_PATH) -> str | None:
     """Load a token for a host."""
     return load_for_host(hostname, hosts_file).get("token")
 
@@ -107,7 +108,7 @@ def get_temporary_hosts_file() -> str:
     return str(temporary_dir / "schemathesis-hosts.toml")
 
 
-def _dump_hosts(path: PathLike, hosts: Dict[str, Any]) -> None:
+def _dump_hosts(path: PathLike, hosts: dict[str, Any]) -> None:
     """Write hosts data to a file."""
     with open(path, "wb") as fd:
         tomli_w.dump(hosts, fd)

schemathesis/service/metadata.py

@@ -1,8 +1,11 @@
 """Useful info to collect from CLI usage."""
+from __future__ import annotations
+import os
 import platform
 from dataclasses import dataclass, field
 
 from ..constants import SCHEMATHESIS_VERSION
+from .constants import DOCKER_IMAGE_ENV_VAR
 
 
 @dataclass
@@ -39,3 +42,5 @@ class Metadata:
     interpreter: InterpreterMetadata = field(default_factory=InterpreterMetadata)
     # CLI info itself.
     cli: CliMetadata = field(default_factory=CliMetadata)
+    # Used Docker image if any
+    docker_image: str | None = field(default_factory=lambda: os.getenv(DOCKER_IMAGE_ENV_VAR))

schemathesis/service/models.py

@@ -1,6 +1,7 @@
+from __future__ import annotations
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional
+from typing import Any
 
 
 class UploadSource(str, Enum):
@@ -9,9 +10,26 @@ class UploadSource(str, Enum):
 
 
 @dataclass
-class ApiDetails:
-    location: str
-    base_url: Optional[str]
+class ProjectDetails:
+    environments: list[ProjectEnvironment]
+    specification: Specification
+
+    @property
+    def default_environment(self) -> ProjectEnvironment | None:
+        return next((env for env in self.environments if env.is_default), None)
+
+
+@dataclass
+class ProjectEnvironment:
+    url: str
+    name: str
+    description: str
+    is_default: bool
+
+
+@dataclass
+class Specification:
+    schema: dict[str, Any]
 
 
 @dataclass

schemathesis/service/report.py

@@ -9,7 +9,7 @@ from contextlib import suppress
 from dataclasses import asdict, dataclass, field
 from io import BytesIO
 from queue import Queue
-from typing import Any, Dict, Optional, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 import click
 
@@ -51,13 +51,13 @@ class ReportWriter:
     def add_metadata(
         self,
         *,
-        api_name: Optional[str],
+        api_name: str | None,
         location: str,
-        base_url: str,
+        base_url: str | None,
         started_at: str,
         metadata: Metadata,
-        ci_environment: Optional[ci.Environment],
-        usage_data: Optional[Dict[str, Any]],
+        ci_environment: ci.Environment | None,
+        usage_data: dict[str, Any] | None,
     ) -> None:
         data = {
             # API identifier on the Schemathesis.io side (optional)
@@ -105,9 +105,9 @@ class BaseReportHandler(EventHandler):
 class ServiceReportHandler(BaseReportHandler):
     client: ServiceClient
     host_data: HostData
-    api_name: Optional[str]
+    api_name: str | None
     location: str
-    base_url: Optional[str]
+    base_url: str | None
     started_at: str
     telemetry: bool
     out_queue: Queue
@@ -156,13 +156,13 @@ def consume_events(writer: ReportWriter, in_queue: Queue) -> ConsumeResult:
 def write_remote(
     client: ServiceClient,
     host_data: HostData,
-    api_name: Optional[str],
+    api_name: str | None,
     location: str,
-    base_url: str,
+    base_url: str | None,
     started_at: str,
     in_queue: Queue,
     out_queue: Queue,
-    usage_data: Optional[Dict[str, Any]],
+    usage_data: dict[str, Any] | None,
 ) -> None:
     """Create a compressed ``tar.gz`` file during the run & upload it to Schemathesis.io when the run is finished."""
     payload = BytesIO()
@@ -199,9 +199,9 @@ def write_remote(
 @dataclass
 class FileReportHandler(BaseReportHandler):
     file_handle: click.utils.LazyFile
-    api_name: Optional[str]
+    api_name: str | None
     location: str
-    base_url: Optional[str]
+    base_url: str | None
     started_at: str
     telemetry: bool
     out_queue: Queue
@@ -227,13 +227,13 @@ class FileReportHandler(BaseReportHandler):
 
 def write_file(
     file_handle: click.utils.LazyFile,
-    api_name: Optional[str],
+    api_name: str | None,
     location: str,
-    base_url: str,
+    base_url: str | None,
     started_at: str,
     in_queue: Queue,
     out_queue: Queue,
-    usage_data: Optional[Dict[str, Any]],
+    usage_data: dict[str, Any] | None,
 ) -> None:
     with file_handle.open() as fileobj, tarfile.open(mode="w:gz", fileobj=fileobj) as tar:
         writer = ReportWriter(tar)

schemathesis/service/serialization.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
 from dataclasses import asdict
-from typing import Any, Callable, Dict, List, Optional, TypeVar, cast
+from typing import Any, Callable, Dict, Optional, TypeVar, cast
 
 from ..models import Response
 from ..runner import events
@@ -10,7 +11,7 @@ S = TypeVar("S", bound=events.ExecutionEvent)
 SerializeFunc = Callable[[S], Optional[Dict[str, Any]]]
 
 
-def serialize_initialized(event: events.Initialized) -> Optional[Dict[str, Any]]:
+def serialize_initialized(event: events.Initialized) -> dict[str, Any] | None:
     return {
         "operations_count": event.operations_count,
         "location": event.location or "",
@@ -18,7 +19,7 @@ def serialize_initialized(event: events.Initialized) -> Optional[Dict[str, Any]]
     }
 
 
-def serialize_before_execution(event: events.BeforeExecution) -> Optional[Dict[str, Any]]:
+def serialize_before_execution(event: events.BeforeExecution) -> dict[str, Any] | None:
     return {
         "correlation_id": event.correlation_id,
         "verbose_name": event.verbose_name,
@@ -26,7 +27,7 @@ def serialize_before_execution(event: events.BeforeExecution) -> Optional[Dict[s
     }
 
 
-def _serialize_case(case: SerializedCase) -> Dict[str, Any]:
+def _serialize_case(case: SerializedCase) -> dict[str, Any]:
     return {
         "verbose_name": case.verbose_name,
         "path_template": case.path_template,
@@ -37,7 +38,7 @@ def _serialize_case(case: SerializedCase) -> Dict[str, Any]:
     }
 
 
-def _serialize_response(response: Response) -> Dict[str, Any]:
+def _serialize_response(response: Response) -> dict[str, Any]:
     return {
         "status_code": response.status_code,
         "headers": response.headers,
@@ -47,7 +48,7 @@ def _serialize_response(response: Response) -> Dict[str, Any]:
     }
 
 
-def serialize_after_execution(event: events.AfterExecution) -> Optional[Dict[str, Any]]:
+def serialize_after_execution(event: events.AfterExecution) -> dict[str, Any] | None:
     return {
         "correlation_id": event.correlation_id,
         "verbose_name": event.verbose_name,
@@ -76,22 +77,17 @@ def serialize_after_execution(event: events.AfterExecution) -> Optional[Dict[str
                 }
                 for check in event.result.checks
             ],
-            "errors": [
-                {
-                    "exception": error.exception,
-                    "exception_with_traceback": error.exception_with_traceback,
-                }
-                for error in event.result.errors
-            ],
+            "errors": [asdict(error) for error in event.result.errors],
+            "skip_reason": event.result.skip_reason,
         },
     }
 
 
-def serialize_interrupted(_: events.Interrupted) -> Optional[Dict[str, Any]]:
+def serialize_interrupted(_: events.Interrupted) -> dict[str, Any] | None:
     return None
 
 
-def serialize_internal_error(event: events.InternalError) -> Optional[Dict[str, Any]]:
+def serialize_internal_error(event: events.InternalError) -> dict[str, Any] | None:
     return {
         "type": event.type.value,
         "subtype": event.subtype.value if event.subtype else event.subtype,
@@ -104,7 +100,7 @@ def serialize_internal_error(event: events.InternalError) -> Optional[Dict[str,
     }
 
 
-def serialize_finished(event: events.Finished) -> Optional[Dict[str, Any]]:
+def serialize_finished(event: events.Finished) -> dict[str, Any] | None:
     return {
         "generic_errors": [
             {
@@ -131,14 +127,14 @@ SERIALIZER_MAP = {
 def serialize_event(
     event: events.ExecutionEvent,
     *,
-    on_initialized: Optional[SerializeFunc] = None,
-    on_before_execution: Optional[SerializeFunc] = None,
-    on_after_execution: Optional[SerializeFunc] = None,
-    on_interrupted: Optional[SerializeFunc] = None,
-    on_internal_error: Optional[SerializeFunc] = None,
-    on_finished: Optional[SerializeFunc] = None,
-    extra: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Optional[Dict[str, Any]]]:
+    on_initialized: SerializeFunc | None = None,
+    on_before_execution: SerializeFunc | None = None,
+    on_after_execution: SerializeFunc | None = None,
+    on_interrupted: SerializeFunc | None = None,
+    on_internal_error: SerializeFunc | None = None,
+    on_finished: SerializeFunc | None = None,
+    extra: dict[str, Any] | None = None,
+) -> dict[str, dict[str, Any] | None]:
     """Turn an event into JSON-serializable structure."""
     # Use the explicitly provided serializer for this event and fallback to default one if it is not provided
     serializer = {
@@ -163,7 +159,7 @@ def serialize_event(
     return {event.__class__.__name__: data}
 
 
-def stringify_path_parameters(path_parameters: Optional[Dict[str, Any]]) -> Dict[str, str]:
+def stringify_path_parameters(path_parameters: dict[str, Any] | None) -> dict[str, str]:
     """Cast all path parameter values to strings.
 
     Path parameter values may be of arbitrary type, but to display them properly they should be casted to strings.
@@ -171,14 +167,14 @@ def stringify_path_parameters(path_parameters: Optional[Dict[str, Any]]) -> Dict
     return {key: str(value) for key, value in (path_parameters or {}).items()}
 
 
-def prepare_query(query: Optional[Dict[str, Any]]) -> Dict[str, List[str]]:
+def prepare_query(query: dict[str, Any] | None) -> dict[str, list[str]]:
     """Convert all query values to list of strings.
 
     Query parameters may be generated in different shapes, including integers, strings, list of strings, etc.
     It can also be an object, if the schema contains an object, but `style` and `explode` combo is not applicable.
     """
 
-    def to_list_of_strings(value: Any) -> List[str]:
+    def to_list_of_strings(value: Any) -> list[str]:
         if isinstance(value, list):
             return list(map(str, value))
         if isinstance(value, str):

schemathesis/service/usage.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
 import sys
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 import click
 from click.types import StringParamType
@@ -7,14 +8,14 @@ from click.types import StringParamType
 from .. import cli, hooks
 
 
-def collect(args: Optional[List[str]] = None) -> Optional[Dict[str, Any]]:
+def collect(args: list[str] | None = None) -> dict[str, Any] | None:
     """Collect anonymized CLI usage data."""
-    context: Optional[click.Context] = click.get_current_context(silent=True)
+    context: click.Context | None = click.get_current_context(silent=True)
     if context is not None and not sys.argv[0].endswith("pytest"):
         args = args or sys.argv[2:]
         parameters, _, types = parse_cli_args(context, args)
-        parameters_data: Dict[str, Dict[str, Any]] = {}
-        used_headers: List[str] = []
+        parameters_data: dict[str, dict[str, Any]] = {}
+        used_headers: list[str] = []
         schema = parameters["schema"]
         app = parameters.get("app")
         if not schema:
@@ -43,7 +44,7 @@ def collect(args: Optional[List[str]] = None) -> Optional[Dict[str, Any]]:
     return None
 
 
-def _collect_option(option: str, option_type: click.Parameter, used_headers: List[str], value: Any) -> Dict[str, Any]:
+def _collect_option(option: str, option_type: click.Parameter, used_headers: list[str], value: Any) -> dict[str, Any]:
     entry = {}
     if isinstance(option_type.type, (StringParamType, click.types.File)):
         if option == "headers" and value:
@@ -59,6 +60,6 @@ def _collect_option(option: str, option_type: click.Parameter, used_headers: Lis
     return entry
 
 
-def parse_cli_args(context: click.Context, args: List[str]) -> Tuple[Dict[str, Any], List, List[click.Parameter]]:
+def parse_cli_args(context: click.Context, args: list[str]) -> tuple[dict[str, Any], list, list[click.Parameter]]:
     parser = cli.run.make_parser(context)
     return parser.parse_args(args=args)

schemathesis/specs/graphql/loaders.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 import pathlib
 from functools import lru_cache
 from json import JSONDecodeError
-from typing import IO, Any, Callable, Dict, Optional, Union, cast, TYPE_CHECKING
+from typing import IO, Any, Callable, Dict, cast, TYPE_CHECKING
 
 from ...code_samples import CodeSampleStyle
 from ...generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod, DataGenerationMethodInput
@@ -22,14 +22,14 @@ if TYPE_CHECKING:
     from .schemas import GraphQLSchema
 
 
-@lru_cache()
+@lru_cache
 def get_introspection_query() -> str:
     import graphql
 
     return graphql.get_introspection_query()
 
 
-@lru_cache()
+@lru_cache
 def get_introspection_query_ast() -> DocumentNode:
     import graphql
 
@@ -41,10 +41,10 @@ def from_path(
     path: PathLike,
     *,
     app: Any = None,
-    base_url: Optional[str] = None,
+    base_url: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
-    rate_limit: Optional[str] = None,
+    rate_limit: str | None = None,
     encoding: str = "utf8",
     sanitize_output: bool = True,
 ) -> GraphQLSchema:
@@ -66,7 +66,7 @@ def from_path(
         )
 
 
-def extract_schema_from_response(response: GenericResponse) -> Dict[str, Any]:
+def extract_schema_from_response(response: GenericResponse) -> dict[str, Any]:
     from requests import Response
 
     try:
@@ -86,12 +86,12 @@ def from_url(
     url: str,
     *,
     app: Any = None,
-    base_url: Optional[str] = None,
-    port: Optional[int] = None,
+    base_url: str | None = None,
+    port: int | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
-    wait_for_schema: Optional[float] = None,
-    rate_limit: Optional[str] = None,
+    wait_for_schema: float | None = None,
+    rate_limit: str | None = None,
     sanitize_output: bool = True,
     **kwargs: Any,
 ) -> GraphQLSchema:
@@ -145,14 +145,14 @@ def from_url(
 
 
 def from_file(
-    file: Union[IO[str], str],
+    file: IO[str] | str,
     *,
     app: Any = None,
-    base_url: Optional[str] = None,
+    base_url: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
-    location: Optional[str] = None,
-    rate_limit: Optional[str] = None,
+    location: str | None = None,
+    rate_limit: str | None = None,
     sanitize_output: bool = True,
 ) -> GraphQLSchema:
     """Load GraphQL schema from a file descriptor or a string.
@@ -165,7 +165,14 @@ def from_file(
         data = file
     else:
         data = file.read()
-    document = graphql.build_schema(data)
+    try:
+        document = graphql.build_schema(data)
+    except Exception as exc:
+        raise SchemaError(
+            SchemaErrorType.GRAPHQL_INVALID_SCHEMA,
+            "The provided API schema does not appear to be a valid GraphQL schema",
+            extras=[entry for entry in str(exc).splitlines() if entry],
+        ) from exc
     result = graphql.execute(document, get_introspection_query_ast())
     # TYPES: We don't pass `is_awaitable` above, therefore `result` is of the `ExecutionResult` type
     result = cast(graphql.ExecutionResult, result)
@@ -187,14 +194,14 @@ def from_file(
 
 
 def from_dict(
-    raw_schema: Dict[str, Any],
+    raw_schema: dict[str, Any],
     *,
     app: Any = None,
-    base_url: Optional[str] = None,
-    location: Optional[str] = None,
+    base_url: str | None = None,
+    location: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
-    rate_limit: Optional[str] = None,
+    rate_limit: str | None = None,
     sanitize_output: bool = True,
 ) -> GraphQLSchema:
     """Load GraphQL schema from a Python dictionary.
@@ -212,7 +219,7 @@ def from_dict(
     if "data" in raw_schema:
         raw_schema = raw_schema["data"]
     dispatch("before_load_schema", hook_context, raw_schema)
-    rate_limiter: Optional[Limiter] = None
+    rate_limiter: Limiter | None = None
     if rate_limit is not None:
         rate_limiter = build_limiter(rate_limit)
     instance = GraphQLSchema(
@@ -233,10 +240,10 @@ def from_wsgi(
     schema_path: str,
     app: Any,
     *,
-    base_url: Optional[str] = None,
+    base_url: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
-    rate_limit: Optional[str] = None,
+    rate_limit: str | None = None,
     sanitize_output: bool = True,
     **kwargs: Any,
 ) -> GraphQLSchema:
@@ -272,10 +279,10 @@ def from_asgi(
     schema_path: str,
     app: Any,
     *,
-    base_url: Optional[str] = None,
+    base_url: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
-    rate_limit: Optional[str] = None,
+    rate_limit: str | None = None,
     sanitize_output: bool = True,
     **kwargs: Any,
 ) -> GraphQLSchema:

schemathesis/specs/graphql/nodes.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Optional
+from __future__ import annotations
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from graphql import ValueNode
@@ -17,7 +18,7 @@ __all__ = [  # noqa: F822
 ]
 
 
-def __getattr__(name: str) -> Optional["ValueNode"]:
+def __getattr__(name: str) -> ValueNode | None:
     if name in __all__:
         import hypothesis_graphql.nodes