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

schemathesis/cli/__init__.py

@@ -7,17 +7,16 @@ import sys
 import traceback
 import warnings
 from collections import defaultdict
-from contextlib import suppress
 from dataclasses import dataclass
 from enum import Enum
 from queue import Queue
-from typing import Any, Callable, Dict, Generator, Iterable, List, NoReturn, Optional, Tuple, Union, cast, TYPE_CHECKING
+from typing import Any, Callable, Generator, Iterable, NoReturn, cast, TYPE_CHECKING
 from urllib.parse import urlparse
 
 import click
 
 from .. import checks as checks_module
-from .. import contrib, experimental
+from .. import contrib, experimental, generation
 from .. import fixups as _fixups
 from .. import runner, service
 from .. import targets as targets_module
@@ -35,7 +34,7 @@ from ..constants import (
     EXTENSIONS_DOCUMENTATION_URL,
     ISSUE_TRACKER_URL,
 )
-from ..exceptions import SchemaError, extract_nth_traceback
+from ..exceptions import SchemaError, extract_nth_traceback, SchemaErrorType
 from ..fixups import ALL_FIXUPS
 from ..loaders import load_app, load_yaml
 from ..transports.auth import get_requests_auth
@@ -66,7 +65,7 @@ if TYPE_CHECKING:
     from .handlers import EventHandler
 
 
-def _get_callable_names(items: Tuple[Callable, ...]) -> Tuple[str, ...]:
+def _get_callable_names(items: tuple[Callable, ...]) -> tuple[str, ...]:
     return tuple(item.__name__ for item in items)
 
 
@@ -91,6 +90,10 @@ DEPRECATED_PRE_RUN_OPTION_WARNING = (
     "Warning: Option `--pre-run` is deprecated and will be removed in Schemathesis 4.0. "
     f"Use the `{HOOKS_MODULE_ENV_VAR}` environment variable instead"
 )
+DEPRECATED_SHOW_ERROR_TRACEBACKS_OPTION_WARNING = (
+    "Warning: Option `--show-errors-tracebacks` is deprecated and will be removed in Schemathesis 4.0. "
+    "Use `--show-trace` instead"
+)
 CASSETTES_PATH_INVALID_USAGE_MESSAGE = "Can't use `--store-network-log` and `--cassette-path` simultaneously"
 COLOR_OPTIONS_INVALID_USAGE_MESSAGE = "Can't use `--no-color` and `--force-color` simultaneously"
 
@@ -109,29 +112,13 @@ def reset_targets() -> None:
     TARGETS_TYPE.choices = _get_callable_names(targets_module.ALL_TARGETS) + ("all",)
 
 
-class DeprecatedOption(click.Option):
-    def __init__(self, *args: Any, removed_in: str, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-        self.removed_in = removed_in
-
-    def handle_parse_result(self, ctx: click.Context, opts: Dict[str, Any], args: List[str]) -> Tuple[Any, List[str]]:
-        if self.name in opts:
-            opt_names = "/".join(f"`{name}`" for name in self.opts)
-            verb = "is" if len(self.opts) == 1 else "are"
-            click.secho(
-                f"\nWARNING: {opt_names} {verb} deprecated and will be removed in Schemathesis {self.removed_in}\n",
-                fg="yellow",
-            )
-        return super().handle_parse_result(ctx, opts, args)
-
-
 @click.group(context_settings=CONTEXT_SETTINGS)
 @click.option("--pre-run", help="A module to execute before running the tests.", type=str, hidden=True)
 @click.version_option()
-def schemathesis(pre_run: Optional[str] = None) -> None:
+def schemathesis(pre_run: str | None = None) -> None:
     """Automated API testing employing fuzzing techniques for OpenAPI and GraphQL."""
     # Don't use `envvar=HOOKS_MODULE_ENV_VAR` arg to raise a deprecation warning for hooks
-    hooks: Optional[str]
+    hooks: str | None
     if pre_run:
         click.secho(DEPRECATED_PRE_RUN_OPTION_WARNING, fg="yellow")
         hooks = pre_run
@@ -463,6 +450,15 @@ The report data, consisting of a tar gz file with multiple JSON files, is subjec
     is_flag=True,
     is_eager=True,
     default=False,
+    hidden=True,
+    show_default=True,
+)
+@click.option(
+    "--show-trace",
+    help="Displays complete traceback information for internal errors.",
+    is_flag=True,
+    is_eager=True,
+    default=False,
     show_default=True,
 )
 @click.option(
@@ -486,8 +482,9 @@ The report data, consisting of a tar gz file with multiple JSON files, is subjec
 )
 @click.option(
     "--store-network-log",
-    help="[DEPRECATED] Saves the test outcomes in a VCR-compatible format.",
+    help="Saves the test outcomes in a VCR-compatible format.",
     type=click.File("w", encoding="utf-8"),
+    hidden=True,
 )
 @click.option(
     "--fixups",
@@ -515,8 +512,7 @@ The report data, consisting of a tar gz file with multiple JSON files, is subjec
     default=DEFAULT_STATEFUL_RECURSION_LIMIT,
     show_default=True,
     type=click.IntRange(1, 100),
-    cls=DeprecatedOption,
-    removed_in="4.0",
+    hidden=True,
 )
 @click.option(
     "--force-schema-version",
@@ -628,6 +624,20 @@ The report data, consisting of a tar gz file with multiple JSON files, is subjec
     callback=callbacks.convert_experimental,
     multiple=True,
 )
+@click.option(
+    "--generation-allow-x00",
+    help="Determines whether to allow the generation of `\x00` bytes within strings.",
+    type=str,
+    default="true",
+    show_default=True,
+    callback=callbacks.convert_boolean_string,
+)
+@click.option(
+    "--generation-codec",
+    help="Specifies the codec used for generating strings.",
+    type=str,
+    default="utf-8",
+)
 @click.option(
     "--schemathesis-io-token",
     help="Schemathesis.io authentication token.",
@@ -656,61 +666,64 @@ The report data, consisting of a tar gz file with multiple JSON files, is subjec
 def run(
     ctx: click.Context,
     schema: str,
-    api_name: Optional[str],
-    auth: Optional[Tuple[str, str]],
+    api_name: str | None,
+    auth: tuple[str, str] | None,
     auth_type: str,
-    headers: Dict[str, str],
+    headers: dict[str, str],
     experimental: list,
     checks: Iterable[str] = DEFAULT_CHECKS_NAMES,
     exclude_checks: Iterable[str] = (),
-    data_generation_methods: Tuple[DataGenerationMethod, ...] = DEFAULT_DATA_GENERATION_METHODS,
-    max_response_time: Optional[int] = None,
+    data_generation_methods: tuple[DataGenerationMethod, ...] = DEFAULT_DATA_GENERATION_METHODS,
+    max_response_time: int | None = None,
     targets: Iterable[str] = DEFAULT_TARGETS_NAMES,
     exit_first: bool = False,
-    max_failures: Optional[int] = None,
+    max_failures: int | None = None,
     dry_run: bool = False,
-    endpoints: Optional[Filter] = None,
-    methods: Optional[Filter] = None,
-    tags: Optional[Filter] = None,
-    operation_ids: Optional[Filter] = None,
+    endpoints: Filter | None = None,
+    methods: Filter | None = None,
+    tags: Filter | None = None,
+    operation_ids: Filter | None = None,
     workers_num: int = DEFAULT_WORKERS,
-    base_url: Optional[str] = None,
-    app: Optional[str] = None,
-    request_timeout: Optional[int] = None,
+    base_url: str | None = None,
+    app: str | None = None,
+    request_timeout: int | None = None,
     request_tls_verify: bool = True,
-    request_cert: Optional[str] = None,
-    request_cert_key: Optional[str] = None,
+    request_cert: str | None = None,
+    request_cert_key: str | None = None,
     validate_schema: bool = True,
     skip_deprecated_operations: bool = False,
-    junit_xml: Optional[click.utils.LazyFile] = None,
-    debug_output_file: Optional[click.utils.LazyFile] = None,
+    junit_xml: click.utils.LazyFile | None = None,
+    debug_output_file: click.utils.LazyFile | None = None,
     show_errors_tracebacks: bool = False,
+    show_trace: bool = False,
     code_sample_style: CodeSampleStyle = CodeSampleStyle.default(),
-    cassette_path: Optional[click.utils.LazyFile] = None,
+    cassette_path: click.utils.LazyFile | None = None,
     cassette_preserve_exact_body_bytes: bool = False,
-    store_network_log: Optional[click.utils.LazyFile] = None,
-    wait_for_schema: Optional[float] = None,
-    fixups: Tuple[str] = (),  # type: ignore
-    rate_limit: Optional[str] = None,
-    stateful: Optional[Stateful] = None,
+    store_network_log: click.utils.LazyFile | None = None,
+    wait_for_schema: float | None = None,
+    fixups: tuple[str] = (),  # type: ignore
+    rate_limit: str | None = None,
+    stateful: Stateful | None = None,
     stateful_recursion_limit: int = DEFAULT_STATEFUL_RECURSION_LIMIT,
-    force_schema_version: Optional[str] = None,
+    force_schema_version: str | None = None,
     sanitize_output: bool = True,
     contrib_unique_data: bool = False,
     contrib_openapi_formats_uuid: bool = False,
-    hypothesis_database: Optional[str] = None,
-    hypothesis_deadline: Optional[Union[int, NotSet]] = None,
-    hypothesis_derandomize: Optional[bool] = None,
-    hypothesis_max_examples: Optional[int] = None,
-    hypothesis_phases: Optional[List[Phase]] = None,
-    hypothesis_report_multiple_bugs: Optional[bool] = None,
-    hypothesis_suppress_health_check: Optional[List[HealthCheck]] = None,
-    hypothesis_seed: Optional[int] = None,
-    hypothesis_verbosity: Optional[hypothesis.Verbosity] = None,
+    hypothesis_database: str | None = None,
+    hypothesis_deadline: int | NotSet | None = None,
+    hypothesis_derandomize: bool | None = None,
+    hypothesis_max_examples: int | None = None,
+    hypothesis_phases: list[Phase] | None = None,
+    hypothesis_report_multiple_bugs: bool | None = None,
+    hypothesis_suppress_health_check: list[HealthCheck] | None = None,
+    hypothesis_seed: int | None = None,
+    hypothesis_verbosity: hypothesis.Verbosity | None = None,
     verbosity: int = 0,
     no_color: bool = False,
-    report_value: Optional[str] = None,
-    schemathesis_io_token: Optional[str] = None,
+    report_value: str | None = None,
+    generation_allow_x00: bool = True,
+    generation_codec: str = "utf-8",
+    schemathesis_io_token: str | None = None,
     schemathesis_io_url: str = service.DEFAULT_URL,
     schemathesis_io_telemetry: bool = True,
     hosts_file: PathLike = service.DEFAULT_HOSTS_PATH,
@@ -722,20 +735,26 @@ def run(
 
     [Optional] API_NAME: Identifier for uploading test data to Schemathesis.io.
     """
-    _hypothesis_phases: Optional[List[hypothesis.Phase]] = None
+    _hypothesis_phases: list[hypothesis.Phase] | None = None
     if hypothesis_phases is not None:
         _hypothesis_phases = [phase.as_hypothesis() for phase in hypothesis_phases]
-    _hypothesis_suppress_health_check: Optional[List[hypothesis.HealthCheck]] = None
+    _hypothesis_suppress_health_check: list[hypothesis.HealthCheck] | None = None
     if hypothesis_suppress_health_check is not None:
         _hypothesis_suppress_health_check = [
             health_check.as_hypothesis() for health_check in hypothesis_suppress_health_check
         ]
 
+    if show_errors_tracebacks:
+        click.secho(DEPRECATED_SHOW_ERROR_TRACEBACKS_OPTION_WARNING, fg="yellow")
+        show_trace = show_errors_tracebacks
+
     # Enable selected experiments
     for experiment in experimental:
         experiment.enable()
 
-    report: Optional[Union[ReportToService, click.utils.LazyFile]]
+    generation_config = generation.GenerationConfig(allow_x00=generation_allow_x00, codec=generation_codec)
+
+    report: ReportToService | click.utils.LazyFile | None
     if report_value is None:
         report = None
     elif report_value:
@@ -762,6 +781,7 @@ def run(
     schema_kind = callbacks.parse_schema_kind(schema, app)
     callbacks.validate_schema(schema, schema_kind, base_url=base_url, dry_run=dry_run, app=app, api_name=api_name)
     client = None
+    schema_or_location: str | dict[str, Any] = schema
     if schema_kind == callbacks.SchemaInputKind.NAME:
         api_name = schema
     if (
@@ -785,18 +805,7 @@ def run(
                     f"\nYou've specified an API name, suggesting you want to upload data to {bold(hostname)}. "
                     "However, your CLI is not currently authenticated."
                 )
-                click.secho("\nTo authenticate:")
-                click.secho(f"1. Retrieve your token from {bold(hostname)}")
-                click.secho(f"2. Execute {bold('`st auth login <TOKEN>`')}")
-                env_var = bold(f"`{service.TOKEN_ENV_VAR}`")
-                click.secho(
-                    f"\nAs an alternative, supply the token directly "
-                    f"using the {bold('`--schemathesis-io-token`')} option "
-                    f"or the {env_var} environment variable."
-                )
-                click.echo(
-                    "\nFor more information, please visit: https://schemathesis.readthedocs.io/en/stable/service.html"
-                )
+                output.default.display_service_unauthorized(hostname)
                 raise click.exceptions.Exit(1) from None
             name: str = cast(str, api_name)
             import requests
@@ -804,8 +813,9 @@ def run(
             try:
                 details = client.get_api_details(name)
                 # Replace config values with ones loaded from the service
-                schema = details.location
-                base_url = base_url or details.base_url
+                schema_or_location = details.specification.schema
+                default_environment = details.default_environment
+                base_url = base_url or (default_environment.url if default_environment else None)
             except requests.HTTPError as exc:
                 handle_service_error(exc, name)
     if report is REPORT_TO_SERVICE and not client:
@@ -844,7 +854,7 @@ def run(
         verbosity=hypothesis_verbosity,
     )
     event_stream = into_event_stream(
-        schema,
+        schema_or_location,
         app=app,
         base_url=base_url,
         started_at=started_at,
@@ -876,13 +886,14 @@ def run(
         stateful=stateful,
         stateful_recursion_limit=stateful_recursion_limit,
         hypothesis_settings=hypothesis_settings,
+        generation_config=generation_config,
     )
     execute(
         event_stream,
         hypothesis_settings=hypothesis_settings,
         workers_num=workers_num,
         rate_limit=rate_limit,
-        show_errors_tracebacks=show_errors_tracebacks,
+        show_trace=show_trace,
         wait_for_schema=wait_for_schema,
         validate_schema=validate_schema,
         cassette_path=cassette_path,
@@ -904,7 +915,7 @@ def run(
     )
 
 
-def prepare_request_cert(cert: Optional[str], key: Optional[str]) -> Optional[RequestCert]:
+def prepare_request_cert(cert: str | None, key: str | None) -> RequestCert | None:
     if cert is not None and key is not None:
         return cert, key
     return cert
@@ -917,71 +928,72 @@ class LoaderConfig:
     The main goal is to avoid too many parameters in function signatures.
     """
 
-    schema_location: str
+    schema_or_location: str | dict[str, Any]
     app: Any
-    base_url: Optional[str]
+    base_url: str | None
     validate_schema: bool
     skip_deprecated_operations: bool
-    data_generation_methods: Tuple[DataGenerationMethod, ...]
-    force_schema_version: Optional[str]
-    request_tls_verify: Union[bool, str]
-    request_cert: Optional[RequestCert]
-    wait_for_schema: Optional[float]
-    rate_limit: Optional[str]
+    data_generation_methods: tuple[DataGenerationMethod, ...]
+    force_schema_version: str | None
+    request_tls_verify: bool | str
+    request_cert: RequestCert | None
+    wait_for_schema: float | None
+    rate_limit: str | None
     # Network request parameters
-    auth: Optional[Tuple[str, str]]
-    auth_type: Optional[str]
-    headers: Optional[Dict[str, str]]
+    auth: tuple[str, str] | None
+    auth_type: str | None
+    headers: dict[str, str] | None
     # Schema filters
-    endpoint: Optional[Filter]
-    method: Optional[Filter]
-    tag: Optional[Filter]
-    operation_id: Optional[Filter]
+    endpoint: Filter | None
+    method: Filter | None
+    tag: Filter | None
+    operation_id: Filter | None
 
 
 def into_event_stream(
-    schema_location: str,
+    schema_or_location: str | dict[str, Any],
     *,
     app: Any,
-    base_url: Optional[str],
+    base_url: str | None,
     started_at: str,
     validate_schema: bool,
     skip_deprecated_operations: bool,
-    data_generation_methods: Tuple[DataGenerationMethod, ...],
-    force_schema_version: Optional[str],
-    request_tls_verify: Union[bool, str],
-    request_cert: Optional[RequestCert],
+    data_generation_methods: tuple[DataGenerationMethod, ...],
+    force_schema_version: str | None,
+    request_tls_verify: bool | str,
+    request_cert: RequestCert | None,
     # Network request parameters
-    auth: Optional[Tuple[str, str]],
-    auth_type: Optional[str],
-    headers: Optional[Dict[str, str]],
-    request_timeout: Optional[int],
-    wait_for_schema: Optional[float],
+    auth: tuple[str, str] | None,
+    auth_type: str | None,
+    headers: dict[str, str] | None,
+    request_timeout: int | None,
+    wait_for_schema: float | None,
     # Schema filters
-    endpoint: Optional[Filter],
-    method: Optional[Filter],
-    tag: Optional[Filter],
-    operation_id: Optional[Filter],
+    endpoint: Filter | None,
+    method: Filter | None,
+    tag: Filter | None,
+    operation_id: Filter | None,
     # Runtime behavior
     checks: Iterable[CheckFunction],
-    max_response_time: Optional[int],
+    max_response_time: int | None,
     targets: Iterable[Target],
     workers_num: int,
-    hypothesis_settings: Optional[hypothesis.settings],
-    seed: Optional[int],
+    hypothesis_settings: hypothesis.settings | None,
+    generation_config: generation.GenerationConfig,
+    seed: int | None,
     exit_first: bool,
-    max_failures: Optional[int],
-    rate_limit: Optional[str],
+    max_failures: int | None,
+    rate_limit: str | None,
     dry_run: bool,
     store_interactions: bool,
-    stateful: Optional[Stateful],
+    stateful: Stateful | None,
     stateful_recursion_limit: int,
 ) -> Generator[events.ExecutionEvent, None, None]:
     try:
         if app is not None:
             app = load_app(app)
         config = LoaderConfig(
-            schema_location=schema_location,
+            schema_or_location=schema_or_location,
             app=app,
             base_url=base_url,
             validate_schema=validate_schema,
@@ -1022,6 +1034,7 @@ def into_event_stream(
             stateful=stateful,
             stateful_recursion_limit=stateful_recursion_limit,
             hypothesis_settings=hypothesis_settings,
+            generation_config=generation_config,
         ).execute()
     except SchemaError as error:
         yield events.InternalError.from_schema_error(error)
@@ -1033,7 +1046,7 @@ def load_schema(config: LoaderConfig) -> BaseSchema:
     """Automatically load API schema."""
     first: Callable[[LoaderConfig], BaseSchema]
     second: Callable[[LoaderConfig], BaseSchema]
-    if is_probably_graphql(config.schema_location):
+    if is_probably_graphql(config.schema_or_location):
         # Try GraphQL first, then fallback to Open API
         first, second = (_load_graphql_schema, _load_openapi_schema)
     else:
@@ -1049,9 +1062,10 @@ def should_try_more(exc: SchemaError) -> bool:
     return not isinstance(exc.__cause__, requests.exceptions.ConnectionError)
 
 
-def _try_load_schema(
-    config: LoaderConfig, first: Callable[[LoaderConfig], BaseSchema], second: Callable[[LoaderConfig], BaseSchema]
-) -> BaseSchema:
+Loader = Callable[[LoaderConfig], "BaseSchema"]
+
+
+def _try_load_schema(config: LoaderConfig, first: Loader, second: Loader) -> BaseSchema:
     from urllib3.exceptions import InsecureRequestWarning
 
     with warnings.catch_warnings():
@@ -1060,38 +1074,51 @@ def _try_load_schema(
             return first(config)
         except SchemaError as exc:
             if should_try_more(exc):
-                with suppress(Exception):
+                try:
                     return second(config)
+                except Exception as second_exc:
+                    if is_specific_exception(second, second_exc):
+                        raise second_exc
             # Re-raise the original error
             raise exc
 
 
+def is_specific_exception(loader: Loader, exc: Exception) -> bool:
+    return (
+        loader is _load_graphql_schema
+        and isinstance(exc, SchemaError)
+        and exc.type == SchemaErrorType.GRAPHQL_INVALID_SCHEMA
+    )
+
+
 def _load_graphql_schema(config: LoaderConfig) -> GraphQLSchema:
-    loader = detect_loader(config.schema_location, config.app, is_openapi=False)
+    loader = detect_loader(config.schema_or_location, config.app, is_openapi=False)
     kwargs = get_graphql_loader_kwargs(loader, config)
-    return loader(config.schema_location, **kwargs)
+    return loader(config.schema_or_location, **kwargs)
 
 
 def _load_openapi_schema(config: LoaderConfig) -> BaseSchema:
-    loader = detect_loader(config.schema_location, config.app, is_openapi=True)
+    loader = detect_loader(config.schema_or_location, config.app, is_openapi=True)
     kwargs = get_loader_kwargs(loader, config)
-    return loader(config.schema_location, **kwargs)
+    return loader(config.schema_or_location, **kwargs)
 
 
-def detect_loader(schema_location: str, app: Any, is_openapi: bool) -> Callable:
+def detect_loader(schema_or_location: str | dict[str, Any], app: Any, is_openapi: bool) -> Callable:
     """Detect API schema loader."""
-    if file_exists(schema_location):
-        # If there is an existing file with the given name,
-        # then it is likely that the user wants to load API schema from there
-        return oas_loaders.from_path if is_openapi else gql_loaders.from_path  # type: ignore
-    if app is not None and not urlparse(schema_location).netloc:
-        # App is passed & location is relative
-        return oas_loaders.get_loader_for_app(app) if is_openapi else gql_loaders.get_loader_for_app(app)
-    # Default behavior
-    return oas_loaders.from_uri if is_openapi else gql_loaders.from_url  # type: ignore
-
-
-def get_loader_kwargs(loader: Callable, config: LoaderConfig) -> Dict[str, Any]:
+    if isinstance(schema_or_location, str):
+        if file_exists(schema_or_location):
+            # If there is an existing file with the given name,
+            # then it is likely that the user wants to load API schema from there
+            return oas_loaders.from_path if is_openapi else gql_loaders.from_path  # type: ignore
+        if app is not None and not urlparse(schema_or_location).netloc:
+            # App is passed & location is relative
+            return oas_loaders.get_loader_for_app(app) if is_openapi else gql_loaders.get_loader_for_app(app)
+        # Default behavior
+        return oas_loaders.from_uri if is_openapi else gql_loaders.from_url  # type: ignore
+    return oas_loaders.from_dict if is_openapi else gql_loaders.from_dict  # type: ignore
+
+
+def get_loader_kwargs(loader: Callable, config: LoaderConfig) -> dict[str, Any]:
     """Detect the proper set of parameters for a loader."""
     # These kwargs are shared by all loaders
     kwargs = {
@@ -1107,7 +1134,7 @@ def get_loader_kwargs(loader: Callable, config: LoaderConfig) -> Dict[str, Any]:
         "data_generation_methods": config.data_generation_methods,
         "rate_limit": config.rate_limit,
     }
-    if loader is not oas_loaders.from_path:
+    if loader not in (oas_loaders.from_path, oas_loaders.from_dict):
         kwargs["headers"] = config.headers
     if loader in (oas_loaders.from_uri, oas_loaders.from_aiohttp):
         _add_requests_kwargs(kwargs, config)
@@ -1117,7 +1144,7 @@ def get_loader_kwargs(loader: Callable, config: LoaderConfig) -> Dict[str, Any]:
 def get_graphql_loader_kwargs(
     loader: Callable,
     config: LoaderConfig,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Detect the proper set of parameters for a loader."""
     # These kwargs are shared by all loaders
     kwargs = {
@@ -1126,14 +1153,14 @@ def get_graphql_loader_kwargs(
         "data_generation_methods": config.data_generation_methods,
         "rate_limit": config.rate_limit,
     }
-    if loader is not gql_loaders.from_path:
+    if loader not in (gql_loaders.from_path, gql_loaders.from_dict):
         kwargs["headers"] = config.headers
     if loader is gql_loaders.from_url:
         _add_requests_kwargs(kwargs, config)
     return kwargs
 
 
-def _add_requests_kwargs(kwargs: Dict[str, Any], config: LoaderConfig) -> None:
+def _add_requests_kwargs(kwargs: dict[str, Any], config: LoaderConfig) -> None:
     kwargs["verify"] = config.request_tls_verify
     if config.request_cert is not None:
         kwargs["cert"] = config.request_cert
@@ -1143,12 +1170,16 @@ def _add_requests_kwargs(kwargs: Dict[str, Any], config: LoaderConfig) -> None:
         kwargs["wait_for_schema"] = config.wait_for_schema
 
 
-def is_probably_graphql(location: str) -> bool:
+def is_probably_graphql(schema_or_location: str | dict[str, Any]) -> bool:
     """Detect whether it is likely that the given location is a GraphQL endpoint."""
-    return location.endswith(("/graphql", "/graphql/"))
+    if isinstance(schema_or_location, str):
+        return schema_or_location.endswith(("/graphql", "/graphql/", ".graphql", ".gql"))
+    return "__schema" in schema_or_location or (
+        "data" in schema_or_location and "__schema" in schema_or_location["data"]
+    )
 
 
-def check_auth(auth: Optional[Tuple[str, str]], headers: Dict[str, str]) -> None:
+def check_auth(auth: tuple[str, str] | None, headers: dict[str, str]) -> None:
     if auth is not None and "authorization" in {header.lower() for header in headers}:
         raise click.BadParameter(
             "The `--auth` and `--header` options were both used to set "
@@ -1199,30 +1230,30 @@ def execute(
     *,
     hypothesis_settings: hypothesis.settings,
     workers_num: int,
-    rate_limit: Optional[str],
-    show_errors_tracebacks: bool,
-    wait_for_schema: Optional[float],
+    rate_limit: str | None,
+    show_trace: bool,
+    wait_for_schema: float | None,
     validate_schema: bool,
-    cassette_path: Optional[click.utils.LazyFile],
+    cassette_path: click.utils.LazyFile | None,
     cassette_preserve_exact_body_bytes: bool,
-    junit_xml: Optional[click.utils.LazyFile],
+    junit_xml: click.utils.LazyFile | None,
     verbosity: int,
     code_sample_style: CodeSampleStyle,
-    data_generation_methods: Tuple[DataGenerationMethod, ...],
-    debug_output_file: Optional[click.utils.LazyFile],
+    data_generation_methods: tuple[DataGenerationMethod, ...],
+    debug_output_file: click.utils.LazyFile | None,
     sanitize_output: bool,
     host_data: service.hosts.HostData,
-    client: Optional[ServiceClient],
-    report: Optional[Union[ReportToService, click.utils.LazyFile]],
+    client: ServiceClient | None,
+    report: ReportToService | click.utils.LazyFile | None,
     telemetry: bool,
-    api_name: Optional[str],
+    api_name: str | None,
     location: str,
-    base_url: Optional[str],
+    base_url: str | None,
     started_at: str,
 ) -> None:
     """Execute a prepared runner by drawing events from it and passing to a proper handler."""
-    handlers: List[EventHandler] = []
-    report_context: Optional[Union[ServiceReportContext, FileReportContext]] = None
+    handlers: list[EventHandler] = []
+    report_context: ServiceReportContext | FileReportContext | None = None
     report_queue: Queue
     if client:
         # If API name is specified, validate it
@@ -1270,7 +1301,7 @@ def execute(
         hypothesis_settings=hypothesis_settings,
         workers_num=workers_num,
         rate_limit=rate_limit,
-        show_errors_tracebacks=show_errors_tracebacks,
+        show_trace=show_trace,
         wait_for_schema=wait_for_schema,
         validate_schema=validate_schema,
         cassette_path=cassette_path.name if cassette_path is not None else None,
@@ -1362,7 +1393,7 @@ def handle_service_error(exc: requests.HTTPError, api_name: str) -> NoReturn:
     elif response.status_code == 404:
         error_message(f"API with name `{api_name}` not found!")
     else:
-        output.default.display_service_error(service.Error(exc))
+        output.default.display_service_error(service.Error(exc), message_prefix="❌ ")
     sys.exit(1)
 
 
@@ -1392,15 +1423,15 @@ def get_exit_code(event: events.ExecutionEvent) -> int:
 def replay(
     ctx: click.Context,
     cassette_path: str,
-    id_: Optional[str],
-    status: Optional[str] = None,
-    uri: Optional[str] = None,
-    method: Optional[str] = None,
+    id_: str | None,
+    status: str | None = None,
+    uri: str | None = None,
+    method: str | None = None,
     no_color: bool = False,
     verbosity: int = 0,
     request_tls_verify: bool = True,
-    request_cert: Optional[str] = None,
-    request_cert_key: Optional[str] = None,
+    request_cert: str | None = None,
+    request_cert_key: str | None = None,
     force_color: bool = False,
 ) -> None:
     """Replay a cassette.
@@ -1467,7 +1498,7 @@ def upload(
     hosts_file: str,
     request_tls_verify: bool = True,
     schemathesis_io_url: str = service.DEFAULT_URL,
-    schemathesis_io_token: Optional[str] = None,
+    schemathesis_io_token: str | None = None,
 ) -> None:
     """Upload report to Schemathesis.io."""
     from ..service.client import ServiceClient
@@ -1579,7 +1610,7 @@ def decide_color_output(ctx: click.Context, no_color: bool, force_color: bool) -
 
 @HookDispatcher.register_spec([HookScope.GLOBAL])
 def after_init_cli_run_handlers(
-    context: HookContext, handlers: List[EventHandler], execution_context: ExecutionContext
+    context: HookContext, handlers: list[EventHandler], execution_context: ExecutionContext
 ) -> None:
     """Called after CLI hooks are initialized.
 
@@ -1588,7 +1619,7 @@ def after_init_cli_run_handlers(
 
 
 @HookDispatcher.register_spec([HookScope.GLOBAL])
-def process_call_kwargs(context: HookContext, case: Case, kwargs: Dict[str, Any]) -> None:
+def process_call_kwargs(context: HookContext, case: Case, kwargs: dict[str, Any]) -> None:
     """Called before every network call in CLI tests.
 
     Aims to modify the argument passed to `case.call` / `case.call_wsgi` / `case.call_asgi`.