schemathesis 4.0.0a10__py3-none-any.whl → 4.0.0a12__py3-none-any.whl

schemathesis/cli/commands/run/handlers/output.py

@@ -4,6 +4,7 @@ import os
 import textwrap
 import time
 from dataclasses import dataclass, field
+from itertools import groupby
 from json.decoder import JSONDecodeError
 from types import GeneratorType
 from typing import TYPE_CHECKING, Any, Generator, Iterable
@@ -13,21 +14,19 @@ import click
 from schemathesis.cli.commands.run.context import ExecutionContext, GroupedFailures
 from schemathesis.cli.commands.run.events import LoadingFinished, LoadingStarted
 from schemathesis.cli.commands.run.handlers.base import EventHandler
-from schemathesis.cli.commands.run.reports import ReportConfig, ReportFormat
 from schemathesis.cli.constants import ISSUE_TRACKER_URL
 from schemathesis.cli.core import get_terminal_width
+from schemathesis.config import ProjectConfig, ReportFormat, SchemathesisWarning
 from schemathesis.core.errors import LoaderError, LoaderErrorKind, format_exception, split_traceback
 from schemathesis.core.failures import MessageBlock, Severity, format_failures
 from schemathesis.core.output import prepare_response_payload
 from schemathesis.core.result import Err, Ok
 from schemathesis.core.version import SCHEMATHESIS_VERSION
 from schemathesis.engine import Status, events
-from schemathesis.engine.config import EngineConfig
 from schemathesis.engine.errors import EngineErrorInfo
 from schemathesis.engine.phases import PhaseName, PhaseSkipReason
 from schemathesis.engine.phases.probes import ProbeOutcome
 from schemathesis.engine.recorder import Interaction, ScenarioRecorder
-from schemathesis.experimental import GLOBAL_EXPERIMENTS
 from schemathesis.generation.modes import GenerationMode
 from schemathesis.schemas import ApiStatistic
 
@@ -100,7 +99,7 @@ def display_failures_for_single_test(ctx: ExecutionContext, label: str, checks:
                 failures=group.failures,
                 curl=group.code_sample,
                 formatter=failure_formatter,
-                config=ctx.output_config,
+                config=ctx.config.output,
             )
         )
         click.echo()
@@ -326,7 +325,13 @@ class ProbingProgressManager:
 @dataclass
 class WarningData:
     missing_auth: dict[int, set[str]] = field(default_factory=dict)
-    only_4xx_responses: set[str] = field(default_factory=set)  # operations that only returned 4xx
+    missing_test_data: set[str] = field(default_factory=set)
+    # operations that only returned 4xx
+    validation_mismatch: set[str] = field(default_factory=set)
+
+    @property
+    def is_empty(self) -> bool:
+        return not bool(self.missing_auth or self.missing_test_data or self.validation_mismatch)
 
 
 @dataclass
@@ -770,12 +775,7 @@ def format_duration(duration_ms: int) -> str:
 
 @dataclass
 class OutputHandler(EventHandler):
-    workers_num: int
-    # Seed can be absent in the deterministic mode
-    seed: int | None
-    rate_limit: str | None
-    wait_for_schema: float | None
-    engine_config: EngineConfig
+    config: ProjectConfig
 
     loading_manager: LoadingProgressManager | None = None
     probing_manager: ProbingProgressManager | None = None
@@ -784,7 +784,6 @@ class OutputHandler(EventHandler):
 
     statistic: ApiStatistic | None = None
     skip_reasons: list[str] = field(default_factory=list)
-    report_config: ReportConfig | None = None
     warnings: WarningData = field(default_factory=WarningData)
     errors: set[events.NonFatalError] = field(default_factory=set)
     phases: dict[PhaseName, tuple[Status, PhaseSkipReason | None]] = field(
@@ -800,7 +799,7 @@ class OutputHandler(EventHandler):
         elif isinstance(event, events.ScenarioStarted):
             self._on_scenario_started(event)
         elif isinstance(event, events.ScenarioFinished):
-            self._on_scenario_finished(event)
+            self._on_scenario_finished(ctx, event)
         if isinstance(event, events.EngineFinished):
             self._on_engine_finished(ctx, event)
         elif isinstance(event, events.Interrupted):
@@ -836,6 +835,8 @@ class OutputHandler(EventHandler):
         from rich.style import Style
         from rich.table import Table
 
+        self.config = event.config
+
         assert self.loading_manager is not None
         self.loading_manager.stop()
 
@@ -1020,7 +1021,7 @@ class OutputHandler(EventHandler):
             assert self.unit_tests_manager is not None
             self.unit_tests_manager.start_operation(event.label)
 
-    def _on_scenario_finished(self, event: events.ScenarioFinished) -> None:
+    def _on_scenario_finished(self, ctx: ExecutionContext, event: events.ScenarioFinished) -> None:
         if event.phase in [PhaseName.EXAMPLES, PhaseName.COVERAGE, PhaseName.FUZZING]:
             assert self.unit_tests_manager is not None
             if event.label:
@@ -1029,7 +1030,7 @@ class OutputHandler(EventHandler):
             self.unit_tests_manager.update_stats(event.status)
             if event.status == Status.SKIP and event.skip_reason is not None:
                 self.skip_reasons.append(event.skip_reason)
-            self._check_warnings(event)
+            self._check_warnings(ctx, event)
         elif (
             event.phase == PhaseName.STATEFUL_TESTING
             and not event.is_final
@@ -1039,15 +1040,22 @@ class OutputHandler(EventHandler):
             links_seen = {case.transition.id for case in event.recorder.cases.values() if case.transition is not None}
             self.stateful_tests_manager.update(links_seen, event.status)
 
-    def _check_warnings(self, event: events.ScenarioFinished) -> None:
+    def _check_warnings(self, ctx: ExecutionContext, event: events.ScenarioFinished) -> None:
         statistic = aggregate_status_codes(event.recorder.interactions.values())
 
         if statistic.total == 0:
             return
 
-        for status_code in (401, 403):
-            if statistic.ratio_for(status_code) >= TOO_MANY_RESPONSES_THRESHOLD:
-                self.warnings.missing_auth.setdefault(status_code, set()).add(event.recorder.label)
+        assert ctx.find_operation_by_label is not None
+        assert event.label is not None
+        operation = ctx.find_operation_by_label(event.label)
+
+        warnings = self.config.warnings_for(operation=operation)
+
+        if SchemathesisWarning.MISSING_AUTH in warnings:
+            for status_code in (401, 403):
+                if statistic.ratio_for(status_code) >= AUTH_ERRORS_THRESHOLD:
+                    self.warnings.missing_auth.setdefault(status_code, set()).add(event.recorder.label)
 
         # Warn if all positive test cases got 4xx in return and no failure was found
         def all_positive_are_rejected(recorder: ScenarioRecorder) -> bool:
@@ -1068,11 +1076,19 @@ class OutputHandler(EventHandler):
 
         if (
             event.status == Status.SUCCESS
-            and GenerationMode.POSITIVE in self.engine_config.execution.generation.modes
+            and (
+                SchemathesisWarning.MISSING_TEST_DATA in warnings or SchemathesisWarning.VALIDATION_MISMATCH in warnings
+            )
+            and GenerationMode.POSITIVE in self.config.generation_for(operation=operation, phase=event.phase.name).modes
             and all_positive_are_rejected(event.recorder)
-            and statistic.should_warn_about_only_4xx()
         ):
-            self.warnings.only_4xx_responses.add(event.recorder.label)
+            if SchemathesisWarning.MISSING_TEST_DATA in warnings and statistic.should_warn_about_missing_test_data():
+                self.warnings.missing_test_data.add(event.recorder.label)
+            if (
+                SchemathesisWarning.VALIDATION_MISMATCH in warnings
+                and statistic.should_warn_about_validation_mismatch()
+            ):
+                self.warnings.validation_mismatch.add(event.recorder.label)
 
     def _on_interrupted(self, event: events.Interrupted) -> None:
         from rich.padding import Padding
@@ -1097,6 +1113,7 @@ class OutputHandler(EventHandler):
             )
             self.console.print(message)
             self.console.print()
+            self.probing_manager = None
 
     def _on_fatal_error(self, ctx: ExecutionContext, event: events.FatalError) -> None:
         from rich.padding import Padding
@@ -1116,7 +1133,9 @@ class OutputHandler(EventHandler):
                     self.console.print(Padding(Text(extra), (0, 0, 0, 5)))
                 self.console.print()
 
-            if not (event.exception.kind == LoaderErrorKind.CONNECTION_OTHER and self.wait_for_schema is not None):
+            if not (
+                event.exception.kind == LoaderErrorKind.CONNECTION_OTHER and self.config.wait_for_schema is not None
+            ):
                 suggestion = LOADER_ERROR_SUGGESTIONS.get(event.exception.kind)
                 if suggestion is not None:
                     click.echo(_style(f"{click.style('Tip:', bold=True, fg='green')} {suggestion}"))
@@ -1134,85 +1153,83 @@ class OutputHandler(EventHandler):
         if not (
             isinstance(event.exception, LoaderError)
             and event.exception.kind == LoaderErrorKind.CONNECTION_OTHER
-            and self.wait_for_schema is not None
+            and self.config.wait_for_schema is not None
         ):
             click.echo(_style(f"\n{click.style('Tip:', bold=True, fg='green')} {suggestion}"))
 
         raise click.Abort
 
-    def display_warnings(self) -> None:
-        display_section_name("WARNINGS")
-        click.echo()
-        if self.warnings.missing_auth:
-            total = sum(len(endpoints) for endpoints in self.warnings.missing_auth.values())
-            suffix = "" if total == 1 else "s"
-            click.echo(
-                _style(
-                    f"Missing or invalid API credentials: {total} API operation{suffix} returned authentication errors\n",
-                    fg="yellow",
-                )
+    def _display_warning_block(
+        self, title: str, operations: set[str] | dict, tips: list[str], operation_suffix: str = ""
+    ) -> None:
+        if isinstance(operations, dict):
+            total = sum(len(ops) for ops in operations.values())
+        else:
+            total = len(operations)
+
+        suffix = "" if total == 1 else "s"
+        click.echo(
+            _style(
+                f"{title}: {total} operation{suffix}{operation_suffix}\n",
+                fg="yellow",
             )
+        )
 
-            for status_code, operations in self.warnings.missing_auth.items():
+        # Print up to 3 endpoints, then "+N more"
+        def _print_up_to_three(operations_: list[str] | set[str]) -> None:
+            for operation in sorted(operations_)[:3]:
+                click.echo(_style(f"  - {operation}", fg="yellow"))
+            extra_count = len(operations_) - 3
+            if extra_count > 0:
+                click.echo(_style(f"  + {extra_count} more", fg="yellow"))
+
+        if isinstance(operations, dict):
+            for status_code, ops in operations.items():
                 status_text = "Unauthorized" if status_code == 401 else "Forbidden"
-                count = len(operations)
+                count = len(ops)
                 suffix = "" if count == 1 else "s"
-                click.echo(
-                    _style(
-                        f"{status_code} {status_text} ({count} operation{suffix}):",
-                        fg="yellow",
-                    )
-                )
-                # Show first few API operations
-                for endpoint in sorted(operations)[:3]:
-                    click.echo(_style(f"  - {endpoint}", fg="yellow"))
-                if len(operations) > 3:
-                    click.echo(_style(f"  + {len(operations) - 3} more", fg="yellow"))
-                click.echo()
-            click.echo(_style("Tip: ", bold=True, fg="yellow"), nl=False)
-            click.echo(_style(f"Use {bold('--auth')} ", fg="yellow"), nl=False)
-            click.echo(_style(f"or {bold('-H')} ", fg="yellow"), nl=False)
-            click.echo(_style("to provide authentication credentials", fg="yellow"))
-            click.echo()
+                click.echo(_style(f"{status_code} {status_text} ({count} operation{suffix}):", fg="yellow"))
 
-        if self.warnings.only_4xx_responses:
-            count = len(self.warnings.only_4xx_responses)
-            suffix = "" if count == 1 else "s"
-            click.echo(
-                _style(
-                    f"Schemathesis configuration: {count} operation{suffix} returned only 4xx responses during unit tests\n",
-                    fg="yellow",
-                )
-            )
+                _print_up_to_three(ops)
+        else:
+            _print_up_to_three(operations)
 
-            for endpoint in sorted(self.warnings.only_4xx_responses)[:3]:
-                click.echo(_style(f"  - {endpoint}", fg="yellow"))
-            if len(self.warnings.only_4xx_responses) > 3:
-                click.echo(_style(f"  + {len(self.warnings.only_4xx_responses) - 3} more", fg="yellow"))
+        if tips:
             click.echo()
 
-            click.echo(_style("Tip: ", bold=True, fg="yellow"), nl=False)
-            click.echo(_style("Check base URL or adjust data generation settings", fg="yellow"))
-            click.echo()
+        for tip in tips:
+            click.echo(_style(tip, fg="yellow"))
 
-    def display_experiments(self) -> None:
-        display_section_name("EXPERIMENTS")
+        click.echo()
 
+    def display_warnings(self) -> None:
+        display_section_name("WARNINGS")
         click.echo()
-        for experiment in sorted(GLOBAL_EXPERIMENTS.enabled, key=lambda e: e.name):
-            click.echo(_style(f"🧪 {experiment.name}: ", bold=True), nl=False)
-            click.echo(_style(experiment.description))
-            click.echo(_style(f"   Feedback: {experiment.discussion_url}"))
-            click.echo()
+        if self.warnings.missing_auth:
+            self._display_warning_block(
+                title="Missing authentication",
+                operations=self.warnings.missing_auth,
+                operation_suffix=" returned authentication errors",
+                tips=["💡 Use --auth or -H to provide authentication credentials"],
+            )
 
-        click.echo(
-            _style(
-                "Your feedback is crucial for experimental features. "
-                "Please visit the provided URL(s) to share your thoughts.",
-                dim=True,
+        if self.warnings.missing_test_data:
+            self._display_warning_block(
+                title="Missing test data",
+                operations=self.warnings.missing_test_data,
+                operation_suffix=" repeatedly returned 404 Not Found, preventing tests from reaching your API's core logic",
+                tips=[
+                    "💡 Provide realistic parameter values in your config file so tests can access existing resources",
+                ],
+            )
+
+        if self.warnings.validation_mismatch:
+            self._display_warning_block(
+                title="Schema validation mismatch",
+                operations=self.warnings.validation_mismatch,
+                operation_suffix=" mostly rejected generated data due to validation errors, indicating schema constraints don't match API validation",
+                tips=["💡 Check your schema constraints - API validation may be stricter than documented"],
             )
-        )
-        click.echo()
 
     def display_stateful_failures(self, ctx: ExecutionContext) -> None:
         display_section_name("Stateful tests")
@@ -1255,7 +1272,7 @@ class OutputHandler(EventHandler):
                     click.echo(f"\n{indent}<EMPTY>")
                 else:
                     try:
-                        payload = prepare_response_payload(response.text, config=ctx.output_config)
+                        payload = prepare_response_payload(response.text, config=ctx.config.output)
                         click.echo(textwrap.indent(f"\n{payload}", prefix=indent))
                     except UnicodeDecodeError:
                         click.echo(f"\n{indent}<BINARY>")
@@ -1410,24 +1427,27 @@ class OutputHandler(EventHandler):
         display_section_name(message, fg=color)
 
     def display_reports(self) -> None:
-        if self.report_config is not None:
-            reports = [
-                (format.value.upper(), self.report_config.get_path(format).name)
-                for format in ReportFormat
-                if format in self.report_config.formats
-            ]
-
+        reports = self.config.reports
+        if reports.vcr.enabled or reports.har.enabled or reports.junit.enabled:
             click.echo(_style("Reports:", bold=True))
-            for report_type, path in reports:
-                click.echo(_style(f"  - {report_type}: {path}"))
+            for format, report in (
+                (ReportFormat.JUNIT, reports.junit),
+                (ReportFormat.VCR, reports.vcr),
+                (ReportFormat.HAR, reports.har),
+            ):
+                if report.enabled:
+                    path = reports.get_path(format)
+                    click.echo(_style(f"  - {format.value.upper()}: {path}"))
             click.echo()
 
     def display_seed(self) -> None:
         click.echo(_style("Seed: ", bold=True), nl=False)
-        if self.seed is None:
+        # Deterministic mode can be applied to a subset of tests, but we only care if it is enabled everywhere
+        # If not everywhere, then the seed matter and should be displayed
+        if self.config.seed is None or self.config.generation.deterministic:
             click.echo("not used in the deterministic mode")
         else:
-            click.echo(str(self.seed))
+            click.echo(str(self.config.seed))
         click.echo()
 
     def _on_engine_finished(self, ctx: ExecutionContext, event: events.EngineFinished) -> None:
@@ -1438,9 +1458,13 @@ class OutputHandler(EventHandler):
         if self.errors:
             display_section_name("ERRORS")
             errors = sorted(self.errors, key=lambda r: (r.phase.value, r.label, r.info.title))
-            for error in errors:
-                display_section_name(error.label, "_", fg="red")
-                click.echo(error.info.format(bold=lambda x: click.style(x, bold=True)))
+            for label, group_errors in groupby(errors, key=lambda r: r.label):
+                display_section_name(label, "_", fg="red")
+                _errors = list(group_errors)
+                for idx, error in enumerate(_errors, 1):
+                    click.echo(error.info.format(bold=lambda x: click.style(x, bold=True)))
+                    if idx < len(_errors):
+                        click.echo()
             click.echo(
                 _style(
                     f"\nNeed more help?\n    Join our Discord server: {DISCORD_LINK}",
@@ -1448,10 +1472,8 @@ class OutputHandler(EventHandler):
                 )
             )
         display_failures(ctx)
-        if self.warnings.missing_auth or self.warnings.only_4xx_responses:
+        if not self.warnings.is_empty:
             self.display_warnings()
-        if GLOBAL_EXPERIMENTS.enabled:
-            self.display_experiments()
         if ctx.statistic.extraction_failures:
             self.display_stateful_failures(ctx)
         display_section_name("SUMMARY")
@@ -1468,21 +1490,39 @@ class OutputHandler(EventHandler):
         if self.errors:
             self.display_errors_summary()
 
-        if self.warnings.missing_auth or self.warnings.only_4xx_responses:
+        if not self.warnings.is_empty:
             click.echo(_style("Warnings:", bold=True))
 
             if self.warnings.missing_auth:
                 affected = sum(len(operations) for operations in self.warnings.missing_auth.values())
-                click.echo(_style(f"  ⚠️ Missing authentication: {bold(str(affected))}", fg="yellow"))
+                suffix = "" if affected == 1 else "s"
+                click.echo(
+                    _style(
+                        f"  ⚠️ Missing authentication: {bold(str(affected))} operation{suffix} returned only 401/403 responses",
+                        fg="yellow",
+                    )
+                )
 
-            if self.warnings.only_4xx_responses:
-                count = len(self.warnings.only_4xx_responses)
+            if self.warnings.missing_test_data:
+                count = len(self.warnings.missing_test_data)
                 suffix = "" if count == 1 else "s"
                 click.echo(
-                    _style(f"  ⚠️ Schemathesis configuration: {bold(str(count))}", fg="yellow"),
-                    nl=False,
+                    _style(
+                        f"  ⚠️ Missing valid test data: {bold(str(count))} operation{suffix} repeatedly returned 404 responses",
+                        fg="yellow",
+                    )
+                )
+
+            if self.warnings.validation_mismatch:
+                count = len(self.warnings.validation_mismatch)
+                suffix = "" if count == 1 else "s"
+                click.echo(
+                    _style(
+                        f"  ⚠️ Schema validation mismatch: {bold(str(count))} operation{suffix} mostly rejected generated data",
+                        fg="yellow",
+                    )
                 )
-                click.echo(_style(f" operation{suffix} returned only 4xx responses during unit tests", fg="yellow"))
+
             click.echo()
 
         if ctx.summary_lines:
@@ -1495,12 +1535,6 @@ class OutputHandler(EventHandler):
         self.display_final_line(ctx, event)
 
 
-TOO_MANY_RESPONSES_WARNING_TEMPLATE = (
-    "Most of the responses from {} have a {} status code. Did you specify proper API credentials?"
-)
-TOO_MANY_RESPONSES_THRESHOLD = 0.9
-
-
 @dataclass
 class StatusCodeStatistic:
     """Statistics about HTTP status codes in a scenario."""
@@ -1516,15 +1550,55 @@ class StatusCodeStatistic:
             return 0.0
         return self.counts.get(status_code, 0) / self.total
 
-    def should_warn_about_only_4xx(self) -> bool:
-        """Check if an operation should be warned about (only 4xx responses, excluding auth)."""
+    def _get_4xx_breakdown(self) -> tuple[int, int, int]:
+        """Get breakdown of 4xx responses: (404_count, other_4xx_count, total_4xx_count)."""
+        count_404 = self.counts.get(404, 0)
+        count_other_4xx = sum(
+            count for code, count in self.counts.items() if 400 <= code < 500 and code not in {401, 403, 404}
+        )
+        total_4xx = count_404 + count_other_4xx
+        return count_404, count_other_4xx, total_4xx
+
+    def _is_only_4xx_responses(self) -> bool:
+        """Check if all responses are 4xx (excluding 5xx)."""
+        return all(400 <= code < 500 for code in self.counts.keys() if code not in {500})
+
+    def _can_warn_about_4xx(self) -> bool:
+        """Check basic conditions for 4xx warnings."""
         if self.total == 0:
             return False
-        # Don't duplicate auth warnings
-        if set(self.counts.keys()) <= {401, 403}:
+        # Skip if only auth errors
+        if set(self.counts.keys()) <= {401, 403, 500}:
+            return False
+        return self._is_only_4xx_responses()
+
+    def should_warn_about_missing_test_data(self) -> bool:
+        """Check if an operation should be warned about missing test data (significant 404 responses)."""
+        if not self._can_warn_about_4xx():
+            return False
+
+        count_404, _, total_4xx = self._get_4xx_breakdown()
+
+        if total_4xx == 0:
+            return False
+
+        return (count_404 / total_4xx) >= OTHER_CLIENT_ERRORS_THRESHOLD
+
+    def should_warn_about_validation_mismatch(self) -> bool:
+        """Check if an operation should be warned about validation mismatch (significant 400/422 responses)."""
+        if not self._can_warn_about_4xx():
+            return False
+
+        _, count_other_4xx, total_4xx = self._get_4xx_breakdown()
+
+        if total_4xx == 0:
             return False
-        # At this point we know we only have 4xx responses
-        return True
+
+        return (count_other_4xx / total_4xx) >= OTHER_CLIENT_ERRORS_THRESHOLD
+
+
+AUTH_ERRORS_THRESHOLD = 0.9
+OTHER_CLIENT_ERRORS_THRESHOLD = 0.1
 
 
 def aggregate_status_codes(interactions: Iterable[Interaction]) -> StatusCodeStatistic:

schemathesis/cli/commands/run/loaders.py

@@ -6,42 +6,28 @@ supporting both GraphQL and OpenAPI specifications.
 
 from __future__ import annotations
 
+import os
 import warnings
-from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Callable
 
 from schemathesis import graphql, openapi
-from schemathesis.core import NOT_SET, NotSet
+from schemathesis.config import ProjectConfig
 from schemathesis.core.errors import LoaderError, LoaderErrorKind
 from schemathesis.core.fs import file_exists
-from schemathesis.core.output import OutputConfig
-from schemathesis.generation import GenerationConfig
 
 if TYPE_CHECKING:
-    from schemathesis.engine.config import NetworkConfig
     from schemathesis.schemas import BaseSchema
 
-Loader = Callable[["AutodetectConfig"], "BaseSchema"]
+Loader = Callable[["ProjectConfig"], "BaseSchema"]
 
 
-@dataclass
-class AutodetectConfig:
-    location: str
-    network: NetworkConfig
-    wait_for_schema: float | None
-    base_url: str | None | NotSet = NOT_SET
-    rate_limit: str | None | NotSet = NOT_SET
-    generation: GenerationConfig | NotSet = NOT_SET
-    output: OutputConfig | NotSet = NOT_SET
-
-
-def load_schema(config: AutodetectConfig) -> BaseSchema:
+def load_schema(location: str, config: ProjectConfig) -> BaseSchema:
     """Load API schema automatically based on the provided configuration."""
-    if is_probably_graphql(config.location):
+    if is_probably_graphql(location):
         # Try GraphQL first, then fallback to Open API
-        return _try_load_schema(config, graphql, openapi)
+        return _try_load_schema(location, config, graphql, openapi)
     # Try Open API first, then fallback to GraphQL
-    return _try_load_schema(config, openapi, graphql)
+    return _try_load_schema(location, config, openapi, graphql)
 
 
 def should_try_more(exc: LoaderError) -> bool:
@@ -60,27 +46,28 @@ def should_try_more(exc: LoaderError) -> bool:
     )
 
 
-def detect_loader(schema_or_location: str | dict[str, Any], module: Any) -> Callable:
+def detect_loader(location: str, module: Any) -> Callable:
     """Detect API schema loader."""
-    if isinstance(schema_or_location, str):
-        if file_exists(schema_or_location):
-            return module.from_path  # type: ignore
-        return module.from_url  # type: ignore
-    raise NotImplementedError
+    if file_exists(location):
+        return module.from_path  # type: ignore
+    return module.from_url  # type: ignore
 
 
-def _try_load_schema(config: AutodetectConfig, first_module: Any, second_module: Any) -> BaseSchema:
+def _try_load_schema(location: str, config: ProjectConfig, first_module: Any, second_module: Any) -> BaseSchema:
     """Try to load schema with fallback option."""
     from urllib3.exceptions import InsecureRequestWarning
 
     with warnings.catch_warnings():
         warnings.simplefilter("ignore", InsecureRequestWarning)
         try:
-            return _load_schema(config, first_module)
+            return _load_schema(location, config, first_module)
         except LoaderError as exc:
+            # If this was the OpenAPI loader on an explicit OpenAPI file, don't fallback
+            if first_module is openapi and is_openapi_file(location):
+                raise exc
             if should_try_more(exc):
                 try:
-                    return _load_schema(config, second_module)
+                    return _load_schema(location, config, second_module)
                 except Exception as second_exc:
                     if is_specific_exception(second_exc):
                         raise second_exc
@@ -88,26 +75,23 @@ def _try_load_schema(config: AutodetectConfig, first_module: Any, second_module:
             raise exc
 
 
-def _load_schema(config: AutodetectConfig, module: Any) -> BaseSchema:
+def _load_schema(location: str, config: ProjectConfig, module: Any) -> BaseSchema:
     """Unified schema loader for both GraphQL and OpenAPI."""
-    loader = detect_loader(config.location, module)
+    loader = detect_loader(location, module)
 
     kwargs: dict = {}
     if loader is module.from_url:
         if config.wait_for_schema is not None:
             kwargs["wait_for_schema"] = config.wait_for_schema
-        kwargs["verify"] = config.network.tls_verify
-        if config.network.cert:
-            kwargs["cert"] = config.network.cert
-        if config.network.auth:
-            kwargs["auth"] = config.network.auth
-
-    return loader(config.location, **kwargs).configure(
-        base_url=config.base_url,
-        rate_limit=config.rate_limit,
-        output=config.output,
-        generation=config.generation,
-    )
+        kwargs["verify"] = config.tls_verify
+        request_cert = config.request_cert_for()
+        if request_cert:
+            kwargs["cert"] = request_cert
+        auth = config.auth_for()
+        if auth is not None:
+            kwargs["auth"] = auth
+
+    return loader(location, config=config._parent, **kwargs)
 
 
 def is_specific_exception(exc: Exception) -> bool:
@@ -120,10 +104,11 @@ def is_specific_exception(exc: Exception) -> bool:
     )
 
 
-def is_probably_graphql(schema_or_location: str | dict[str, Any]) -> bool:
+def is_probably_graphql(location: str) -> bool:
     """Detect whether it is likely that the given location is a GraphQL endpoint."""
-    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"]
-    )
+    return location.endswith(("/graphql", "/graphql/", ".graphql", ".gql"))
+
+
+def is_openapi_file(location: str) -> bool:
+    name = os.path.basename(location).lower()
+    return any(name == f"{base}{ext}" for base in ("openapi", "swagger") for ext in (".json", ".yaml", ".yml"))