datamodel-code-generator 0.67.0__tar.gz → 0.68.0__tar.gz

{datamodel_code_generator-0.67.0 → datamodel_code_generator-0.68.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamodel-code-generator
-Version: 0.67.0
+Version: 0.68.0
 Summary: Datamodel Code Generator
 Project-URL: Homepage, https://github.com/koxudaxi/datamodel-code-generator
 Project-URL: Source, https://github.com/koxudaxi/datamodel-code-generator

{datamodel_code_generator-0.67.0 → datamodel_code_generator-0.68.0}/scripts/build_conformance_docs.py

@@ -29,8 +29,11 @@ WORKFLOW_CLONE_RE = re.compile(
     r"git clone\b(?P<options>[^\n]*?)\s+(?P<url>https://[^\s]+)\s+(?P<path>\S+)",
 )
 WORKFLOW_CHECKOUT_RE = re.compile(r"git -C (?P<path>\S+) checkout (?P<ref>[0-9a-f]{40})")
+WORKFLOW_CACHE_PATH_RE = re.compile(r"^\s+path:\s*(?P<path>\S+)\s*$", re.MULTILINE)
 WORKFLOW_SPARSE_CHECKOUT_RE = re.compile(r"git -C \S+ sparse-checkout set (?P<paths>[^\n]+)")
 WORKFLOW_EXPECTED_COUNT_RE = re.compile(r"--expected-(?P<name>[a-z-]+)\s+(?P<count>\d+)")
+WORKFLOW_TOX_RUN_RE = re.compile(r"\btox\s+run\b[^\n]*\s-e\s+(?P<tox_env>[A-Za-z0-9_-]+)\b")
+WORKFLOW_TOX_INPUT_PATH_RE = re.compile(r"(?P<path>\.tox/[^\s\\]+)")
 
 
 @dataclass(frozen=True)
@@ -137,6 +140,7 @@ CONFORMANCE_SUITES = (
         ),
     ),
 )
+CONFORMANCE_TOX_ENVS = frozenset(spec.tox_env for spec in CONFORMANCE_SUITES)
 
 
 def _literal_assignment(tree: ast.Module, name: str) -> Any:
@@ -220,6 +224,108 @@ def _workflow_job_blocks(path: Path) -> dict[str, str]:
     return blocks
 
 
+def _workflow_step_blocks(block: str) -> list[str]:
+    """Split a workflow job block into top-level step blocks."""
+    steps: list[str] = []
+    current_step: list[str] = []
+
+    for line in block.splitlines():
+        if line.startswith("      - "):
+            if current_step:
+                steps.append("\n".join(current_step))
+            current_step = [line]
+            continue
+        if current_step:
+            current_step.append(line)
+
+    if current_step:
+        steps.append("\n".join(current_step))
+    return steps
+
+
+def _workflow_path_is_inside(path: str | None, base_path: str | None) -> bool:
+    """Return whether a workflow path is the base path or below it."""
+    if path is None or base_path is None:
+        return False
+    return path == base_path or path.startswith(f"{base_path}/")
+
+
+def _workflow_tox_input_path(step: str) -> str | None:
+    """Return the first .tox input path from a tox run step."""
+    if match := WORKFLOW_TOX_INPUT_PATH_RE.search(step):
+        return match.group("path")
+    return None
+
+
+def _workflow_clone_step(steps: list[str], input_path: str | None, end_index: int) -> str:
+    """Find the nearest preceding clone step for a tox run input path."""
+    if input_path is None:
+        return ""
+
+    for index in range(end_index - 1, -1, -1):
+        step = steps[index]
+        if (match := WORKFLOW_CLONE_RE.search(step)) and _workflow_path_is_inside(input_path, match.group("path")):
+            return step
+    return ""
+
+
+def _workflow_cache_enabled(steps: list[str], input_path: str | None, end_index: int) -> bool:
+    """Return whether a preceding cache step covers a tox run input path."""
+    if input_path is None:
+        return False
+
+    for index in range(end_index):
+        step = steps[index]
+        if (
+            "uses: actions/cache" in step
+            and (match := WORKFLOW_CACHE_PATH_RE.search(step))
+            and _workflow_path_is_inside(input_path, match.group("path"))
+        ):
+            return True
+    return False
+
+
+def _workflow_suite_jobs(job_id: str, job_name: str, steps: list[str]) -> dict[str, WorkflowJobMetadata]:
+    """Build suite-keyed metadata from consolidated e2e workflow steps."""
+    suite_jobs: dict[str, WorkflowJobMetadata] = {}
+
+    for index, step in enumerate(steps):
+        if not (tox_match := WORKFLOW_TOX_RUN_RE.search(step)):
+            continue
+        if (tox_env := tox_match.group("tox_env")) not in CONFORMANCE_TOX_ENVS:
+            continue
+
+        input_path = _workflow_tox_input_path(step)
+        end_index = index + 1
+        clone_step = _workflow_clone_step(steps, input_path, end_index)
+
+        clone_url: str | None = None
+        if match := WORKFLOW_CLONE_RE.search(clone_step):
+            clone_url = match.group("url")
+
+        checkout_ref: str | None = None
+        if match := WORKFLOW_CHECKOUT_RE.search(clone_step):
+            checkout_ref = match.group("ref")
+
+        sparse_checkout_paths: tuple[str, ...] = ()
+        if match := WORKFLOW_SPARSE_CHECKOUT_RE.search(clone_step):
+            sparse_checkout_paths = tuple(match.group("paths").split())
+
+        suite_jobs[tox_env] = WorkflowJobMetadata(
+            job_id=job_id,
+            job_name=job_name,
+            clone_url=clone_url,
+            checkout_ref=checkout_ref,
+            cache_enabled=_workflow_cache_enabled(steps, input_path, end_index),
+            sparse_checkout_paths=sparse_checkout_paths,
+            expected_counts={
+                match.group("name"): int(match.group("count")) for match in WORKFLOW_EXPECTED_COUNT_RE.finditer(step)
+            },
+        )
+
+    return suite_jobs
+
+
 def load_workflow_jobs(path: Path = WORKFLOW_PATH) -> dict[str, WorkflowJobMetadata]:
     """Load workflow job metadata needed by the conformance dashboard."""
     jobs: dict[str, WorkflowJobMetadata] = {}
@@ -227,6 +333,7 @@ def load_workflow_jobs(path: Path = WORKFLOW_PATH) -> dict[str, WorkflowJobMetad
         job_name = job_id
         if match := WORKFLOW_JOB_NAME_RE.search(block):
             job_name = match.group("name").strip("\"'")
+        steps = _workflow_step_blocks(block)
 
         clone_url: str | None = None
         if match := WORKFLOW_CLONE_RE.search(block):
@@ -248,10 +355,11 @@ def load_workflow_jobs(path: Path = WORKFLOW_PATH) -> dict[str, WorkflowJobMetad
             job_name=job_name,
             clone_url=clone_url,
             checkout_ref=checkout_ref,
-            cache_enabled="uses: actions/cache@" in block,
+            cache_enabled="uses: actions/cache" in block,
             sparse_checkout_paths=sparse_checkout_paths,
             expected_counts=expected_counts,
         )
+        jobs.update(_workflow_suite_jobs(job_id, job_name, steps))
     return jobs
 
 

{datamodel_code_generator-0.67.0 → datamodel_code_generator-0.68.0}/scripts/build_llms_txt.py

@@ -129,7 +129,12 @@ def extract_page_info(md_path: Path, url: str, depth: int = 0) -> PageInfo | Non
     if len(desc) > MAX_DESC_LEN:
         desc = desc[: MAX_DESC_LEN - 3] + "..."
     return PageInfo(
-        title=title, path=str(md_path.relative_to(DOCS_DIR)), url=url, description=desc, content=content, depth=depth
+        title=title,
+        path=md_path.relative_to(DOCS_DIR).as_posix(),
+        url=url,
+        description=desc,
+        content=content,
+        depth=depth,
     )
 
 

datamodel_code_generator-0.68.0/scripts/select_ci_test_shard.py

@@ -0,0 +1,257 @@
+"""Select deterministic pytest shards for CI."""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import json
+from pathlib import Path
+from typing import Any
+
+EXCLUDED_PARTS = frozenset({"__pycache__", "cli_doc", "data"})
+PAYLOAD_VALIDATION_FILE = "tests/main/test_payload_validation.py"
+SPLIT_NODE_FILES = frozenset({PAYLOAD_VALIDATION_FILE})
+RECIPE_VERSION = 1
+TESTS_ROOT = Path("tests")
+WEIGHT_OVERRIDES = {
+    # Rounded milliseconds from a full local pytest --durations run on 2026-07-03.
+    "tests/main/asyncapi/test_main_asyncapi.py": 420,
+    "tests/main/avro/test_main_avro.py": 2_270,
+    "tests/main/graphql/test_annotated.py": 80,
+    "tests/main/graphql/test_main_graphql.py": 1_180,
+    "tests/main/jsonschema/test_main_jsonschema.py": 13_210,
+    "tests/main/openapi/test_main_openapi.py": 7_530,
+    "tests/main/protobuf/test_main_protobuf.py": 520,
+    "tests/main/test_cli_fast_paths.py": 1_710,
+    "tests/main/test_dynamic_models.py": 550,
+    "tests/main/test_error_messages.py": 40,
+    "tests/main/test_exec_validation.py": 320,
+    "tests/main/test_generation_determinism.py": 860,
+    "tests/main/test_jsonschema_suite_conformance.py": 1,
+    "tests/main/test_main_csv.py": 50,
+    "tests/main/test_main_general.py": 3_990,
+    "tests/main/test_main_json.py": 120,
+    "tests/main/test_main_watch.py": 2_220,
+    "tests/main/test_main_yaml.py": 40,
+    "tests/main/test_parsed_source_cache_parity.py": 50,
+    "tests/main/test_performance.py": 1,
+    "tests/main/test_public_api_signature_baseline.py": 170,
+    "tests/main/test_types.py": 1,
+    "tests/main/xmlschema/test_main_xmlschema.py": 810,
+    "tests/model/dataclass/test_param.py": 1,
+    "tests/model/pydantic_v2/test_base_model.py": 1,
+    "tests/model/pydantic_v2/test_config.py": 1,
+    "tests/model/pydantic_v2/test_dataclass.py": 1,
+    "tests/model/pydantic_v2/test_root_model.py": 1,
+    "tests/model/pydantic_v2/test_root_model_type_alias.py": 1,
+    "tests/model/pydantic_v2/test_types.py": 1,
+    "tests/model/pydantic_v2/test_version.py": 1,
+    "tests/model/test_base.py": 10,
+    "tests/model/test_dataclass.py": 1,
+    "tests/parser/test_base.py": 990,
+    "tests/parser/test_default_put_dict.py": 1,
+    "tests/parser/test_generation.py": 1,
+    "tests/parser/test_generation_store_usage.py": 200,
+    "tests/parser/test_graph.py": 1,
+    "tests/parser/test_graphql.py": 190,
+    "tests/parser/test_imports.py": 230,
+    "tests/parser/test_jsonschema.py": 200,
+    "tests/parser/test_openapi.py": 1_960,
+    "tests/parser/test_scc.py": 100,
+    "tests/parser/test_schema_version.py": 210,
+    "tests/parser/test_xmlschema.py": 50,
+    "tests/skills/datamodel-code-generator/test_skill_flag_drift.py": 50,
+    "tests/skills/datamodel-code-generator/test_skill_recipes.py": 3_700,
+    "tests/test_assert_helper_usage.py": 190,
+    "tests/test_build_architecture_docs_script.py": 380,
+    "tests/test_build_conformance_docs_script.py": 50,
+    "tests/test_build_deprecation_docs_script.py": 100,
+    "tests/test_build_docs_examples_script.py": 40,
+    "tests/test_build_experimental_docs_script.py": 100,
+    "tests/test_build_llms_txt_script.py": 50,
+    "tests/test_build_playground_assets_script.py": 1,
+    "tests/test_build_preset_docs_script.py": 490,
+    "tests/test_build_release_benchmark_docs_script.py": 1_340,
+    "tests/test_build_schema_docs_script.py": 220,
+    "tests/test_conftest_helpers.py": 1,
+    "tests/test_deprecations.py": 1,
+    "tests/test_enums.py": 1,
+    "tests/test_experimental.py": 1,
+    "tests/test_format.py": 6_170,
+    "tests/test_generate_changelog_script.py": 230,
+    "tests/test_http.py": 1_090,
+    "tests/test_imports.py": 1,
+    "tests/test_infer_input_type.py": 110,
+    "tests/test_input_model.py": 1_630,
+    "tests/test_main_kr.py": 3_920,
+    "tests/test_package_metadata.py": 380,
+    "tests/test_prompt.py": 1,
+    "tests/test_reference.py": 1,
+    "tests/test_resolver.py": 1,
+    "tests/test_select_ci_test_shard_script.py": 250,
+    "tests/test_types.py": 10,
+    "tests/test_update_command_help_on_markdown_script.py": 1,
+    "tests/test_util.py": 40,
+    "tests/test_validate_release_draft_analysis_script.py": 1,
+    "tests/test_validators.py": 1,
+    "tests/test_yaml_backend.py": 1,
+}
+SPLIT_NODE_WEIGHT_OVERRIDES = {
+    f"{PAYLOAD_VALIDATION_FILE}::test_generated_payload_backend_accepts_representative_schema_payloads": 3_330,
+    f"{PAYLOAD_VALIDATION_FILE}::test_generated_payload_backend_rejects_representative_schema_invalid_payloads": 850,
+    f"{PAYLOAD_VALIDATION_FILE}::test_generated_pydantic_v2_model_accepts_schema_derived_payloads": 109_400,
+    f"{PAYLOAD_VALIDATION_FILE}::test_generated_pydantic_v2_model_dumps_schema_valid_payloads": 106_910,
+    f"{PAYLOAD_VALIDATION_FILE}::test_generated_pydantic_v2_model_rejects_schema_invalid_payloads": 58_170,
+    f"{PAYLOAD_VALIDATION_FILE}::test_msgspec_schema_runtime_exclusions_cover_known_semantic_gaps": 1,
+    f"{PAYLOAD_VALIDATION_FILE}::test_msgspec_schema_runtime_exclusions_detect_untyped_fractional_multiple_of": 1,
+    f"{PAYLOAD_VALIDATION_FILE}::test_msgspec_schema_runtime_exclusions_ignore_literal_payloads": 1,
+    f"{PAYLOAD_VALIDATION_FILE}::test_payload_backend_all_case_mode_widens_runtime_validating_backends": 10,
+    f"{PAYLOAD_VALIDATION_FILE}::test_payload_backend_case_mode_env_is_configurable": 1,
+    f"{PAYLOAD_VALIDATION_FILE}::test_payload_backend_case_mode_env_rejects_invalid_values": 1,
+    f"{PAYLOAD_VALIDATION_FILE}::test_payload_backend_full_matrix_exclusions_are_classified": 1,
+    f"{PAYLOAD_VALIDATION_FILE}::test_payload_backend_representative_matrix_is_classified": 1,
+    f"{PAYLOAD_VALIDATION_FILE}::test_payload_max_examples_env_is_configurable": 1,
+    f"{PAYLOAD_VALIDATION_FILE}::test_payload_max_examples_env_rejects_invalid_values": 1,
+    f"{PAYLOAD_VALIDATION_FILE}::test_payload_rejection_oracle_covers_supported_policy_constraints": 20,
+    f"{PAYLOAD_VALIDATION_FILE}::test_payload_rejection_oracle_policy_is_classified": 10,
+    f"{PAYLOAD_VALIDATION_FILE}::test_payload_round_trip_exclusions_are_classified": 1,
+    f"{PAYLOAD_VALIDATION_FILE}::test_payload_validation_cases_cover_discovered_schema_files": 690,
+    f"{PAYLOAD_VALIDATION_FILE}::test_pydantic_round_trip_exclusions_cover_uri_unique_items_normalization": 1,
+    f"{PAYLOAD_VALIDATION_FILE}::test_pydantic_v2_dataclass_legacy_exclusions_cover_fractional_multiple_of": 1,
+    f"{PAYLOAD_VALIDATION_FILE}::test_pydantic_v2_legacy_runtime_exclusions_are_classified": 1,
+    f"{PAYLOAD_VALIDATION_FILE}::test_pydantic_v2_legacy_runtime_exclusions_are_version_gated": 1,
+}
+
+
+def _as_posix(path: Path) -> str:
+    return path.as_posix()
+
+
+def _is_test_file(path: Path) -> bool:
+    if EXCLUDED_PARTS & set(path.parts):
+        return False
+    return path.name.startswith("test_") and path.suffix == ".py" and path.as_posix() not in SPLIT_NODE_FILES
+
+
+def _collect_split_nodeids(path: Path) -> list[str]:
+    module = ast.parse(path.read_text(encoding="utf-8"), filename=_as_posix(path))
+    nodeids: list[str] = []
+
+    for node in module.body:
+        match node:
+            case ast.FunctionDef(name=name) | ast.AsyncFunctionDef(name=name) if name.startswith("test_"):
+                nodeids.append(f"{_as_posix(path)}::{name}")
+            case ast.ClassDef(name=class_name) if class_name.startswith("Test"):
+                for child in node.body:
+                    match child:
+                        case ast.FunctionDef(name=name) | ast.AsyncFunctionDef(name=name) if name.startswith("test_"):
+                            nodeids.append(f"{_as_posix(path)}::{class_name}::{name}")
+
+    return sorted(nodeids)
+
+
+def _collect_test_items(root: Path = TESTS_ROOT) -> list[str]:
+    file_items = (path.as_posix() for path in root.rglob("*.py") if _is_test_file(path))
+    split_node_items = (
+        nodeid for split_file in sorted(SPLIT_NODE_FILES) for nodeid in _collect_split_nodeids(Path(split_file))
+    )
+    return sorted([*file_items, *split_node_items])
+
+
+def _item_weight(item: str) -> int:
+    path = Path(item.partition("::")[0])
+    if "::" in item:
+        return SPLIT_NODE_WEIGHT_OVERRIDES.get(item, 10_000)
+    return WEIGHT_OVERRIDES.get(item, path.stat().st_size)
+
+
+def _build_recipe_items() -> list[dict[str, int | str]]:
+    return [{"nodeid": item, "weight": _item_weight(item)} for item in _collect_test_items()]
+
+
+def _validate_recipe_items(items: Any) -> list[dict[str, int | str]]:
+    if not isinstance(items, list):
+        msg = "recipe items must be a list"
+        raise SystemExit(msg)
+
+    validated: list[dict[str, int | str]] = []
+    for item in items:
+        match item:
+            case {"nodeid": str(nodeid), "weight": int(weight)} if not isinstance(weight, bool):
+                validated.append({"nodeid": nodeid, "weight": weight})
+            case _:
+                msg = f"invalid recipe item: {item!r}"
+                raise SystemExit(msg)
+    return validated
+
+
+def _load_recipe_items(path: Path) -> list[dict[str, int | str]]:
+    recipe = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(recipe, dict) or recipe.get("version") != RECIPE_VERSION or "items" not in recipe:
+        msg = f"unsupported shard recipe: {recipe!r}"
+        raise SystemExit(msg)
+    return _validate_recipe_items(recipe["items"])
+
+
+def _write_recipe(path: Path, items: list[dict[str, int | str]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps({"version": RECIPE_VERSION, "items": items}, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+
+
+def _select_shard(items: list[dict[str, int | str]], shard_index: int, shard_total: int) -> list[str]:
+    shards: list[list[str]] = [[] for _ in range(shard_total)]
+    shard_weights = [0] * shard_total
+    weighted_items = sorted(
+        ((int(item["weight"]), str(item["nodeid"])) for item in items),
+        key=lambda item: (-item[0], item[1]),
+    )
+
+    for weight, item in weighted_items:
+        target = min(
+            range(shard_total),
+            key=lambda index: (shard_weights[index], len(shards[index]), index),
+        )
+        shards[target].append(item)
+        shard_weights[target] += weight
+
+    return sorted(shards[shard_index - 1])
+
+
+def _main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("shard_index", type=int, nargs="?")
+    parser.add_argument("shard_total", type=int, nargs="?")
+    parser.add_argument("--recipe", type=Path)
+    parser.add_argument("--write-recipe", type=Path)
+    args = parser.parse_args()
+
+    items = _load_recipe_items(args.recipe) if args.recipe else _build_recipe_items()
+    if args.write_recipe:
+        _write_recipe(args.write_recipe, items)
+        if args.shard_index is None and args.shard_total is None:
+            return
+
+    if args.shard_index is None or args.shard_total is None:
+        parser.error("shard_index and shard_total are required unless only --write-recipe is used")
+
+    shard_index = args.shard_index
+    shard_total = args.shard_total
+
+    match 1 <= shard_index <= shard_total:
+        case False:
+            msg = "shard_index must be between 1 and shard_total"
+            raise SystemExit(msg)
+        case True:
+            if selected := _select_shard(items, shard_index, shard_total):
+                print(*selected, sep="\n")
+                return
+
+    msg = f"No tests selected for shard {shard_index}/{shard_total}"
+    raise SystemExit(msg)
+
+
+if __name__ == "__main__":
+    _main()

{datamodel_code_generator-0.67.0 → datamodel_code_generator-0.68.0}/src/datamodel_code_generator/__init__.py

@@ -759,6 +759,43 @@ def _generate_config_values(generate_config: GenerateConfig) -> dict[str, Any]:
     return values
 
 
+def _warn_if_input_string_points_to_existing_path(
+    input_: Path | str | ParseResult | Mapping[str, Any] | list[Any],
+) -> None:
+    match input_:
+        case str() as input_text if input_text and "\n" not in input_text and "\r" not in input_text:
+            pass
+        case _:
+            return
+    try:
+        path = Path(input_text).expanduser()
+        path_exists = path.exists()
+    except (OSError, RuntimeError, ValueError):
+        return
+    if not path_exists:
+        return
+
+    import warnings  # noqa: PLC0415
+
+    with contextlib.suppress(Warning):
+        warnings.warn(
+            "`input_` strings are treated as schema text. "
+            "The value also resolves to an existing path; pass a `Path` object to read it as a file.",
+            stacklevel=3,
+        )
+
+
+@contextlib.contextmanager
+def _warn_on_input_string_path_failure(
+    input_: Path | str | ParseResult | Mapping[str, Any] | list[Any],
+) -> Iterator[None]:
+    try:
+        yield
+    except Exception:
+        _warn_if_input_string_points_to_existing_path(input_)
+        raise
+
+
 def _create_parser_config(
     generate_config: GenerateConfig,
     additional_options: ParserConfigDict
@@ -1148,7 +1185,7 @@ def _build_parser(  # noqa: PLR0911, PLR0913
     raise Error(msg)
 
 
-def _emit_results(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
+def _emit_results(  # noqa: PLR0912, PLR0913, PLR0915
     results: str | dict[tuple[str, ...], Any],
     input_: Path | str | ParseResult | Mapping[str, Any] | list[Any],
     input_filename: str | None,
@@ -1225,25 +1262,24 @@ def _emit_results(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
             for name, result in sorted(results.items())
         }
 
-    file: IO[Any] | None
     for path, (body, future_imports, filename) in modules.items():
         if not path.parent.exists():
             path.parent.mkdir(parents=True)
 
         safe_filename = filename.replace("\n", " ").replace("\r", " ") if filename else ""
         effective_header = custom_file_header or header.format(safe_filename)
-        file = path.open("wt", encoding=config.encoding)
-        if custom_file_header and body:
-            file.write(
-                _build_module_content(body, effective_header, custom_file_header, future_imports=future_imports) + "\n"
-            )
-        else:
-            file.write(effective_header)
-            if body:
-                file.write("\n\n")
-                file.write(body.rstrip())
-            file.write("\n")
-        file.close()
+        with path.open("wt", encoding=config.encoding) as file:
+            if custom_file_header and body:
+                file.write(
+                    _build_module_content(body, effective_header, custom_file_header, future_imports=future_imports)
+                    + "\n"
+                )
+            else:
+                file.write(effective_header)
+                if body:
+                    file.write("\n\n")
+                    file.write(body.rstrip())
+                file.write("\n")
 
     if defer_formatting and config.formatters:
         from datamodel_code_generator._format_types import Formatter  # noqa: PLC0415
@@ -1302,7 +1338,7 @@ def generate(  # noqa: PLR0912, PLR0914, PLR0915
     (JSON, YAML, Dict, CSV) as input.
 
     Args:
-        input_: The input source (file path, string content, URL, dict,
+        input_: The input source (Path file input, string content, URL, dict,
             list of file paths, or MCP tools list when input_file_type is
             InputFileType.MCPTools).
         config: A GenerateConfig object with all options. Cannot be used together with **options.
@@ -1426,8 +1462,9 @@ def generate(  # noqa: PLR0912, PLR0914, PLR0915
             raise Error(msg) from exc
 
         try:
-            assert isinstance(input_text_, str)
-            input_file_type = infer_input_type(input_text_)
+            with _warn_on_input_string_path_failure(input_):
+                assert isinstance(input_text_, str)
+                input_file_type = infer_input_type(input_text_)
         except Exception as exc:
             raise InvalidFileFormatError(exc) from exc
         else:
@@ -1440,15 +1477,17 @@ def generate(  # noqa: PLR0912, PLR0914, PLR0915
             if isinstance(input_, Path) and input_.is_file() and input_file_type not in RAW_DATA_TYPES:
                 input_text = input_text_
 
-    input_text = _normalize_raw_input(input_, input_text, input_file_type, config)
+    with _warn_on_input_string_path_failure(input_):
+        input_text = _normalize_raw_input(input_, input_text, input_file_type, config)
 
     if input_file_type == InputFileType.MCPTools:
-        source_override, input_file_type, skip_root_model = _convert_mcp_tools(
-            input_,
-            input_text,
-            config,
-            remote_text_cache,
-        )
+        with _warn_on_input_string_path_failure(input_):
+            source_override, input_file_type, skip_root_model = _convert_mcp_tools(
+                input_,
+                input_text,
+                config,
+                remote_text_cache,
+            )
 
     if isinstance(input_, ParseResult) and input_file_type not in RAW_DATA_TYPES:
         input_text = None
@@ -1469,29 +1508,35 @@ def generate(  # noqa: PLR0912, PLR0914, PLR0915
         _resolve_schema_versions(input_file_type, config.schema_version)
     )
 
-    parser = _build_parser(
-        input_file_type,
-        source,
-        config,
-        additional_options,
-        data_model_types,
-        jsonschema_version=jsonschema_version,
-        openapi_version=openapi_version,
-        asyncapi_version=asyncapi_version,
-        xmlschema_version=xmlschema_version,
-        protobuf_version=protobuf_version,
-    )
+    with _warn_on_input_string_path_failure(input_):
+        parser = _build_parser(
+            input_file_type,
+            source,
+            config,
+            additional_options,
+            data_model_types,
+            jsonschema_version=jsonschema_version,
+            openapi_version=openapi_version,
+            asyncapi_version=asyncapi_version,
+            xmlschema_version=xmlschema_version,
+            protobuf_version=protobuf_version,
+        )
 
     with chdir(config.output):
         try:
-            results = parser.parse(
-                settings_path=config.settings_path,
-                disable_future_imports=config.disable_future_imports,
-                all_exports_scope=config.all_exports_scope,
-                all_exports_collision_strategy=config.all_exports_collision_strategy,
-                module_split_mode=config.module_split_mode,
-                collect_model_metadata=config.emit_model_metadata is not None,
-            )
+            with _warn_on_input_string_path_failure(input_):
+                results = parser.parse(
+                    settings_path=config.settings_path,
+                    disable_future_imports=config.disable_future_imports,
+                    all_exports_scope=config.all_exports_scope,
+                    all_exports_collision_strategy=config.all_exports_collision_strategy,
+                    module_split_mode=config.module_split_mode,
+                    collect_model_metadata=config.emit_model_metadata is not None,
+                )
+        except Exception:
+            with contextlib.suppress(BaseException):
+                parser._dispose()  # noqa: SLF001
+            raise
         except BaseException:
             with contextlib.suppress(BaseException):
                 parser._dispose()  # noqa: SLF001