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

schemathesis/cli/callbacks.py

@@ -4,7 +4,7 @@ import os
 import re
 import traceback
 from contextlib import contextmanager
-from typing import Dict, Generator, List, Optional, Tuple, Union, TYPE_CHECKING
+from typing import Generator, TYPE_CHECKING
 from urllib.parse import urlparse
 
 import click
@@ -77,7 +77,7 @@ class SchemaInputKind(enum.Enum):
     NAME = 4
 
 
-def parse_schema_kind(schema: str, app: Optional[str]) -> SchemaInputKind:
+def parse_schema_kind(schema: str, app: str | None) -> SchemaInputKind:
     """Detect what kind the input schema is."""
     try:
         netloc = urlparse(schema).netloc
@@ -99,21 +99,20 @@ def validate_schema(
     schema: str,
     kind: SchemaInputKind,
     *,
-    base_url: Optional[str],
+    base_url: str | None,
     dry_run: bool,
-    app: Optional[str],
-    api_name: Optional[str],
+    app: str | None,
+    api_name: str | None,
 ) -> None:
     if kind == SchemaInputKind.URL:
         validate_url(schema)
     if kind == SchemaInputKind.PATH:
-        # Base URL is required if it is not a dry run
-        if app is None and base_url is None and not dry_run:
+        if app is None:
             if not file_exists(schema):
-                message = FILE_DOES_NOT_EXIST_MESSAGE
-            else:
-                message = MISSING_BASE_URL_MESSAGE
-            raise click.UsageError(message)
+                raise click.UsageError(FILE_DOES_NOT_EXIST_MESSAGE)
+            # Base URL is required if it is not a dry run
+            if base_url is None and not dry_run:
+                raise click.UsageError(MISSING_BASE_URL_MESSAGE)
     if kind == SchemaInputKind.NAME:
         if api_name is not None:
             raise click.UsageError(f"Got unexpected extra argument ({api_name})")
@@ -138,9 +137,7 @@ def validate_base_url(ctx: click.core.Context, param: click.core.Parameter, raw_
     return raw_value
 
 
-def validate_rate_limit(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: Optional[str]
-) -> Optional[str]:
+def validate_rate_limit(ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None) -> str | None:
     if raw_value is None:
         return raw_value
     try:
@@ -150,7 +147,7 @@ def validate_rate_limit(
         raise click.UsageError(exc.args[0]) from exc
 
 
-def validate_app(ctx: click.core.Context, param: click.core.Parameter, raw_value: Optional[str]) -> Optional[str]:
+def validate_app(ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None) -> str | None:
     if raw_value is None:
         return raw_value
     try:
@@ -176,8 +173,8 @@ def validate_app(ctx: click.core.Context, param: click.core.Parameter, raw_value
 
 
 def validate_hypothesis_database(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: Optional[str]
-) -> Optional[str]:
+    ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None
+) -> str | None:
     if raw_value is None:
         return raw_value
     if ctx.params.get("hypothesis_derandomize"):
@@ -186,8 +183,8 @@ def validate_hypothesis_database(
 
 
 def validate_auth(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: Optional[str]
-) -> Optional[Tuple[str, str]]:
+    ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None
+) -> tuple[str, str] | None:
     if raw_value is not None:
         with reraise_format_error(raw_value):
             user, password = tuple(raw_value.split(":"))
@@ -202,8 +199,8 @@ def validate_auth(
 
 
 def validate_headers(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: Tuple[str, ...]
-) -> Dict[str, str]:
+    ctx: click.core.Context, param: click.core.Parameter, raw_value: tuple[str, ...]
+) -> dict[str, str]:
     headers = {}
     for header in raw_value:
         with reraise_format_error(header):
@@ -222,7 +219,7 @@ def validate_headers(
     return headers
 
 
-def validate_regex(ctx: click.core.Context, param: click.core.Parameter, raw_value: Tuple[str, ...]) -> Tuple[str, ...]:
+def validate_regex(ctx: click.core.Context, param: click.core.Parameter, raw_value: tuple[str, ...]) -> tuple[str, ...]:
     for value in raw_value:
         try:
             re.compile(value)
@@ -232,8 +229,8 @@ def validate_regex(ctx: click.core.Context, param: click.core.Parameter, raw_val
 
 
 def validate_request_cert_key(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: Optional[str]
-) -> Optional[str]:
+    ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None
+) -> str | None:
     if raw_value is not None and "request_cert" not in ctx.params:
         raise click.UsageError(MISSING_REQUEST_CERT_MESSAGE)
     return raw_value
@@ -246,8 +243,8 @@ def validate_preserve_exact_body_bytes(ctx: click.core.Context, param: click.cor
 
 
 def convert_verbosity(
-    ctx: click.core.Context, param: click.core.Parameter, value: Optional[str]
-) -> Optional[hypothesis.Verbosity]:
+    ctx: click.core.Context, param: click.core.Parameter, value: str | None
+) -> hypothesis.Verbosity | None:
     import hypothesis
 
     if value is None:
@@ -255,15 +252,15 @@ def convert_verbosity(
     return hypothesis.Verbosity[value]
 
 
-def convert_stateful(ctx: click.core.Context, param: click.core.Parameter, value: str) -> Optional[Stateful]:
+def convert_stateful(ctx: click.core.Context, param: click.core.Parameter, value: str) -> Stateful | None:
     if value == "none":
         return None
     return Stateful[value]
 
 
 def convert_experimental(
-    ctx: click.core.Context, param: click.core.Parameter, value: Tuple[str, ...]
-) -> List[experimental.Experiment]:
+    ctx: click.core.Context, param: click.core.Parameter, value: tuple[str, ...]
+) -> list[experimental.Experiment]:
     return [
         feature
         for feature in experimental.GLOBAL_EXPERIMENTS.available
@@ -271,7 +268,7 @@ def convert_experimental(
     ]
 
 
-def convert_checks(ctx: click.core.Context, param: click.core.Parameter, value: Tuple[List[str]]) -> List[str]:
+def convert_checks(ctx: click.core.Context, param: click.core.Parameter, value: tuple[list[str]]) -> list[str]:
     return sum(value, [])
 
 
@@ -281,7 +278,7 @@ def convert_code_sample_style(ctx: click.core.Context, param: click.core.Paramet
 
 def convert_data_generation_method(
     ctx: click.core.Context, param: click.core.Parameter, value: str
-) -> List[DataGenerationMethod]:
+) -> list[DataGenerationMethod]:
     if value == "all":
         return DataGenerationMethod.all()
     return [DataGenerationMethod[value]]
@@ -307,7 +304,7 @@ def convert_hosts_file(ctx: click.core.Context, param: click.core.Parameter, val
     return value
 
 
-def convert_boolean_string(ctx: click.core.Context, param: click.core.Parameter, value: str) -> Union[str, bool]:
+def convert_boolean_string(ctx: click.core.Context, param: click.core.Parameter, value: str) -> str | bool:
     if value.lower() in TRUE_VALUES:
         return True
     if value.lower() in FALSE_VALUES:

schemathesis/cli/cassettes.py

@@ -6,7 +6,7 @@ import sys
 import threading
 from dataclasses import dataclass, field
 from queue import Queue
-from typing import IO, Any, Dict, Generator, Iterator, List, Optional, cast, TYPE_CHECKING
+from typing import IO, Any, Generator, Iterator, cast, TYPE_CHECKING
 
 from ..constants import SCHEMATHESIS_VERSION
 from ..runner import events
@@ -93,7 +93,7 @@ class Process:
     correlation_id: str
     thread_id: int
     data_generation_method: DataGenerationMethod
-    interactions: List[SerializedInteraction]
+    interactions: list[SerializedInteraction]
 
 
 @dataclass
@@ -123,16 +123,16 @@ def worker(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: bool, q
     current_id = 1
     stream = file_handle.open()
 
-    def format_header_values(values: List[str]) -> str:
+    def format_header_values(values: list[str]) -> str:
         return "\n".join(f"      - {json.dumps(v)}" for v in values)
 
-    def format_headers(headers: Dict[str, List[str]]) -> str:
+    def format_headers(headers: dict[str, list[str]]) -> str:
         return "\n".join(f'      "{name}":\n{format_header_values(values)}' for name, values in headers.items())
 
-    def format_check_message(message: Optional[str]) -> str:
+    def format_check_message(message: str | None) -> str:
         return "~" if message is None else f"{repr(message)}"
 
-    def format_checks(checks: List[SerializedCheck]) -> str:
+    def format_checks(checks: list[SerializedCheck]) -> str:
         return "\n".join(
             f"    - name: '{check.name}'\n      status: '{check.value.name.upper()}'\n      message: {format_check_message(check.message)}"
             for check in checks
@@ -278,18 +278,18 @@ def write_double_quoted(stream: IO, text: str) -> None:
 
 @dataclass
 class Replayed:
-    interaction: Dict[str, Any]
+    interaction: dict[str, Any]
     response: requests.Response
 
 
 def replay(
-    cassette: Dict[str, Any],
-    id_: Optional[str] = None,
-    status: Optional[str] = None,
-    uri: Optional[str] = None,
-    method: Optional[str] = None,
+    cassette: dict[str, Any],
+    id_: str | None = None,
+    status: str | None = None,
+    uri: str | None = None,
+    method: str | None = None,
     request_tls_verify: bool = True,
-    request_cert: Optional[RequestCert] = None,
+    request_cert: RequestCert | None = None,
 ) -> Generator[Replayed, None, None]:
     """Replay saved interactions."""
     import requests
@@ -304,26 +304,26 @@ def replay(
 
 
 def filter_cassette(
-    interactions: List[Dict[str, Any]],
-    id_: Optional[str] = None,
-    status: Optional[str] = None,
-    uri: Optional[str] = None,
-    method: Optional[str] = None,
-) -> Iterator[Dict[str, Any]]:
+    interactions: list[dict[str, Any]],
+    id_: str | None = None,
+    status: str | None = None,
+    uri: str | None = None,
+    method: str | None = None,
+) -> Iterator[dict[str, Any]]:
     filters = []
 
-    def id_filter(item: Dict[str, Any]) -> bool:
+    def id_filter(item: dict[str, Any]) -> bool:
         return item["id"] == id_
 
-    def status_filter(item: Dict[str, Any]) -> bool:
+    def status_filter(item: dict[str, Any]) -> bool:
         status_ = cast(str, status)
         return item["status"].upper() == status_.upper()
 
-    def uri_filter(item: Dict[str, Any]) -> bool:
+    def uri_filter(item: dict[str, Any]) -> bool:
         uri_ = cast(str, uri)
         return bool(re.search(uri_, item["request"]["uri"]))
 
-    def method_filter(item: Dict[str, Any]) -> bool:
+    def method_filter(item: dict[str, Any]) -> bool:
         method_ = cast(str, method)
         return bool(re.search(method_, item["request"]["method"]))
 
@@ -339,13 +339,13 @@ def filter_cassette(
     if method is not None:
         filters.append(method_filter)
 
-    def is_match(interaction: Dict[str, Any]) -> bool:
+    def is_match(interaction: dict[str, Any]) -> bool:
         return all(filter_(interaction) for filter_ in filters)
 
     return filter(is_match, interactions)
 
 
-def get_prepared_request(data: Dict[str, Any]) -> requests.PreparedRequest:
+def get_prepared_request(data: dict[str, Any]) -> requests.PreparedRequest:
     """Create a `requests.PreparedRequest` from a serialized one."""
     from requests.structures import CaseInsensitiveDict
     from requests.cookies import RequestsCookieJar

schemathesis/cli/context.py

@@ -3,9 +3,10 @@ import os
 import shutil
 from dataclasses import dataclass, field
 from queue import Queue
-from typing import List, Optional, Union, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from ..code_samples import CodeSampleStyle
+from ..internal.deprecation import deprecated_property
 from ..runner.serialization import SerializedTestResult
 
 if TYPE_CHECKING:
@@ -21,7 +22,7 @@ class ServiceReportContext:
 @dataclass
 class FileReportContext:
     queue: Queue
-    filename: Optional[str] = None
+    filename: str | None = None
 
 
 @dataclass
@@ -29,21 +30,26 @@ class ExecutionContext:
     """Storage for the current context of the execution."""
 
     hypothesis_settings: hypothesis.settings
-    hypothesis_output: List[str] = field(default_factory=list)
+    hypothesis_output: list[str] = field(default_factory=list)
     workers_num: int = 1
-    rate_limit: Optional[str] = None
-    show_errors_tracebacks: bool = False
-    wait_for_schema: Optional[float] = None
+    rate_limit: str | None = None
+    show_trace: bool = False
+    wait_for_schema: float | None = None
     validate_schema: bool = True
     operations_processed: int = 0
-    # It is set in runtime, from a `Initialized` event
-    operations_count: Optional[int] = None
+    # It is set in runtime, from the `Initialized` event
+    operations_count: int | None = None
+    seed: int | None = None
     current_line_length: int = 0
     terminal_size: os.terminal_size = field(default_factory=shutil.get_terminal_size)
-    results: List[SerializedTestResult] = field(default_factory=list)
-    cassette_path: Optional[str] = None
-    junit_xml_file: Optional[str] = None
+    results: list[SerializedTestResult] = field(default_factory=list)
+    cassette_path: str | None = None
+    junit_xml_file: str | None = None
     is_interrupted: bool = False
     verbosity: int = 0
     code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
-    report: Optional[Union[ServiceReportContext, FileReportContext]] = None
+    report: ServiceReportContext | FileReportContext | None = None
+
+    @deprecated_property(removed_in="4.0", replacement="show_trace")
+    def show_errors_tracebacks(self) -> bool:
+        return self.show_trace

schemathesis/cli/junitxml.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import platform
 from dataclasses import dataclass, field
-from typing import List, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from junit_xml import TestCase, TestSuite, to_xml_report_file
 
@@ -19,7 +19,7 @@ if TYPE_CHECKING:
 @dataclass
 class JunitXMLHandler(EventHandler):
     file_handle: LazyFile
-    test_cases: List = field(default_factory=list)
+    test_cases: list = field(default_factory=list)
 
     def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
         if isinstance(event, events.AfterExecution):

schemathesis/cli/options.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
 from enum import Enum
-from typing import Any, List, NoReturn, Optional, Set, Tuple, Type, Union
+from typing import Any, NoReturn
 
 import click
 
@@ -19,12 +20,12 @@ class CustomHelpMessageChoice(click.Choice):
 
 
 class BaseCsvChoice(click.Choice):
-    def parse_value(self, value: str) -> Tuple[List[str], Set[str]]:
+    def parse_value(self, value: str) -> tuple[list[str], set[str]]:
         selected = [item for item in value.split(",") if item]
         invalid_options = set(selected) - set(self.choices)
         return selected, invalid_options
 
-    def fail_on_invalid_options(self, invalid_options: Set[str], selected: List[str]) -> NoReturn:
+    def fail_on_invalid_options(self, invalid_options: set[str], selected: list[str]) -> NoReturn:
         # Sort to keep the error output consistent with the passed values
         sorted_options = ", ".join(sorted(invalid_options, key=selected.index))
         available_options = ", ".join(self.choices)
@@ -32,13 +33,13 @@ class BaseCsvChoice(click.Choice):
 
 
 class CsvEnumChoice(BaseCsvChoice):
-    def __init__(self, choices: Type[Enum]):
+    def __init__(self, choices: type[Enum]):
         self.enum = choices
         super().__init__(tuple(el.name for el in choices))
 
     def convert(  # type: ignore[return]
-        self, value: str, param: Optional[click.core.Parameter], ctx: Optional[click.core.Context]
-    ) -> List[Enum]:
+        self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None
+    ) -> list[Enum]:
         selected, invalid_options = self.parse_value(value)
         if not invalid_options and selected:
             return [self.enum[item] for item in selected]
@@ -46,9 +47,7 @@ class CsvEnumChoice(BaseCsvChoice):
 
 
 class CsvChoice(BaseCsvChoice):
-    def convert(
-        self, value: str, param: Optional[click.core.Parameter], ctx: Optional[click.core.Context]
-    ) -> List[str]:
+    def convert(self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None) -> list[str]:
         selected, invalid_options = self.parse_value(value)
         if not invalid_options and selected:
             return selected
@@ -57,8 +56,8 @@ class CsvChoice(BaseCsvChoice):
 
 class OptionalInt(click.types.IntRange):
     def convert(  # type: ignore
-        self, value: str, param: Optional[click.core.Parameter], ctx: Optional[click.core.Context]
-    ) -> Union[int, NotSet]:
+        self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None
+    ) -> int | NotSet:
         if value.lower() == "none":
             return NOT_SET
         try: