Reviewing files that changed from the base of the PR and between 0a41d43 and 025e226.

• src/datamodel_code_generator/__init__.py
• src/datamodel_code_generator/format.py
• src/datamodel_code_generator/model/base.py
• src/datamodel_code_generator/parser/base.py
• src/datamodel_code_generator/parser/graphql.py
• src/datamodel_code_generator/parser/jsonschema.py
• src/datamodel_code_generator/parser/openapi.py
• tests/test_format.py

• GitHub Check: py312-isort7 on Ubuntu
• GitHub Check: py312-isort5 on Ubuntu
• GitHub Check: py312-black23 on Ubuntu
• GitHub Check: py312-pydantic1 on Ubuntu
• GitHub Check: 3.13 on Windows
• GitHub Check: 3.10 on Windows
• GitHub Check: 3.11 on Windows
• GitHub Check: 3.12 on Windows
• GitHub Check: 3.14 on Windows
• GitHub Check: 3.12 on Ubuntu
• GitHub Check: benchmarks
• GitHub Check: Analyze (python)

src/datamodel_code_generator/model/base.py (4)

404-420: Verify the intended caching behavior for directory existence checks.

The custom_dir.exists() check on line 411 executes only when the cache misses. If a custom template directory is created after the environment is cached, it won't be detected or used. This optimization assumes template directories are static at runtime.

This is likely intentional for performance, but confirm that this behavior aligns with expected usage patterns.

---

423-436: LGTM! Clean separation of environment and template caching.

The refactoring properly delegates environment creation to the cached _get_environment function while maintaining the template-level cache. This two-tier caching strategy is efficient and maintains the original behavior.

---

439-449: LGTM! Proper caching for absolute path templates.

The function correctly creates an environment with fallback to built-in templates. The absence of existence checks is safe since callers (line 721) only invoke this after verifying the template file exists.

---

452-462: LGTM! Consistent refactoring pattern.

The refactoring mirrors the approach used in _get_template_with_custom_dir, providing consistent two-tier caching for absolute path templates.

src/datamodel_code_generator/parser/jsonschema.py (1)

624-625: defer_formatting wiring in JsonSchemaParser looks correct

The new defer_formatting argument is added with a safe default and forwarded to Parser.__init__ via keyword, so existing callers remain compatible while enabling deferred Ruff behavior.

Also applies to: 733-734

src/datamodel_code_generator/parser/openapi.py (1)

281-282: OpenAPIParser defer_formatting propagation is consistent and non‑breaking

The new defer_formatting flag is added with a default and cleanly forwarded to the base parser, matching the JsonSchemaParser pattern and preserving existing behavior.

Also applies to: 391-392

src/datamodel_code_generator/parser/graphql.py (1)

198-199: GraphQLParser defer_formatting integration is aligned with other parsers

Adding and forwarding defer_formatting mirrors the JSON/OpenAPI parsers and should make GraphQL formatting behavior consistent without affecting existing callers.

Also applies to: 306-307

src/datamodel_code_generator/__init__.py (1)

33-41: Deferred Ruff + batch directory formatting in generate() is coherent

• Importing CodeFormatter here and computing defer_formatting = output is not None and not output.suffix correctly distinguishes directory/extension‑less outputs from the typical single‑file models.py case.
• Passing defer_formatting into the parser ensures Ruff is skipped during per‑file format_code when we intend to run it once over the final directory.
• The final block that instantiates CodeFormatter and calls format_directory(output) only when defer_formatting is true and Ruff is requested gives the desired “batch Ruff over directory” behavior without changing Black/isort semantics.

Net effect: single‑file flows behave as before, while modular/directory flows now avoid N× Ruff invocations in favor of a single batch run.

Also applies to: 711-712, 811-812, 935-951

tests/test_format.py (1)

216-336: New formatting tests thoroughly cover directory and deferred Ruff behavior

The added tests validate:

• format_directory() calling the correct Ruff commands (check/format/both) with the expected cwd.
• defer_formatting=True preventing any Ruff subprocess calls from format_code.
• generate() invoking batch Ruff exactly twice for directory output with both Ruff formatters.

This gives good confidence in the new formatting pipeline wiring.

src/datamodel_code_generator/parser/base.py (3)

779-779: LGTM! Well-placed parameter addition.

The defer_formatting parameter is properly typed, has a sensible default value for backward compatibility, and is logically placed alongside other formatting-related parameters.

---

955-955: LGTM! Standard instance variable initialization.

The instance variable is properly initialized and logically grouped with related formatting configuration.

---

2718-2718: LGTM! Correct parameter propagation.

The defer_formatting flag is properly forwarded to CodeFormatter, completing the integration chain from Parser initialization to the formatting stage.

Reviewing files that changed from the base of the PR and between 025e226 and 06140a1.

• src/datamodel_code_generator/format.py
• tests/test_format.py

• tests/test_format.py

• GitHub Check: 3.11 on Windows
• GitHub Check: 3.13 on macOS
• GitHub Check: 3.10 on Windows
• GitHub Check: 3.12 on macOS
• GitHub Check: 3.12 on Windows
• GitHub Check: 3.13 on Windows
• GitHub Check: 3.14 on Windows
• GitHub Check: benchmarks
• GitHub Check: Analyze (python)

src/datamodel_code_generator/format.py (4)

9-11: LGTM! Necessary imports for new functionality.

The shutil and sys imports support the new _find_ruff_path method for locating the Ruff executable.

---

296-304: Nice optimization: combined Ruff pipeline reduces subprocess overhead.

The logic correctly routes to the combined apply_ruff_check_and_format when both Ruff check and format are enabled, avoiding two separate subprocess calls. The deferred formatting path appropriately skips Ruff processing here, assuming format_directory will be called later.

---

374-389: LGTM! Safe directory-level formatting implementation.

The method correctly uses tuple arguments with subprocess.run, avoiding shell injection risks. The separate subprocess calls for check and format are appropriate for directory operations where the shell pipe optimization would be less beneficial.

---

10-10: Remove unused noqa directives.

Static analysis reports that the noqa directives on these lines suppress rules that are not enabled in your configuration.

🔎 Proposed fix

-import subprocess  # noqa: S404
+import subprocess

-        defer_formatting: bool = False,  # noqa: FBT001, FBT002
+        defer_formatting: bool = False,

Also applies to: 188-188

⛔ Skipped due to learnings

Learnt from: koxudaxi
Repo: koxudaxi/datamodel-code-generator PR: 2681
File: tests/cli_doc/test_cli_doc_coverage.py:82-82
Timestamp: 2025-12-18T13:43:16.235Z
Learning: In datamodel-code-generator project, Ruff preview mode is enabled via `lint.preview = true` in pyproject.toml. This enables preview rules like PLR6301 (no-self-use), so `noqa: PLR6301` directives are necessary and should not be removed even if RUF100 suggests they are unused.

Reviewing files that changed from the base of the PR and between 06140a1 and 38010cf.

• src/datamodel_code_generator/format.py
• tests/main/test_main_general.py
• tests/test_format.py

• GitHub Check: 3.12 on macOS
• GitHub Check: py312-isort5 on Ubuntu
• GitHub Check: 3.10 on macOS
• GitHub Check: 3.10 on Windows
• GitHub Check: 3.14 on Windows
• GitHub Check: 3.12 on Windows
• GitHub Check: 3.12 on Ubuntu
• GitHub Check: 3.11 on Windows
• GitHub Check: 3.13 on Windows
• GitHub Check: Analyze (python)
• GitHub Check: benchmarks

tests/test_format.py (5)

216-234: LGTM! Comprehensive test for format_directory with ruff check.

The test correctly validates that format_directory invokes ruff check --fix with the output directory path and appropriate working directory.

---

237-255: LGTM! Test correctly validates ruff format for directories.

The test properly verifies that format_directory invokes ruff format on the entire directory when RUFF_FORMAT is configured.

---

258-283: LGTM! Test validates combined Ruff check and format pipeline.

The test correctly verifies that both ruff check --fix and ruff format are invoked sequentially when both formatters are configured for directory formatting.

---

286-299: LGTM! Test validates deferred formatting skips Ruff subprocess calls.

The test correctly verifies that when defer_formatting=True, Ruff formatters (which use subprocess) are skipped while other formatters like Black continue to run. The assertion on output content confirms the code is returned (with non-Ruff formatters applied).

---

302-336: LGTM! Integration test validates batch Ruff formatting for directory output.

The test correctly validates that generate() with directory output and Ruff formatters applies batch formatting via two subprocess calls. The use of mock.ANY for cwd is appropriate since the exact working directory is implementation-dependent.

src/datamodel_code_generator/format.py (4)

296-304: LGTM! Defer formatting logic correctly skips Ruff for batch processing.

The implementation correctly:

• Applies Black and isort unconditionally (they work per-file)
• Defers Ruff formatters when defer_formatting=True for batch directory processing
• Uses combined pipeline when both Ruff formatters are present
• Applies custom formatters unconditionally

The defer logic is sound since Ruff formatting is applied later via format_directory when generating to directories.

---

341-364: LGTM! Process chaining correctly implements combined Ruff pipeline.

The implementation properly chains ruff check --fix and ruff format using subprocess pipes:

• Creates both processes with appropriate pipe configuration
• Closes check_proc.stdout in parent to enable proper SIGPIPE handling
• Uses communicate() for clean output capture
• Waits for both processes to complete

The # type: ignore comments are reasonable since mypy doesn't track that stdin is guaranteed to be a pipe.

---

366-374: LGTM! Windows compatibility correctly implemented.

The method properly handles platform differences:

• Uses ruff.exe on Windows, ruff elsewhere
• Checks virtual environment first (respects isolated environments)
• Falls back to PATH search via shutil.which

This addresses the Windows compatibility concern from previous reviews.

---

387-402: LGTM! Batch directory formatting implementation is efficient.

The method correctly applies Ruff formatters to entire directories in batch mode, which is more efficient than per-file formatting. The behavior is consistent with existing Ruff methods (apply_ruff_lint, apply_ruff_formatter) in silently ignoring formatter errors via check=False.

tests/main/test_main_general.py (4)

1362-1379: LGTM! Integration test validates combined Ruff pipeline end-to-end.

The test correctly exercises the combined ruff check and ruff format pipeline through the CLI interface and validates the formatted output matches expectations.

---

1382-1399: LGTM! Test validates ruff check formatter independently.

The test correctly verifies that ruff check --fix alone produces properly formatted output through the CLI.

---

1402-1419: LGTM! Test validates ruff format formatter independently.

The test correctly verifies that ruff format alone produces properly formatted output through the CLI.

---

1422-1434: LGTM! Test validates batch Ruff formatting for directory output.

The test correctly verifies that Ruff formatters are applied in batch mode when generating to a directory with multiple files. The assertions confirm that the generated files contain expected content with proper formatting.