Code formatting

Author: sternakt

fastapi_code_generator/__init__.py

@@ -2,20 +2,25 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 import logging
+from itertools import groupby
 from pathlib import Path
-from typing import Union
+from typing import NamedTuple
 
-logger = logging.getLogger(__name__)
-
-from datamodel_code_generator.parser import base
+from datamodel_code_generator.format import CodeFormatter
+from datamodel_code_generator.imports import IMPORT_ANNOTATIONS, Import, Imports
 from datamodel_code_generator.model.base import DataModel
+from datamodel_code_generator.parser import base
+from datamodel_code_generator.reference import ModelResolver
+
+logger = logging.getLogger(__name__)
 
 # Save the original method before patching
 original_parse = base.Parser.parse
 
+
 def patch_parse() -> None:  # noqa: C901
     def __alias_shadowed_imports(
-        self,
+        self: base.Parser,
         models: list[DataModel],
         all_model_field_names: set[str],
     ) -> None:
@@ -24,21 +29,22 @@ def __alias_shadowed_imports(
                 if model_field.data_type.type in all_model_field_names:
                     alias = model_field.data_type.type + "_aliased"
                     model_field.data_type.type = alias
-                    model_field.data_type.import_.alias = alias
+                    if model_field.data_type.import_:
+                        model_field.data_type.import_.alias = alias
 
     def _parse(  # noqa: PLR0912, PLR0914, PLR0915
-        self,
+        self: base.Parser,
         with_import: bool | None = True,  # noqa: FBT001, FBT002
         format_: bool | None = True,  # noqa: FBT001, FBT002
         settings_path: Path | None = None,
     ) -> str | dict[tuple[str, ...], base.Result]:
         self.parse_raw()
 
         if with_import:
-            self.imports.append(base.IMPORT_ANNOTATIONS)
+            self.imports.append(IMPORT_ANNOTATIONS)
 
         if format_:
-            code_formatter: base.CodeFormatter | None = base.CodeFormatter(
+            code_formatter: CodeFormatter | None = CodeFormatter(
                 self.target_python_version,
                 settings_path,
                 self.wrap_string_literal,
@@ -52,7 +58,9 @@ def _parse(  # noqa: PLR0912, PLR0914, PLR0915
         else:
             code_formatter = None
 
-        _, sorted_data_models, require_update_action_models = base.sort_data_models(self.results)
+        _, sorted_data_models, require_update_action_models = base.sort_data_models(
+            self.results
+        )
 
         results: dict[tuple[str, ...], base.Result] = {}
 
@@ -63,15 +71,17 @@ def sort_key(data_model: DataModel) -> tuple[int, tuple[str, ...]]:
             return (len(data_model.module_path), tuple(data_model.module_path))
 
         # process in reverse order to correctly establish module levels
-        grouped_models = base.groupby(
+        grouped_models = groupby(
             sorted(sorted_data_models.values(), key=sort_key, reverse=True),
             key=module_key,
         )
 
         module_models: list[tuple[tuple[str, ...], list[DataModel]]] = []
         unused_models: list[DataModel] = []
-        model_to_module_models: dict[DataModel, tuple[tuple[str, ...], list[DataModel]]] = {}
-        module_to_import: dict[tuple[str, ...], base.Imports] = {}
+        model_to_module_models: dict[
+            DataModel, tuple[tuple[str, ...], list[DataModel]]
+        ] = {}
+        module_to_import: dict[tuple[str, ...], Imports] = {}
 
         previous_module: tuple[str, ...] = ()
         for module, models in ((k, [*v]) for k, v in grouped_models):
@@ -87,23 +97,25 @@ def sort_key(data_model: DataModel) -> tuple[int, tuple[str, ...]]:
                     )
                     for parts in range(len(previous_module) - 1, len(module), -1)
                 )
-            module_models.append((
-                module,
-                models,
-            ))
+            module_models.append(
+                (
+                    module,
+                    models,
+                )
+            )
             previous_module = module
 
-        class Processed(base.NamedTuple):
+        class Processed(NamedTuple):
             module: tuple[str, ...]
             models: list[DataModel]
             init: bool
-            imports: base.Imports
-            scoped_model_resolver: base.ModelResolver
+            imports: Imports
+            scoped_model_resolver: ModelResolver
 
         processed_models: list[Processed] = []
 
         for module_, models in module_models:
-            imports = module_to_import[module_] = base.Imports(self.use_exact_imports)
+            imports = module_to_import[module_] = Imports(self.use_exact_imports)
             init = False
             if module_:
                 parent = (*module_[:-1], "__init__.py")
@@ -113,28 +125,42 @@ class Processed(base.NamedTuple):
                     module = (*module_, "__init__.py")
                     init = True
                 else:
-                    module = tuple(part.replace("-", "_") for part in (*module_[:-1], f"{module_[-1]}.py"))
+                    module = tuple(
+                        part.replace("-", "_")
+                        for part in (*module_[:-1], f"{module_[-1]}.py")
+                    )
             else:
                 module = ("__init__.py",)
 
-            all_module_fields = {field.name for model in models for field in model.fields if field.name is not None}
-            scoped_model_resolver = base.ModelResolver(exclude_names=all_module_fields)
+            all_module_fields = {
+                field.name
+                for model in models
+                for field in model.fields
+                if field.name is not None
+            }
+            scoped_model_resolver = ModelResolver(exclude_names=all_module_fields)
 
             self.__alias_shadowed_imports(models, all_module_fields)
             self._Parser__override_required_field(models)
             self._Parser__replace_unique_list_to_set(models)
-            self._Parser__change_from_import(models, imports, scoped_model_resolver, init)
+            self._Parser__change_from_import(
+                models, imports, scoped_model_resolver, init
+            )
             self._Parser__extract_inherited_enum(models)
             self._Parser__set_reference_default_value_to_field(models)
             self._Parser__reuse_model(models, require_update_action_models)
-            self._Parser__collapse_root_models(models, unused_models, imports, scoped_model_resolver)
+            self._Parser__collapse_root_models(
+                models, unused_models, imports, scoped_model_resolver
+            )
             self._Parser__set_default_enum_member(models)
             self._Parser__sort_models(models, imports)
             self._Parser__change_field_name(models)
             self._Parser__apply_discriminator_type(models, imports)
             self._Parser__set_one_literal_on_default(models)
 
-            processed_models.append(Processed(module, models, init, imports, scoped_model_resolver))
+            processed_models.append(
+                Processed(module, models, init, imports, scoped_model_resolver)
+            )
 
         for processed_model in processed_models:
             for model in processed_model.models:
@@ -159,11 +185,25 @@ class Processed(base.NamedTuple):
             for from_, import_ in unused_imports:
                 processed_model.imports.remove(Import(from_=from_, import_=import_))
 
-        for module, models, init, imports, scoped_model_resolver in processed_models:  # noqa: B007
+        for (
+            module,
+            models,
+            init,
+            imports,
+            scoped_model_resolver,
+        ) in processed_models:  # noqa: B007
             # process after removing unused models
-            self._Parser__change_imported_model_name(models, imports, scoped_model_resolver)
+            self._Parser__change_imported_model_name(
+                models, imports, scoped_model_resolver
+            )
 
-        for module, models, init, imports, scoped_model_resolver in processed_models:  # noqa: B007
+        for (
+            module,
+            models,
+            init,
+            imports,
+            scoped_model_resolver,
+        ) in processed_models:  # noqa: B007
             result: list[str] = []
             if models:
                 if with_import:
@@ -176,7 +216,9 @@ class Processed(base.NamedTuple):
                     result += [
                         "\n",
                         self.dump_resolve_reference_action(
-                            m.reference.short_name for m in models if m.path in require_update_action_models
+                            m.reference.short_name
+                            for m in models
+                            if m.path in require_update_action_models
                         ),
                     ]
             if not result and not init:
@@ -185,7 +227,9 @@ class Processed(base.NamedTuple):
             if code_formatter:
                 body = code_formatter.format_code(body)
 
-            results[module] = base.Result(body=body, source=models[0].file_path if models else None)
+            results[module] = base.Result(
+                body=body, source=models[0].file_path if models else None
+            )
 
         # retain existing behaviour
         if [*results] == [("__init__.py",)]:
@@ -196,17 +240,20 @@ class Processed(base.NamedTuple):
             self._Parser__postprocess_result_modules(results)
             if self.treat_dot_as_module
             else {
-                tuple((part[: part.rfind(".")].replace(".", "_") + part[part.rfind(".") :]) for part in k): v
+                tuple(
+                    (
+                        part[: part.rfind(".")].replace(".", "_")
+                        + part[part.rfind(".") :]
+                    )
+                    for part in k
+                ): v
                 for k, v in results.items()
             }
         )
 
-
     base.Parser.parse = _parse
     base.Parser.__alias_shadowed_imports = __alias_shadowed_imports
-
     logger.info("Patched Parser.parse method.")
 
-patch_parse()
-
 
+patch_parse()

here/main.py

@@ -0,0 +1,13 @@
+# generated by fastapi-codegen:
+#   filename:  shadowed_imports.yaml
+#   timestamp: 2020-06-19T00:00:00+00:00
+
+from __future__ import annotations
+
+from fastapi import FastAPI
+
+app = FastAPI(
+    title='REST API',
+    version='0.0.1',
+    servers=[{'url': 'https://api.something.com/1'}],
+)

here/models.py

@@ -0,0 +1,15 @@
+# generated by fastapi-codegen:
+#   filename:  shadowed_imports.yaml
+#   timestamp: 2020-06-19T00:00:00+00:00
+
+from __future__ import annotations
+
+from datetime import date as date_aliased
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class MarketingOptIn(BaseModel):
+    optedIn: Optional[bool] = Field(None, example=False)
+    date: Optional[date_aliased] = Field(None, example='2018-04-26T17:03:25.155Z')