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

schemathesis/cli/output/default.py

@@ -7,12 +7,12 @@ import textwrap
 import time
 from itertools import groupby
 from queue import Queue
-from typing import Any, Dict, Generator, List, Optional, Tuple, Union, cast
+from typing import Any, Generator, cast
 
 import click
+from importlib import metadata
 
 from ... import service
-from ..._compat import metadata
 from ...code_samples import CodeSampleStyle
 from ...constants import (
     DISCORD_LINK,
@@ -48,7 +48,7 @@ def display_section_name(title: str, separator: str = "=", **kwargs: Any) -> Non
     click.secho(message, **kwargs)
 
 
-def display_subsection(result: SerializedTestResult, color: Optional[str] = "red") -> None:
+def display_subsection(result: SerializedTestResult, color: str | None = "red") -> None:
     display_section_name(result.verbose_name, "_", fg=color)
 
 
@@ -87,7 +87,7 @@ def display_summary(event: events.Finished) -> None:
     display_section_name(message, fg=color)
 
 
-def get_summary_message_parts(event: events.Finished) -> List[str]:
+def get_summary_message_parts(event: events.Finished) -> list[str]:
     parts = []
     passed = event.passed_count
     if passed:
@@ -104,7 +104,7 @@ def get_summary_message_parts(event: events.Finished) -> List[str]:
     return parts
 
 
-def get_summary_output(event: events.Finished) -> Tuple[str, str]:
+def get_summary_output(event: events.Finished) -> tuple[str, str]:
     parts = get_summary_message_parts(event)
     if not parts:
         message = "Empty test suite"
@@ -120,7 +120,7 @@ def get_summary_output(event: events.Finished) -> Tuple[str, str]:
     return message, color
 
 
-def display_hypothesis_output(hypothesis_output: List[str]) -> None:
+def display_hypothesis_output(hypothesis_output: list[str]) -> None:
     """Show falsifying examples from Hypothesis output if there are any."""
     if hypothesis_output:
         display_section_name("HYPOTHESIS OUTPUT")
@@ -147,9 +147,9 @@ def display_errors(context: ExecutionContext, event: events.Finished) -> None:
         should_display_full_traceback_message |= display_single_error(context, result)
     if event.generic_errors:
         display_generic_errors(context, event.generic_errors)
-    if should_display_full_traceback_message and not context.show_errors_tracebacks:
+    if should_display_full_traceback_message and not context.show_trace:
         click.secho(
-            "\nAdd this option to your command line parameters to see full tracebacks: --show-errors-tracebacks",
+            "\nAdd this option to your command line parameters to see full tracebacks: --show-trace",
             fg="red",
         )
     click.secho(
@@ -166,7 +166,7 @@ def display_single_error(context: ExecutionContext, result: SerializedTestResult
     return should_display_full_traceback_message
 
 
-def display_generic_errors(context: ExecutionContext, errors: List[SerializedError]) -> None:
+def display_generic_errors(context: ExecutionContext, errors: list[SerializedError]) -> None:
     for error in errors:
         display_section_name(error.title or "Generic error", "_", fg="red")
         _display_error(context, error)
@@ -181,6 +181,7 @@ def display_full_traceback_message(error: SerializedError) -> bool:
             "requests.exceptions",
             "SerializationNotPossible",
             "hypothesis.errors.FailedHealthCheck",
+            "hypothesis.errors.InvalidArgument: Scalar ",
         )
     )
 
@@ -207,8 +208,10 @@ RUNTIME_ERROR_SUGGESTIONS = {
     ),
     RuntimeErrorType.HYPOTHESIS_UNSATISFIABLE: "Examine the schema for inconsistencies and consider simplifying it.",
     RuntimeErrorType.SCHEMA_BODY_IN_GET_REQUEST: DISABLE_SCHEMA_VALIDATION_SUGGESTION,
-    RuntimeErrorType.SCHEMA_INVALID_REGULAR_EXPRESSION: "Ensure your regex is compatible with Python's syntax. "
+    RuntimeErrorType.SCHEMA_INVALID_REGULAR_EXPRESSION: "Ensure your regex is compatible with Python's syntax.\n"
     "For guidance, visit: https://docs.python.org/3/library/re.html",
+    RuntimeErrorType.HYPOTHESIS_UNSUPPORTED_GRAPHQL_SCALAR: "Define a custom strategy for it.\n"
+    "For guidance, visit: https://schemathesis.readthedocs.io/en/stable/graphql.html#custom-scalars",
     RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_DATA_TOO_LARGE: _format_health_check_suggestion("data_too_large"),
     RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_FILTER_TOO_MUCH: _format_health_check_suggestion("filter_too_much"),
     RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_TOO_SLOW: _format_health_check_suggestion("too_slow"),
@@ -231,7 +234,7 @@ def _display_error(context: ExecutionContext, error: SerializedError) -> bool:
         click.echo(error.exception)
     if error.extras:
         extras = error.extras
-    elif context.show_errors_tracebacks:
+    elif context.show_trace:
         extras = _split_traceback(error.exception_with_traceback)
     else:
         extras = []
@@ -310,13 +313,11 @@ def display_failures_for_single_test(context: ExecutionContext, result: Serializ
         click.echo(
             f"\n{bold('Reproduce with')}: \n\n    {code_sample}\n",
         )
-    if result.seed is not None:
-        click.secho(f"Or add this option to your command line parameters: --hypothesis-seed={result.seed}")
 
 
 def group_by_case(
-    checks: List[SerializedCheck], code_sample_style: CodeSampleStyle
-) -> Generator[Tuple[str, Generator[SerializedCheck, None, None]], None, None]:
+    checks: list[SerializedCheck], code_sample_style: CodeSampleStyle
+) -> Generator[tuple[str, Generator[SerializedCheck, None, None]], None, None]:
     checks = deduplicate_failures(checks)
     checks = sorted(checks, key=lambda c: _by_unique_code_sample(c, code_sample_style))
     yield from groupby(checks, lambda c: _by_unique_code_sample(c, code_sample_style))
@@ -398,6 +399,9 @@ def display_statistic(context: ExecutionContext, event: events.Finished) -> None
             f"\n{bold('Note')}: Use the '{SCHEMATHESIS_TEST_CASE_HEADER}' header to correlate test case ids "
             "from failure messages with server logs for debugging."
         )
+        if context.seed is not None:
+            seed_option = f"`--hypothesis-seed={context.seed}`"
+            click.secho(f"\n{bold('Note')}: To replicate these test failures, rerun with {bold(seed_option)}")
 
     if context.report is not None and not context.is_interrupted:
         if isinstance(context.report, FileReportContext):
@@ -462,31 +466,52 @@ def display_report_metadata(meta: service.Metadata) -> None:
     click.secho(f"Compressed report size: {meta.size / 1024.:,.0f} KB", bold=True)
 
 
-def display_service_error(event: service.Error) -> None:
+def display_service_unauthorized(hostname: str) -> None:
+    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")
+
+
+def display_service_error(event: service.Error, message_prefix: str = "") -> None:
     """Show information about an error during communication with Schemathesis.io."""
     from requests import RequestException, HTTPError, Response
 
     if isinstance(event.exception, HTTPError):
         response = cast(Response, event.exception.response)
         status_code = response.status_code
-        click.secho(f"Schemathesis.io responded with HTTP {status_code}", fg="red")
         if 500 <= status_code <= 599:
+            click.secho(f"Schemathesis.io responded with HTTP {status_code}", fg="red")
             # Server error, should be resolved soon
             click.secho(
-                "It is likely that we are already notified about the issue and working on a fix\n"
+                "\nIt is likely that we are already notified about the issue and working on a fix\n"
                 "Please, try again in 30 minutes",
                 fg="red",
             )
         elif status_code == 401:
             # Likely an invalid token
-            click.secho(
-                "Please, check that you use the proper CLI access token\n"
-                "See https://schemathesis.readthedocs.io/en/stable/service.html for more details",
-                fg="red",
-            )
+            click.echo("Your CLI is not authenticated.")
+            display_service_unauthorized("schemathesis.io")
         else:
-            # Other client-side errors are likely caused by a bug on the CLI side
-            ask_to_report(event)
+            try:
+                data = response.json()
+                detail = data["detail"]
+                click.secho(f"{message_prefix}{detail}", fg="red")
+            except Exception:
+                # Other client-side errors are likely caused by a bug on the CLI side
+                click.secho(
+                    "We apologize for the inconvenience. This appears to be an internal issue.\n"
+                    "Please, consider reporting the following details to our issue "
+                    f"tracker:\n\n  {ISSUE_TRACKER_URL}\n\nResponse: {response.text!r}\n"
+                    f"Headers: {response.headers!r}",
+                    fg="red",
+                )
     elif isinstance(event.exception, RequestException):
         ask_to_report(event, report_to_issues=False)
     else:
@@ -506,7 +531,7 @@ def ask_to_report(event: service.Error, report_to_issues: bool = True, extra: st
     else:
         response = ""
     if report_to_issues:
-        ask = f"Please, consider reporting the traceback below it to our issue tracker:\n\n  {ISSUE_TRACKER_URL}\n"
+        ask = f"Please, consider reporting the following details to our issue tracker:\n\n  {ISSUE_TRACKER_URL}\n\n"
     else:
         ask = ""
     click.secho(
@@ -539,7 +564,7 @@ def create_spinner(repetitions: int) -> Generator[str, None, None]:
                 yield ch
 
 
-def display_checks_statistics(total: Dict[str, Dict[Union[str, Status], int]]) -> None:
+def display_checks_statistics(total: dict[str, dict[str | Status, int]]) -> None:
     padding = 20
     col1_len = max(map(len, total.keys())) + padding
     col2_len = len(str(max(total.values(), key=lambda v: v["total"])["total"])) * 2 + padding
@@ -550,7 +575,7 @@ def display_checks_statistics(total: Dict[str, Dict[Union[str, Status], int]]) -
         display_check_result(check_name, results, template)
 
 
-def display_check_result(check_name: str, results: Dict[Union[str, Status], int], template: str) -> None:
+def display_check_result(check_name: str, results: dict[str | Status, int], template: str) -> None:
     """Show results of single check execution."""
     if Status.failure in results:
         verdict = "FAILED"
@@ -591,18 +616,18 @@ def should_skip_suggestion(context: ExecutionContext, event: events.InternalErro
     return event.subtype == SchemaErrorType.CONNECTION_OTHER and context.wait_for_schema is not None
 
 
-def _split_traceback(traceback: str) -> List[str]:
+def _split_traceback(traceback: str) -> list[str]:
     return [entry for entry in traceback.splitlines() if entry]
 
 
-def _display_extras(extras: List[str]) -> None:
+def _display_extras(extras: list[str]) -> None:
     if extras:
         click.echo()
     for extra in extras:
         click.secho(f"    {extra}")
 
 
-def _maybe_display_tip(suggestion: Optional[str]) -> None:
+def _maybe_display_tip(suggestion: str | None) -> None:
     # Display suggestion if any
     if suggestion is not None:
         click.secho(f"\n{click.style('Tip:', bold=True, fg='green')} {suggestion}")
@@ -614,7 +639,7 @@ def display_internal_error(context: ExecutionContext, event: events.InternalErro
     click.secho(event.message)
     if event.type == InternalErrorType.SCHEMA:
         extras = event.extras
-    elif context.show_errors_tracebacks:
+    elif context.show_trace:
         extras = _split_traceback(event.exception_with_traceback)
     else:
         extras = [event.exception]
@@ -622,18 +647,19 @@ def display_internal_error(context: ExecutionContext, event: events.InternalErro
     if not should_skip_suggestion(context, event):
         if event.type == InternalErrorType.SCHEMA and isinstance(event.subtype, SchemaErrorType):
             suggestion = SCHEMA_ERROR_SUGGESTIONS.get(event.subtype)
-        elif context.show_errors_tracebacks:
+        elif context.show_trace:
             suggestion = (
                 f"Please consider reporting the traceback above to our issue tracker:\n\n  {ISSUE_TRACKER_URL}."
             )
         else:
-            suggestion = f"To see full tracebacks, add {bold('`--show-errors-tracebacks`')} to your CLI options"
+            suggestion = f"To see full tracebacks, add {bold('`--show-trace`')} to your CLI options"
         _maybe_display_tip(suggestion)
 
 
 def handle_initialized(context: ExecutionContext, event: events.Initialized) -> None:
     """Display information about the test session."""
     context.operations_count = cast(int, event.operations_count)  # INVARIANT: should not be `None`
+    context.seed = event.seed
     display_section_name("Schemathesis test session starts")
     if context.verbosity > 0:
         versions = (
@@ -651,10 +677,14 @@ def handle_initialized(context: ExecutionContext, event: events.Initialized) ->
         click.secho(f"Schema location: {event.location}", bold=True)
     click.secho(f"Base URL: {event.base_url}", bold=True)
     click.secho(f"Specification version: {event.specification_name}", bold=True)
+    if context.seed is not None:
+        click.secho(f"Random seed: {context.seed}", bold=True)
     click.secho(f"Workers: {context.workers_num}", bold=True)
     if context.rate_limit is not None:
         click.secho(f"Rate limit: {context.rate_limit}", bold=True)
     click.secho(f"Collected API operations: {context.operations_count}", bold=True)
+    links_count = cast(int, event.links_count)
+    click.secho(f"Collected API links: {links_count}", bold=True)
     if isinstance(context.report, ServiceReportContext):
         click.secho("Report to Schemathesis.io: ENABLED", bold=True)
     if context.operations_count >= 1:

schemathesis/code_samples.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 from enum import Enum
 from functools import lru_cache
 from shlex import quote
-from typing import Optional, Union, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from .constants import SCHEMATHESIS_TEST_CASE_HEADER
 from .types import Headers
@@ -11,7 +11,7 @@ if TYPE_CHECKING:
     from requests.structures import CaseInsensitiveDict
 
 
-@lru_cache()
+@lru_cache
 def get_excluded_headers() -> CaseInsensitiveDict:
     from requests.structures import CaseInsensitiveDict
     from requests.utils import default_headers
@@ -43,11 +43,11 @@ class CodeSampleStyle(str, Enum):
         }[self]
 
     @classmethod
-    def default(cls) -> "CodeSampleStyle":
+    def default(cls) -> CodeSampleStyle:
         return cls.curl
 
     @classmethod
-    def from_str(cls, value: str) -> "CodeSampleStyle":
+    def from_str(cls, value: str) -> CodeSampleStyle:
         try:
             return cls[value]
         except KeyError:
@@ -61,10 +61,10 @@ class CodeSampleStyle(str, Enum):
         *,
         method: str,
         url: str,
-        body: Optional[Union[str, bytes]],
-        headers: Optional[Headers],
+        body: str | bytes | None,
+        headers: Headers | None,
         verify: bool,
-        extra_headers: Optional[Headers] = None,
+        extra_headers: Headers | None = None,
     ) -> str:
         """Generate a code snippet for making HTTP requests."""
         handlers = {
@@ -76,7 +76,7 @@ class CodeSampleStyle(str, Enum):
         )
 
 
-def _filter_headers(headers: Optional[Headers], extra: Optional[Headers] = None) -> Headers:
+def _filter_headers(headers: Headers | None, extra: Headers | None = None) -> Headers:
     headers = headers.copy() if headers else {}
     if extra is not None:
         for key, value in extra.items():
@@ -89,7 +89,7 @@ def _generate_curl(
     *,
     method: str,
     url: str,
-    body: Optional[Union[str, bytes]],
+    body: str | bytes | None,
     headers: Headers,
     verify: bool,
 ) -> str:
@@ -111,7 +111,7 @@ def _generate_requests(
     *,
     method: str,
     url: str,
-    body: Optional[Union[str, bytes]],
+    body: str | bytes | None,
     headers: Headers,
     verify: bool,
 ) -> str:

schemathesis/constants.py

@@ -1,4 +1,4 @@
-from ._compat import metadata
+from importlib import metadata
 from .types import NotSet
 
 try:

schemathesis/contrib/unique_data.py

@@ -16,10 +16,10 @@ def uninstall() -> None:
     unregister(before_generate_case)
 
 
-def before_generate_case(context: HookContext, strategy: st.SearchStrategy["Case"]) -> st.SearchStrategy["Case"]:
+def before_generate_case(context: HookContext, strategy: st.SearchStrategy[Case]) -> st.SearchStrategy[Case]:
     seen = set()
 
-    def is_not_seen(case: "Case") -> bool:
+    def is_not_seen(case: Case) -> bool:
         # Calculate hash just once as it is costly
         hashed = hash(case)
         if hashed not in seen:

schemathesis/exceptions.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass, field
 from hashlib import sha1
 from json import JSONDecodeError
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Callable, Dict, Generator, List, NoReturn, Optional, Tuple, Type, Union
+from typing import TYPE_CHECKING, Any, Callable, Generator, NoReturn
 
 from .constants import SERIALIZERS_SUGGESTION_MESSAGE
 from .failures import FailureContext
@@ -23,14 +23,14 @@ class CheckFailed(AssertionError):
     """Custom error type to distinguish from arbitrary AssertionError that may happen in the dependent libraries."""
 
     __module__ = "builtins"
-    context: Optional[FailureContext]
-    causes: Optional[Tuple[Union["CheckFailed", AssertionError], ...]]
+    context: FailureContext | None
+    causes: tuple[CheckFailed | AssertionError, ...] | None
 
     def __init__(
         self,
         *args: Any,
-        context: Optional[FailureContext] = None,
-        causes: Optional[Tuple[Union["CheckFailed", AssertionError], ...]] = None,
+        context: FailureContext | None = None,
+        causes: tuple[CheckFailed | AssertionError, ...] | None = None,
     ):
         super().__init__(*args)
         self.context = context
@@ -38,8 +38,8 @@ class CheckFailed(AssertionError):
 
 
 def make_unique_by_key(
-    check_name: str, check_message: Optional[str], context: Optional[FailureContext]
-) -> Tuple[Optional[str], ...]:
+    check_name: str, check_message: str | None, context: FailureContext | None
+) -> tuple[str | None, ...]:
     """A key to distinguish different failed checks.
 
     It is not only based on `FailureContext`, because the end-user may raise plain `AssertionError` in their custom
@@ -51,8 +51,8 @@ def make_unique_by_key(
 
 
 def deduplicate_failed_checks(
-    checks: List[Union[CheckFailed, AssertionError]]
-) -> Generator[Union[CheckFailed, AssertionError], None, None]:
+    checks: list[CheckFailed | AssertionError]
+) -> Generator[CheckFailed | AssertionError, None, None]:
     """Keep only unique failed checks."""
     seen = set()
     for check in checks:
@@ -66,10 +66,10 @@ def deduplicate_failed_checks(
             seen.add(key)
 
 
-CACHE: Dict[Union[str, int], Type[CheckFailed]] = {}
+CACHE: dict[str | int, type[CheckFailed]] = {}
 
 
-def get_exception(name: str) -> Type[CheckFailed]:
+def get_exception(name: str) -> type[CheckFailed]:
     """Create a new exception class with provided name or fetch one from the cache."""
     if name in CACHE:
         exception_class = CACHE[name]
@@ -81,14 +81,14 @@ def get_exception(name: str) -> Type[CheckFailed]:
     return exception_class
 
 
-def _get_hashed_exception(prefix: str, message: str) -> Type[CheckFailed]:
+def _get_hashed_exception(prefix: str, message: str) -> type[CheckFailed]:
     """Give different exceptions for different error messages."""
     messages_digest = sha1(message.encode("utf-8")).hexdigest()
     name = f"{prefix}{messages_digest}"
     return get_exception(name)
 
 
-def get_grouped_exception(prefix: str, *exceptions: AssertionError) -> Type[CheckFailed]:
+def get_grouped_exception(prefix: str, *exceptions: AssertionError) -> type[CheckFailed]:
     # The prefix is needed to distinguish multiple operations with the same error messages
     # that are coming from different operations
     messages = [exception.args[0] for exception in exceptions]
@@ -96,50 +96,50 @@ def get_grouped_exception(prefix: str, *exceptions: AssertionError) -> Type[Chec
     return _get_hashed_exception("GroupedException", f"{prefix}{message}")
 
 
-def get_server_error(status_code: int) -> Type[CheckFailed]:
+def get_server_error(status_code: int) -> type[CheckFailed]:
     """Return new exception for the Internal Server Error cases."""
     name = f"ServerError{status_code}"
     return get_exception(name)
 
 
-def get_status_code_error(status_code: int) -> Type[CheckFailed]:
+def get_status_code_error(status_code: int) -> type[CheckFailed]:
     """Return new exception for an unexpected status code."""
     name = f"StatusCodeError{status_code}"
     return get_exception(name)
 
 
-def get_response_type_error(expected: str, received: str) -> Type[CheckFailed]:
+def get_response_type_error(expected: str, received: str) -> type[CheckFailed]:
     """Return new exception for an unexpected response type."""
     name = f"SchemaValidationError{expected}_{received}"
     return get_exception(name)
 
 
-def get_malformed_media_type_error(media_type: str) -> Type[CheckFailed]:
+def get_malformed_media_type_error(media_type: str) -> type[CheckFailed]:
     name = f"MalformedMediaType{media_type}"
     return get_exception(name)
 
 
-def get_missing_content_type_error() -> Type[CheckFailed]:
+def get_missing_content_type_error() -> type[CheckFailed]:
     """Return new exception for a missing Content-Type header."""
     return get_exception("MissingContentTypeError")
 
 
-def get_schema_validation_error(exception: ValidationError) -> Type[CheckFailed]:
+def get_schema_validation_error(exception: ValidationError) -> type[CheckFailed]:
     """Return new exception for schema validation error."""
     return _get_hashed_exception("SchemaValidationError", str(exception))
 
 
-def get_response_parsing_error(exception: JSONDecodeError) -> Type[CheckFailed]:
+def get_response_parsing_error(exception: JSONDecodeError) -> type[CheckFailed]:
     """Return new exception for response parsing error."""
     return _get_hashed_exception("ResponseParsingError", str(exception))
 
 
-def get_headers_error(message: str) -> Type[CheckFailed]:
+def get_headers_error(message: str) -> type[CheckFailed]:
     """Return new exception for missing headers."""
     return _get_hashed_exception("MissingHeadersError", message)
 
 
-def get_timeout_error(deadline: Union[float, int]) -> Type[CheckFailed]:
+def get_timeout_error(deadline: float | int) -> type[CheckFailed]:
     """Request took too long."""
     return _get_hashed_exception("TimeoutError", str(deadline))
 
@@ -152,15 +152,15 @@ class OperationSchemaError(Exception):
     """Schema associated with an API operation contains an error."""
 
     __module__ = "builtins"
-    message: Optional[str] = None
-    path: Optional[str] = None
-    method: Optional[str] = None
-    full_path: Optional[str] = None
+    message: str | None = None
+    path: str | None = None
+    method: str | None = None
+    full_path: str | None = None
 
     @classmethod
     def from_jsonschema_error(
-        cls, error: ValidationError, path: Optional[str], method: Optional[str], full_path: Optional[str]
-    ) -> "OperationSchemaError":
+        cls, error: ValidationError, path: str | None, method: str | None, full_path: str | None
+    ) -> OperationSchemaError:
         if error.absolute_path:
             part = error.absolute_path[-1]
             if isinstance(part, int) and len(error.absolute_path) > 1:
@@ -170,7 +170,7 @@ class OperationSchemaError(Exception):
                 message = f"Invalid `{part}` definition"
         else:
             message = "Invalid schema definition"
-        error_path = " -> ".join((str(entry) for entry in error.path)) or "[root]"
+        error_path = " -> ".join(str(entry) for entry in error.path) or "[root]"
         message += f"\n\nLocation:\n    {error_path}"
         instance = truncated_json(error.instance)
         message += f"\n\nProblematic definition:\n{instance}"
@@ -185,8 +185,8 @@ class OperationSchemaError(Exception):
 
     @classmethod
     def from_reference_resolution_error(
-        cls, error: RefResolutionError, path: Optional[str], method: Optional[str], full_path: Optional[str]
-    ) -> "OperationSchemaError":
+        cls, error: RefResolutionError, path: str | None, method: str | None, full_path: str | None
+    ) -> OperationSchemaError:
         message = "Unresolvable JSON pointer in the schema"
         # Get the pointer value from "Unresolvable JSON pointer: 'components/UnknownParameter'"
         pointer = str(error).split(": ", 1)[-1]
@@ -217,7 +217,7 @@ class InvalidRegularExpression(OperationSchemaError):
     __module__ = "builtins"
 
     @classmethod
-    def from_hypothesis_jsonschema_message(cls, message: str) -> "InvalidRegularExpression":
+    def from_hypothesis_jsonschema_message(cls, message: str) -> InvalidRegularExpression:
         match = re.search(r"pattern='(.*?)'.*?\((.*?)\)", message)
         if match:
             message = f"Invalid regular expression. Pattern `{match.group(1)}` is not recognized - `{match.group(2)}`"
@@ -263,7 +263,7 @@ class DeadlineExceeded(Exception):
     __module__ = "builtins"
 
     @classmethod
-    def from_exc(cls, exc: hypothesis.errors.DeadlineExceeded) -> "DeadlineExceeded":
+    def from_exc(cls, exc: hypothesis.errors.DeadlineExceeded) -> DeadlineExceeded:
         runtime = exc.runtime.total_seconds() * 1000
         deadline = exc.deadline.total_seconds() * 1000
         return cls(
@@ -281,6 +281,7 @@ class RuntimeErrorType(str, enum.Enum):
     # Hypothesis issues
     HYPOTHESIS_DEADLINE_EXCEEDED = "hypothesis_deadline_exceeded"
     HYPOTHESIS_UNSATISFIABLE = "hypothesis_unsatisfiable"
+    HYPOTHESIS_UNSUPPORTED_GRAPHQL_SCALAR = "hypothesis_unsupported_graphql_scalar"
     HYPOTHESIS_HEALTH_CHECK_DATA_TOO_LARGE = "hypothesis_health_check_data_too_large"
     HYPOTHESIS_HEALTH_CHECK_FILTER_TOO_MUCH = "hypothesis_health_check_filter_too_much"
     HYPOTHESIS_HEALTH_CHECK_TOO_SLOW = "hypothesis_health_check_too_slow"
@@ -290,6 +291,9 @@ class RuntimeErrorType(str, enum.Enum):
     SCHEMA_INVALID_REGULAR_EXPRESSION = "schema_invalid_regular_expression"
     SCHEMA_GENERIC = "schema_generic"
 
+    SERIALIZATION_NOT_POSSIBLE = "serialization_not_possible"
+    SERIALIZATION_UNBOUNDED_PREFIX = "serialization_unbounded_prefix"
+
     # Unclassified
     UNCLASSIFIED = "unclassified"
 
@@ -308,6 +312,7 @@ class SchemaErrorType(str, enum.Enum):
     HTTP_FORBIDDEN = "http_forbidden"
 
     # Content decoding issues
+    SYNTAX_ERROR = "syntax_error"
     UNEXPECTED_CONTENT_TYPE = "unexpected_content_type"
     YAML_NUMERIC_STATUS_CODES = "yaml_numeric_status_codes"
     YAML_NON_STRING_KEYS = "yaml_non_string_keys"
@@ -317,6 +322,9 @@ class SchemaErrorType(str, enum.Enum):
     OPEN_API_UNSPECIFIED_VERSION = "open_api_unspecified_version"
     OPEN_API_UNSUPPORTED_VERSION = "open_api_unsupported_version"
 
+    # GraphQL validation
+    GRAPHQL_INVALID_SCHEMA = "graphql_invalid_schema"
+
     # Unclassified
     UNCLASSIFIED = "unclassified"
 
@@ -327,9 +335,9 @@ class SchemaError(RuntimeError):
 
     type: SchemaErrorType
     message: str
-    url: Optional[str] = None
-    response: Optional["GenericResponse"] = None
-    extras: List[str] = field(default_factory=list)
+    url: str | None = None
+    response: GenericResponse | None = None
+    extras: list[str] = field(default_factory=list)
 
     def __str__(self) -> str:
         return self.message
@@ -398,11 +406,11 @@ class SerializationNotPossible(SerializationError):
     __module__ = "builtins"
 
     @classmethod
-    def from_media_types(cls, *media_types: str) -> "SerializationNotPossible":
+    def from_media_types(cls, *media_types: str) -> SerializationNotPossible:
         return cls(SERIALIZATION_NOT_POSSIBLE_MESSAGE.format(", ".join(media_types)))
 
     @classmethod
-    def for_media_type(cls, media_type: str) -> "SerializationNotPossible":
+    def for_media_type(cls, media_type: str) -> SerializationNotPossible:
         return cls(SERIALIZATION_FOR_TYPE_IS_NOT_POSSIBLE_MESSAGE.format(media_type))
 
 
@@ -430,7 +438,7 @@ def format_exception(error: Exception, include_traceback: bool = False) -> str:
     return "".join(lines).strip()
 
 
-def extract_nth_traceback(trace: Optional[TracebackType], n: int) -> Optional[TracebackType]:
+def extract_nth_traceback(trace: TracebackType | None, n: int) -> TracebackType | None:
     depth = 0
     while depth < n and trace is not None:
         trace = trace.tb_next
@@ -442,8 +450,9 @@ def remove_ssl_line_number(text: str) -> str:
     return re.sub(r"\(_ssl\.c:\d+\)", "", text)
 
 
-def extract_requests_exception_details(exc: RequestException) -> Tuple[str, List[str]]:
+def extract_requests_exception_details(exc: RequestException) -> tuple[str, list[str]]:
     from requests.exceptions import SSLError, ConnectionError, ChunkedEncodingError
+    from urllib3.exceptions import MaxRetryError
 
     if isinstance(exc, SSLError):
         message = "SSL verification problem"
@@ -451,8 +460,12 @@ def extract_requests_exception_details(exc: RequestException) -> Tuple[str, List
         extra = [remove_ssl_line_number(reason)]
     elif isinstance(exc, ConnectionError):
         message = "Connection failed"
-        _, reason = exc.args[0].reason.args[0].split(":", maxsplit=1)
-        extra = [reason.strip()]
+        inner = exc.args[0]
+        if isinstance(inner, MaxRetryError) and inner.reason is not None:
+            _, reason = inner.reason.args[0].split(":", maxsplit=1)
+            extra = [reason.strip()]
+        else:
+            extra = [" ".join(map(str, inner.args))]
     elif isinstance(exc, ChunkedEncodingError):
         message = "Connection broken. The server declared chunked encoding but sent an invalid chunk"
         extra = [str(exc.args[0].args[1])]