schemathesis 3.25.5__py3-none-any.whl → 3.26.0__py3-none-any.whl

schemathesis/_dependency_versions.py

@@ -1,4 +1,5 @@
 """Compatibility flags based on installed dependency versions."""
+
 from packaging import version
 
 from importlib import metadata

schemathesis/_hypothesis.py

@@ -1,4 +1,5 @@
 """High-level API for creating Hypothesis tests."""
+
 from __future__ import annotations
 
 import asyncio

schemathesis/_xml.py

@@ -1,4 +1,5 @@
 """XML serialization."""
+
 from __future__ import annotations
 from io import StringIO
 from typing import Any, Dict, List, Union

schemathesis/auths.py

@@ -1,4 +1,5 @@
 """Support for custom API authentication mechanisms."""
+
 from __future__ import annotations
 import inspect
 import threading

schemathesis/cli/__init__.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import base64
 import enum
 import io
@@ -10,48 +11,45 @@ from collections import defaultdict
 from dataclasses import dataclass
 from enum import Enum
 from queue import Queue
-from typing import Any, Callable, Generator, Iterable, NoReturn, cast, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Callable, Generator, Iterable, NoReturn, cast
 from urllib.parse import urlparse
 
 import click
 
 from .. import checks as checks_module
-from .. import contrib, experimental, generation
+from .. import contrib, experimental, generation, runner, service
 from .. import fixups as _fixups
-from .. import runner, service
 from .. import targets as targets_module
+from .._override import CaseOverride
 from ..code_samples import CodeSampleStyle
-from .constants import HealthCheck, Phase, Verbosity
-from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod
 from ..constants import (
     API_NAME_ENV_VAR,
     BASE_URL_ENV_VAR,
     DEFAULT_RESPONSE_TIMEOUT,
     DEFAULT_STATEFUL_RECURSION_LIMIT,
+    EXTENSIONS_DOCUMENTATION_URL,
     HOOKS_MODULE_ENV_VAR,
     HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER,
-    WAIT_FOR_SCHEMA_ENV_VAR,
-    EXTENSIONS_DOCUMENTATION_URL,
     ISSUE_TRACKER_URL,
+    WAIT_FOR_SCHEMA_ENV_VAR,
 )
-from ..exceptions import SchemaError, extract_nth_traceback, SchemaErrorType
+from ..exceptions import SchemaError, SchemaErrorType, extract_nth_traceback
 from ..fixups import ALL_FIXUPS
-from ..loaders import load_app, load_yaml
-from .._override import CaseOverride
-from ..transports.auth import get_requests_auth
+from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod
 from ..hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, HookScope
+from ..internal.datetime import current_datetime
+from ..internal.validation import file_exists
+from ..loaders import load_app, load_yaml
 from ..models import Case, CheckFunction
-from ..runner import events, prepare_hypothesis_settings
+from ..runner import events, prepare_hypothesis_settings, probes
 from ..specs.graphql import loaders as gql_loaders
 from ..specs.openapi import loaders as oas_loaders
-from ..specs.openapi import formats
 from ..stateful import Stateful
 from ..targets import Target
+from ..transports.auth import get_requests_auth
 from ..types import Filter, PathLike, RequestCert
-from ..internal.datetime import current_datetime
-from ..internal.validation import file_exists
-from . import callbacks, cassettes, output, probes
-from .constants import DEFAULT_WORKERS, MAX_WORKERS, MIN_WORKERS
+from . import callbacks, cassettes, output
+from .constants import DEFAULT_WORKERS, MAX_WORKERS, MIN_WORKERS, HealthCheck, Phase, Verbosity
 from .context import ExecutionContext, FileReportContext, ServiceReportContext
 from .debug import DebugOutputHandler
 from .junitxml import JunitXMLHandler
@@ -61,8 +59,9 @@ from .sanitization import SanitizationHandler
 if TYPE_CHECKING:
     import hypothesis
     import requests
-    from ..service.client import ServiceClient
+
     from ..schemas import BaseSchema
+    from ..service.client import ServiceClient
     from ..specs.graphql.schemas import GraphQLSchema
     from .handlers import EventHandler
 
@@ -682,8 +681,9 @@ The report data, consisting of a tar gz file with multiple JSON files, is subjec
 @click.option("--force-color", help="Explicitly tells to enable ANSI color escape codes.", type=bool, is_flag=True)
 @click.option(
     "--experimental",
+    "experiments",
     help="Enable experimental support for specific features.",
-    type=click.Choice([experimental.OPEN_API_3_1.name]),
+    type=click.Choice([experimental.OPEN_API_3_1.name, experimental.SCHEMA_ANALYSIS.name]),
     callback=callbacks.convert_experimental,
     multiple=True,
 )
@@ -738,7 +738,7 @@ def run(
     set_header: dict[str, str],
     set_cookie: dict[str, str],
     set_path: dict[str, str],
-    experimental: list,
+    experiments: list,
     checks: Iterable[str] = DEFAULT_CHECKS_NAMES,
     exclude_checks: Iterable[str] = (),
     data_generation_methods: tuple[DataGenerationMethod, ...] = DEFAULT_DATA_GENERATION_METHODS,
@@ -827,7 +827,7 @@ def run(
         show_trace = show_errors_tracebacks
 
     # Enable selected experiments
-    for experiment in experimental:
+    for experiment in experiments:
         experiment.enable()
 
     override = CaseOverride(query=set_query, headers=set_header, cookies=set_cookie, path_parameters=set_path)
@@ -902,6 +902,10 @@ def run(
         from ..service.client import ServiceClient
 
         # Upload without connecting data to a certain API
+        client = ServiceClient(base_url=schemathesis_io_url, token=token)
+    if experimental.SCHEMA_ANALYSIS.is_enabled and not client:
+        from ..service.client import ServiceClient
+
         client = ServiceClient(base_url=schemathesis_io_url, token=token)
     host_data = service.hosts.HostData(schemathesis_io_hostname, hosts_file)
 
@@ -971,6 +975,7 @@ def run(
         stateful_recursion_limit=stateful_recursion_limit,
         hypothesis_settings=hypothesis_settings,
         generation_config=generation_config,
+        service_client=client,
     )
     execute(
         event_stream,
@@ -1075,6 +1080,7 @@ def into_event_stream(
     store_interactions: bool,
     stateful: Stateful | None,
     stateful_recursion_limit: int,
+    service_client: ServiceClient | None,
 ) -> Generator[events.ExecutionEvent, None, None]:
     try:
         if app is not None:
@@ -1100,10 +1106,9 @@ def into_event_stream(
             tag=tag or None,
             operation_id=operation_id or None,
         )
-        loaded_schema = load_schema(config)
-        run_probes(loaded_schema, config)
+        schema = load_schema(config)
         yield from runner.from_schema(
-            loaded_schema,
+            schema,
             auth=auth,
             auth_type=auth_type,
             override=override,
@@ -1126,6 +1131,16 @@ def into_event_stream(
             stateful_recursion_limit=stateful_recursion_limit,
             hypothesis_settings=hypothesis_settings,
             generation_config=generation_config,
+            probe_config=probes.ProbeConfig(
+                base_url=config.base_url,
+                request_tls_verify=config.request_tls_verify,
+                request_proxy=config.request_proxy,
+                request_cert=config.request_cert,
+                auth=config.auth,
+                auth_type=config.auth_type,
+                headers=config.headers,
+            ),
+            service_client=service_client,
         ).execute()
     except SchemaError as error:
         yield events.InternalError.from_schema_error(error)
@@ -1133,19 +1148,6 @@ def into_event_stream(
         yield events.InternalError.from_exc(exc)
 
 
-def run_probes(schema: BaseSchema, config: LoaderConfig) -> None:
-    """Discover capabilities of the tested app."""
-    probe_results = probes.run(schema, config)
-    for result in probe_results:
-        if isinstance(result.probe, probes.NullByteInHeader) and result.is_failure:
-            from ..specs.openapi._hypothesis import HEADER_FORMAT, header_values
-
-            formats.register(
-                HEADER_FORMAT,
-                header_values(blacklist_characters="\n\r\x00").map(str.lstrip),
-            )
-
-
 def load_schema(config: LoaderConfig) -> BaseSchema:
     """Automatically load API schema."""
     first: Callable[[LoaderConfig], BaseSchema]

schemathesis/cli/cassettes.py

@@ -254,8 +254,8 @@ def write_double_quoted(stream: IO, text: str) -> None:
             ch = text[end]
         if (
             ch is None
-            or ch in '"\\\x85\u2028\u2029\uFEFF'
-            or not ("\x20" <= ch <= "\x7E" or ("\xA0" <= ch <= "\uD7FF" or "\uE000" <= ch <= "\uFFFD"))
+            or ch in '"\\\x85\u2028\u2029\ufeff'
+            or not ("\x20" <= ch <= "\x7e" or ("\xa0" <= ch <= "\ud7ff" or "\ue000" <= ch <= "\ufffd"))
         ):
             if start < end:
                 stream.write(text[start:end])
@@ -264,9 +264,9 @@ def write_double_quoted(stream: IO, text: str) -> None:
                 # Escape character
                 if ch in Emitter.ESCAPE_REPLACEMENTS:
                     data = "\\" + Emitter.ESCAPE_REPLACEMENTS[ch]
-                elif ch <= "\xFF":
+                elif ch <= "\xff":
                     data = "\\x%02X" % ord(ch)
-                elif ch <= "\uFFFF":
+                elif ch <= "\uffff":
                     data = "\\u%04X" % ord(ch)
                 else:
                     data = "\\U%08X" % ord(ch)

schemathesis/cli/context.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import os
 import shutil
 from dataclasses import dataclass, field
@@ -7,7 +8,10 @@ from typing import TYPE_CHECKING
 
 from ..code_samples import CodeSampleStyle
 from ..internal.deprecation import deprecated_property
+from ..internal.result import Result
+from ..runner.probes import ProbeRun
 from ..runner.serialization import SerializedTestResult
+from ..service.models import AnalysisResult
 
 if TYPE_CHECKING:
     import hypothesis
@@ -49,6 +53,8 @@ class ExecutionContext:
     verbosity: int = 0
     code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
     report: ServiceReportContext | FileReportContext | None = None
+    probes: list[ProbeRun] | None = None
+    analysis: Result[AnalysisResult, Exception] | None = None
 
     @deprecated_property(removed_in="4.0", replacement="show_trace")
     def show_errors_tracebacks(self) -> bool:

schemathesis/cli/output/default.py

@@ -1,38 +1,50 @@
 from __future__ import annotations
+
 import base64
 import os
 import platform
 import shutil
 import textwrap
 import time
+from importlib import metadata
 from itertools import groupby
 from queue import Queue
-from typing import Any, Generator, cast
+from typing import Any, Generator, cast, TYPE_CHECKING
 
 import click
-from importlib import metadata
 
 from ... import service
 from ...code_samples import CodeSampleStyle
 from ...constants import (
     DISCORD_LINK,
+    FALSE_VALUES,
     FLAKY_FAILURE_MESSAGE,
+    GITHUB_APP_LINK,
+    ISSUE_TRACKER_URL,
     REPORT_SUGGESTION_ENV_VAR,
     SCHEMATHESIS_TEST_CASE_HEADER,
     SCHEMATHESIS_VERSION,
-    FALSE_VALUES,
-    ISSUE_TRACKER_URL,
-    GITHUB_APP_LINK,
 )
-from ...exceptions import RuntimeErrorType, prepare_response_payload
+from ...exceptions import (
+    RuntimeErrorType,
+    format_exception,
+    prepare_response_payload,
+    extract_requests_exception_details,
+)
 from ...experimental import GLOBAL_EXPERIMENTS
+from ...internal.result import Ok
 from ...models import Status
 from ...runner import events
 from ...runner.events import InternalErrorType, SchemaErrorType
-from ...runner.serialization import SerializedError, SerializedTestResult, deduplicate_failures, SerializedCheck
+from ...runner.probes import ProbeOutcome
+from ...runner.serialization import SerializedCheck, SerializedError, SerializedTestResult, deduplicate_failures
+from ...service.models import AnalysisSuccess, UnknownExtension, ErrorState
 from ..context import ExecutionContext, FileReportContext, ServiceReportContext
 from ..handlers import EventHandler
 
+if TYPE_CHECKING:
+    import requests
+
 SPINNER_REPETITION_NUMBER = 10
 
 
@@ -179,16 +191,19 @@ def display_generic_errors(context: ExecutionContext, errors: list[SerializedErr
 
 def display_full_traceback_message(error: SerializedError) -> bool:
     # Some errors should not trigger the message that suggests to show full tracebacks to the user
-    return not error.exception.startswith(
-        (
-            "DeadlineExceeded",
-            "OperationSchemaError",
-            "requests.exceptions",
-            "SerializationNotPossible",
-            "hypothesis.errors.FailedHealthCheck",
-            "hypothesis.errors.InvalidArgument: Scalar ",
-            "hypothesis.errors.InvalidArgument: min_size=",
+    return (
+        not error.exception.startswith(
+            (
+                "DeadlineExceeded",
+                "OperationSchemaError",
+                "requests.exceptions",
+                "SerializationNotPossible",
+                "hypothesis.errors.FailedHealthCheck",
+                "hypothesis.errors.InvalidArgument: Scalar ",
+                "hypothesis.errors.InvalidArgument: min_size=",
+            )
         )
+        and "can never generate an example, because min_size is larger than Hypothesis supports." not in error.exception
     )
 
 
@@ -357,6 +372,81 @@ def display_single_log(result: SerializedTestResult) -> None:
     click.echo("\n\n".join(result.logs))
 
 
+def display_analysis(context: ExecutionContext) -> None:
+    """Display schema analysis details."""
+    import requests.exceptions
+
+    if context.analysis is None:
+        return
+    display_section_name("SCHEMA ANALYSIS")
+    if isinstance(context.analysis, Ok):
+        analysis = context.analysis.ok()
+        click.echo()
+        if isinstance(analysis, AnalysisSuccess):
+            click.secho(analysis.message, bold=True)
+            click.echo("\nAnalysis took: {:.2f}ms".format(analysis.elapsed))
+            if analysis.extensions:
+                known = []
+                failed = []
+                unknown = []
+                for extension in analysis.extensions:
+                    if isinstance(extension, UnknownExtension):
+                        unknown.append(extension)
+                    elif isinstance(extension.state, ErrorState):
+                        failed.append(extension)
+                    else:
+                        known.append(extension)
+                if known:
+                    click.echo("\nThe following extensions have been applied:\n")
+                    for extension in known:
+                        click.echo(f"  - {extension.summary}")
+                if failed:
+                    click.echo("\nThe following extensions errored:\n")
+                    for extension in failed:
+                        click.echo(f"  - {extension.summary}")
+                    suggestion = f"Please, consider reporting this to our issue tracker:\n\n  {ISSUE_TRACKER_URL}"
+                    click.secho(f"\n{click.style('Tip:', bold=True, fg='green')} {suggestion}")
+                if unknown:
+                    noun = "extension" if len(unknown) == 1 else "extensions"
+                    specific_noun = "this extension" if len(unknown) == 1 else "these extensions"
+                    title = click.style("Compatibility Notice", bold=True)
+                    click.secho(f"\n{title}: {len(unknown)} {noun} not recognized:\n")
+                    for extension in unknown:
+                        click.echo(f"  - {extension.summary}")
+                    suggestion = f"Consider updating the CLI to add support for {specific_noun}."
+                    click.secho(f"\n{click.style('Tip:', bold=True, fg='green')} {suggestion}")
+            else:
+                click.echo("\nNo extensions have been applied.")
+        else:
+            click.echo("An error happened during schema analysis:\n")
+            click.secho(f"  {analysis.message}", bold=True)
+        click.echo()
+    else:
+        exception = context.analysis.err()
+        suggestion = None
+        if isinstance(exception, requests.exceptions.HTTPError):
+            response = exception.response
+            click.secho("Error\n", fg="red", bold=True)
+            _display_service_network_error(response)
+            click.echo()
+            return None
+        elif isinstance(exception, requests.RequestException):
+            message, extras = extract_requests_exception_details(exception)
+            suggestion = "Please check your network connection and try again."
+            title = "Network Error"
+        else:
+            traceback = format_exception(exception, True)
+            extras = _split_traceback(traceback)
+            title = "Internal Error"
+            message = f"We apologize for the inconvenience. This appears to be an internal issue.\nPlease, consider reporting the following details to our issue tracker:\n\n  {ISSUE_TRACKER_URL}"
+            suggestion = "Please update your CLI to the latest version and try again."
+        click.secho(f"{title}\n", fg="red", bold=True)
+        click.echo(message)
+        _display_extras(extras)
+        _maybe_display_tip(suggestion)
+        click.echo()
+
+
 def display_statistic(context: ExecutionContext, event: events.Finished) -> None:
     """Format and print statistic collected by :obj:`models.TestResult`."""
     display_section_name("SUMMARY")
@@ -487,43 +577,49 @@ def display_service_unauthorized(hostname: str) -> None:
 
 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
+    from requests import HTTPError, RequestException, Response
 
     if isinstance(event.exception, HTTPError):
         response = cast(Response, event.exception.response)
-        status_code = response.status_code
-        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(
-                "\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.echo("Your CLI is not authenticated.")
-            display_service_unauthorized("schemathesis.io")
-        else:
-            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",
-                )
+        _display_service_network_error(response, message_prefix)
     elif isinstance(event.exception, RequestException):
         ask_to_report(event, report_to_issues=False)
     else:
         ask_to_report(event)
 
 
+def _display_service_network_error(response: requests.Response, message_prefix: str = "") -> None:
+    status_code = response.status_code
+    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(
+            "\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.echo("Your CLI is not authenticated.")
+        display_service_unauthorized("schemathesis.io")
+    else:
+        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"Status: {response.status_code}\n"
+                f"Headers: {response.headers!r}",
+                fg="red",
+            )
+            _maybe_display_tip("Please update your CLI to the latest version and try again.")
+
+
 SERVICE_ERROR_MESSAGE = "An error happened during uploading reports to Schemathesis.io"
 
 
@@ -694,7 +790,42 @@ def handle_initialized(context: ExecutionContext, event: events.Initialized) ->
     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:
+
+
+def handle_before_probing(context: ExecutionContext, event: events.BeforeProbing) -> None:
+    click.secho("API probing: ...\r", bold=True, nl=False)
+
+
+def handle_after_probing(context: ExecutionContext, event: events.AfterProbing) -> None:
+    context.probes = event.probes
+    status = "SKIP"
+    if event.probes is not None:
+        for probe in event.probes:
+            if probe.outcome in (ProbeOutcome.SUCCESS, ProbeOutcome.FAILURE):
+                # The probe itself has been executed
+                status = "SUCCESS"
+            elif probe.outcome == ProbeOutcome.ERROR:
+                status = "ERROR"
+    click.secho(f"API probing: {status}", bold=True, nl=False)
+    click.echo()
+
+
+def handle_before_analysis(context: ExecutionContext, event: events.BeforeAnalysis) -> None:
+    click.secho("Schema analysis: ...\r", bold=True, nl=False)
+
+
+def handle_after_analysis(context: ExecutionContext, event: events.AfterAnalysis) -> None:
+    context.analysis = event.analysis
+    status = "SKIP"
+    if event.analysis is not None:
+        if isinstance(event.analysis, Ok) and isinstance(event.analysis.ok(), AnalysisSuccess):
+            status = "SUCCESS"
+        else:
+            status = "ERROR"
+    click.secho(f"Schema analysis: {status}", bold=True, nl=False)
+    click.echo()
+    operations_count = cast(int, context.operations_count)  # INVARIANT: should not be `None`
+    if operations_count >= 1:
         click.echo()
 
 
@@ -731,6 +862,7 @@ def handle_finished(context: ExecutionContext, event: events.Finished) -> None:
     display_errors(context, event)
     display_failures(context, event)
     display_application_logs(context, event)
+    display_analysis(context)
     display_statistic(context, event)
     click.echo()
     display_summary(event)
@@ -752,6 +884,14 @@ class DefaultOutputStyleHandler(EventHandler):
         """Choose and execute a proper handler for the given event."""
         if isinstance(event, events.Initialized):
             handle_initialized(context, event)
+        if isinstance(event, events.BeforeProbing):
+            handle_before_probing(context, event)
+        if isinstance(event, events.AfterProbing):
+            handle_after_probing(context, event)
+        if isinstance(event, events.BeforeAnalysis):
+            handle_before_analysis(context, event)
+        if isinstance(event, events.AfterAnalysis):
+            handle_after_analysis(context, event)
         if isinstance(event, events.BeforeExecution):
             handle_before_execution(context, event)
         if isinstance(event, events.AfterExecution):

schemathesis/cli/output/short.py

@@ -26,6 +26,14 @@ class ShortOutputStyleHandler(EventHandler):
         """
         if isinstance(event, events.Initialized):
             default.handle_initialized(context, event)
+        if isinstance(event, events.BeforeProbing):
+            default.handle_before_probing(context, event)
+        if isinstance(event, events.AfterProbing):
+            default.handle_after_probing(context, event)
+        if isinstance(event, events.BeforeAnalysis):
+            default.handle_before_analysis(context, event)
+        if isinstance(event, events.AfterAnalysis):
+            default.handle_after_analysis(context, event)
         if isinstance(event, events.BeforeExecution):
             handle_before_execution(context, event)
         if isinstance(event, events.AfterExecution):

schemathesis/experimental/__init__.py

@@ -72,3 +72,10 @@ OPEN_API_3_1 = GLOBAL_EXPERIMENTS.create_experiment(
     description="Support for response validation",
     discussion_url="https://github.com/schemathesis/schemathesis/discussions/1822",
 )
+SCHEMA_ANALYSIS = GLOBAL_EXPERIMENTS.create_experiment(
+    name="schema-analysis",
+    verbose_name="Schema Analysis",
+    env_var="SCHEMA_ANALYSIS",
+    description="Analyzing API schemas via Schemathesis.io",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/2056",
+)

schemathesis/filters.py

@@ -1,4 +1,5 @@
 """Filtering system that allows users to filter API operations based on certain criteria."""
+
 from __future__ import annotations
 import re
 from dataclasses import dataclass, field

schemathesis/models.py

@@ -960,9 +960,12 @@ class Response:
     @classmethod
     def from_requests(cls, response: requests.Response) -> Response:
         """Create a response from requests.Response."""
-        headers = {name: response.raw.headers.getlist(name) for name in response.raw.headers.keys()}
+        raw = response.raw
+        raw_headers = raw.headers if raw is not None else {}
+        headers = {name: response.raw.headers.getlist(name) for name in raw_headers.keys()}
         # Similar to http.client:319 (HTTP version detection in stdlib's `http` package)
-        http_version = "1.0" if response.raw.version == 10 else "1.1"
+        version = raw.version if raw is not None else 10
+        http_version = "1.0" if version == 10 else "1.1"
 
         def is_empty(_response: requests.Response) -> bool:
             # Assume the response is empty if:

schemathesis/parameters.py

@@ -2,6 +2,7 @@
 
 These are basic entities that describe what data could be sent to the API.
 """
+
 from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Generator, Generic, TypeVar