Bugfix-TypeAlias-Rebuild ---> Main (#2566)

* bugfix-type-alias-rebuild > main: added linting exceptions for docstrings

* bugfix-type-alias-rebuild > main: added property to indicate if TypeAlias

NOTE: we could also bypass this and just check the instance of the model, but this is more intentional.

* bugfix-type-alias-rebuild > main: do not add model path to update list if model is a type alias

* bugfix-type-alias-rebuild > main: added tests for coverage

* bugfix-type-alias-rebuild > main: added changes from review

* bugfix-type-alias-rebuild > main: added missing case for coverage

* bugfix-type-alias-rebuild > main: removed type declaration for QA

* bugfix-type-alias-rebuild > main: added e2e test scenarios

* bugfix-type-alias-rebuild > main: added e2e test cases

* bugfix-type-alias-rebuild > main: commented out case as recursive types not yet corrected for py311

* bugfix-type-alias-rebuild > main: linting

* Revert "bugfix-type-alias-rebuild > main: added linting exceptions for docstrings"

This reverts commit 4ba7085.

* bugfix-type-alias-rebuild > main: linting

* bugfix-type-alias-rebuild > main: linting

---------

Co-authored-by: raj-open <raj-open@users.noreply.github.com>
Co-authored-by: Koudai Aono <koxudaxi@gmail.com>

Author: raj-open

src/datamodel_code_generator/model/base.py

@@ -340,6 +340,7 @@ class DataModel(TemplateBase, Nullable, ABC):
     TEMPLATE_FILE_PATH: ClassVar[str] = ""
     BASE_CLASS: ClassVar[str] = ""
     DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = ()
+    IS_ALIAS: bool = False
 
     def __init__(  # noqa: PLR0913
         self,
@@ -523,6 +524,11 @@ def all_data_types(self) -> Iterator[DataType]:
             yield from field.data_type.all_data_types
         yield from self.base_classes
 
+    @property
+    def is_alias(self) -> bool:
+        """Whether is a type alias (i.e. not an instance of BaseModel/RootModel)."""
+        return self.IS_ALIAS
+
     @property
     def nullable(self) -> bool:
         """Check if this model is nullable."""

src/datamodel_code_generator/model/type_alias.py

@@ -22,6 +22,8 @@
 class TypeAliasBase(DataModel):
     """Base class for all type alias implementations."""
 
+    IS_ALIAS: bool = True
+
     @property
     def imports(self) -> tuple[Import, ...]:
         """Get imports including Annotated if needed."""

src/datamodel_code_generator/parser/base.py

@@ -132,6 +132,28 @@ def dump_templates(templates: list[DataModel]) -> str:
 MAX_RECURSION_COUNT: int = sys.getrecursionlimit()
 
 
+def add_model_path_to_list(
+    paths: list[str] | None,
+    model: DataModel,
+    /,
+) -> list[str]:
+    """
+    Auxiliary method which adds model path to list, provided the following hold.
+
+    - model is not a type alias
+    - path is not already in the list.
+
+    """
+    if paths is None:
+        paths = []
+    if model.is_alias:
+        return paths
+    if (path := model.path) in paths:
+        return paths
+    paths.append(path)
+    return paths
+
+
 def sort_data_models(  # noqa: PLR0912, PLR0915
     unsorted_data_models: list[DataModel],
     sorted_data_models: SortedDataModels | None = None,
@@ -151,13 +173,13 @@ def sort_data_models(  # noqa: PLR0912, PLR0915
             sorted_data_models[model.path] = model
         elif model.path in model.reference_classes and len(model.reference_classes) == 1:  # only self-referencing
             sorted_data_models[model.path] = model
-            require_update_action_models.append(model.path)
+            add_model_path_to_list(require_update_action_models, model)
         elif (
             not model.reference_classes - {model.path} - set(sorted_data_models)
         ):  # reference classes have been resolved
             sorted_data_models[model.path] = model
             if model.path in model.reference_classes:
-                require_update_action_models.append(model.path)
+                add_model_path_to_list(require_update_action_models, model)
         else:
             unresolved_references.append(model)
     if unresolved_references:
@@ -206,11 +228,11 @@ def sort_data_models(  # noqa: PLR0912, PLR0915
             if not unresolved_model:
                 sorted_data_models[model.path] = model
                 if update_action_parent:
-                    require_update_action_models.append(model.path)
+                    add_model_path_to_list(require_update_action_models, model)
                 continue
             if not unresolved_model - unsorted_data_model_names:
                 sorted_data_models[model.path] = model
-                require_update_action_models.append(model.path)
+                add_model_path_to_list(require_update_action_models, model)
                 continue
             # unresolved
             unresolved_classes = ", ".join(
@@ -1003,7 +1025,7 @@ def __reuse_model(self, models: list[DataModel], require_update_action_models: l
                         custom_template_dir=model._custom_template_dir,  # noqa: SLF001
                     )
                     if cached_model_reference.path in require_update_action_models:
-                        require_update_action_models.append(inherited_model.path)
+                        add_model_path_to_list(require_update_action_models, inherited_model)
                     models.insert(index, inherited_model)
                     models.remove(model)
 

tests/data/expected/main/openapi/type_alias_recursive.py

@@ -0,0 +1,42 @@
+# generated by datamodel-codegen:
+#   filename:  type_alias_recursive.yaml
+#   timestamp: 2019-07-26T00:00:00+00:00
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional, Union
+
+from pydantic import BaseModel
+from typing_extensions import TypeAlias
+
+
+class File(BaseModel):
+    path: str
+
+
+class Folder(BaseModel):
+    address: Optional[str] = None
+    files: List[File]
+    subfolders: Optional[List[Folder]] = None
+
+
+ElementaryType: TypeAlias = Optional[Union[bool, str, int, float]]
+
+
+JsonType: TypeAlias = Union[ElementaryType, List["JsonType"], Dict[str, "JsonType"]]
+
+
+class Space(BaseModel):
+    label: Optional[str] = None
+    data: Optional[JsonType] = None
+    dual: Optional[DualSpace] = None
+
+
+class DualSpace(BaseModel):
+    label: Optional[str] = None
+    data: Optional[JsonType] = None
+    predual: Optional[Space] = None
+
+
+Folder.update_forward_refs()
+Space.update_forward_refs()

tests/data/expected/main/openapi/type_alias_recursive_py312.py

@@ -0,0 +1,39 @@
+# generated by datamodel-codegen:
+#   filename:  type_alias_recursive.yaml
+#   timestamp: 2019-07-26T00:00:00+00:00
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class File(BaseModel):
+    path: str
+
+
+class Folder(BaseModel):
+    address: str | None = None
+    files: list[File]
+    subfolders: list[Folder] | None = None
+
+
+type ElementaryType = bool | str | int | float | None
+
+
+type JsonType = ElementaryType | list[JsonType] | dict[str, JsonType]
+
+
+class Space(BaseModel):
+    label: str | None = None
+    data: JsonType | None = None
+    dual: DualSpace | None = None
+
+
+class DualSpace(BaseModel):
+    label: str | None = None
+    data: JsonType | None = None
+    predual: Space | None = None
+
+
+Folder.model_rebuild()
+Space.model_rebuild()

tests/data/openapi/type_alias_recursive.yaml

@@ -0,0 +1,79 @@
+openapi: "3.0.0"
+info:
+  version: 1.0.0
+  title: TypeAlias Test
+  description: |-
+    Test cases for recursive models
+components:
+  schemas:
+
+    # ----------------------------------------------------------------
+    # Simple self-referential recursive types
+    # ----------------------------------------------------------------
+
+    File:
+      type: object
+      required:
+        - path
+      properties:
+        path:
+          type: string
+
+    Folder:
+      type: object
+      required:
+        - files
+        - folders
+      properties:
+        address:
+          type: string
+        files:
+          type: array
+          items:
+            $ref: "#/components/schemas/File"
+        subfolders:
+          type: array
+          items:
+            $ref: "#/components/schemas/Folder"
+
+    ElementaryType:
+      nullable: true
+      oneOf:
+        - type: boolean
+        - type: string
+        - type: integer
+        - type: number
+
+    JsonType:
+      oneOf:
+        - $ref: "#/components/schemas/ElementaryType"
+        - type: array
+          items:
+            $ref: "#/components/schemas/JsonType"
+        - type: object
+          additionalProperties:
+            $ref: "#/components/schemas/JsonType"
+
+    # ----------------------------------------------------------------
+    # Binary recursive types
+    # ----------------------------------------------------------------
+
+    Space:
+      type: object
+      properties:
+        label:
+          type: string
+        data:
+          $ref: "#/components/schemas/JsonType"
+        dual:
+          $ref: "#/components/schemas/DualSpace"
+
+    DualSpace:
+      type: object
+      properties:
+        label:
+          type: string
+        data:
+          $ref: "#/components/schemas/JsonType"
+        predual:
+          $ref: "#/components/schemas/Space"

tests/main/openapi/test_main_openapi.py

@@ -2130,6 +2130,34 @@ def test_main_openapi_type_alias_py312(output_file: Path) -> None:
     )
 
 
+@pytest.mark.skipif(
+    int(black.__version__.split(".")[0]) < 23,
+    reason="Installed black doesn't support the new 'type' statement",
+)
+def test_main_openapi_type_alias_recursive_py312(output_file: Path) -> None:
+    """
+    Test that handling of type aliases work as expected for recursive types.
+
+    NOTE: applied to python 3.12--14
+    """
+    run_main_and_assert(
+        input_path=OPEN_API_DATA_PATH / "type_alias_recursive.yaml",
+        output_path=output_file,
+        input_file_type="openapi",
+        assert_func=assert_file_content,
+        expected_file="type_alias_recursive_py312.py",
+        extra_args=[
+            "--use-type-alias",
+            "--target-python-version",
+            "3.12",
+            "--use-standard-collections",
+            "--use-union-operator",
+            "--output-model-type",
+            "pydantic_v2.BaseModel",
+        ],
+    )
+
+
 def test_main_openapi_byte_format(output_file: Path) -> None:
     """Test OpenAPI generation with byte format."""
     run_main_and_assert(

tests/parser/test_base.py

@@ -9,8 +9,10 @@
 
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model.pydantic import BaseModel, DataModelField
+from datamodel_code_generator.model.type_alias import TypeAlias, TypeAliasBackport, TypeAliasTypeBackport, TypeStatement
 from datamodel_code_generator.parser.base import (
     Parser,
+    add_model_path_to_list,
     escape_characters,
     exact_import,
     relative,
@@ -54,6 +56,45 @@ def test_parser() -> None:
     assert c.base_class == "Base"
 
 
+def test_add_model_path_to_list() -> None:
+    """Test method which adds model paths to "update" list."""
+    reference_1 = Reference(path="Base1", original_name="A", name="A")
+    reference_2 = Reference(path="Alias2", original_name="B", name="B")
+    reference_3 = Reference(path="Alias3", original_name="B", name="B")
+    reference_4 = Reference(path="Alias4", original_name="B", name="B")
+    reference_5 = Reference(path="Alias5", original_name="B", name="B")
+    model1 = BaseModel(fields=[], reference=reference_1)
+    model2 = TypeAlias(fields=[], reference=reference_2)
+    model3 = TypeAliasBackport(fields=[], reference=reference_3)
+    model4 = TypeAliasTypeBackport(fields=[], reference=reference_4)
+    model5 = TypeStatement(fields=[], reference=reference_5)
+
+    paths = add_model_path_to_list(None, model1)
+    assert "Base1" in paths
+    assert len(paths) == 1
+
+    paths = list[str]()
+    add_model_path_to_list(paths, model1)
+    assert "Base1" in paths
+    assert len(paths) == 1
+
+    add_model_path_to_list(paths, model1)
+    assert len(paths) != 2
+    assert len(paths) == 1
+
+    add_model_path_to_list(paths, model2)
+    assert "Alias2" not in paths
+
+    add_model_path_to_list(paths, model3)
+    assert "Alias3" not in paths
+
+    add_model_path_to_list(paths, model4)
+    assert "Alias4" not in paths
+
+    add_model_path_to_list(paths, model5)
+    assert "Alias5" not in paths
+
+
 def test_sort_data_models() -> None:
     """Test sorting data models by dependencies."""
     reference_a = Reference(path="A", original_name="A", name="A")