feat: new cli option --use-exact-imports

README.md

@@ -457,6 +457,9 @@ Model customization:
   --use-schema-description
                         Use schema description to populate class docstring
   --use-title-as-name   use titles as class names of models
+  --use-exact-imports   Import exact types instead of modules, for example: 
+                        `from .foo import Bar` instead of 
+                        `from . import foo` with `foo.Bar`
 
 Template customization:
   --aliases ALIASES     Alias mapping file

datamodel_code_generator/__init__.py

@@ -301,6 +301,7 @@ def generate(
     custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
     use_pendulum: bool = False,
     http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
+    use_exact_imports: bool = False,
 ) -> None:
     remote_text_cache: DefaultPutDict[str, str] = DefaultPutDict()
     if isinstance(input_, str):
@@ -461,6 +462,7 @@ def get_header_and_first_line(csv_file: IO[str]) -> Dict[str, Any]:
         custom_formatters_kwargs=custom_formatters_kwargs,
         use_pendulum=use_pendulum,
         http_query_parameters=http_query_parameters,
+        use_exact_imports=use_exact_imports,
         **kwargs,
     )
 

datamodel_code_generator/__main__.py

@@ -312,6 +312,7 @@ def validate_root(cls, values: Any) -> Any:
     custom_formatters_kwargs: Optional[TextIOBase] = None
     use_pendulum: bool = False
     http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None
+    use_exact_imports: bool = False
 
     def merge_args(self, args: Namespace) -> None:
         set_args = {
@@ -508,6 +509,7 @@ def main(args: Optional[Sequence[str]] = None) -> Exit:
             custom_formatters_kwargs=custom_formatters_kwargs,
             use_pendulum=config.use_pendulum,
             http_query_parameters=config.http_query_parameters,
+            use_exact_imports=config.use_exact_imports,
         )
         return Exit.OK
     except InvalidClassNameError as e:

datamodel_code_generator/arguments.py

@@ -178,6 +178,13 @@ def start_section(self, heading: Optional[str]) -> None:
     action='store_true',
     default=False,
 )
+model_options.add_argument(
+    '--use-exact-imports',
+    help='import exact types instead of modules, for example: "from .foo import Bar" instead of '
+    '"from . import foo" with "foo.Bar"',
+    action='store_true',
+    default=False,
+)
 
 # ======================================================================================
 # Typing options for generated models

datamodel_code_generator/imports.py

@@ -26,11 +26,12 @@ class Imports(DefaultDict[Optional[str], Set[str]]):
     def __str__(self) -> str:
         return self.dump()
 
-    def __init__(self) -> None:
+    def __init__(self, use_exact: bool = False) -> None:
         super().__init__(set)
         self.alias: DefaultDict[Optional[str], Dict[str, str]] = defaultdict(dict)
         self.counter: Dict[Tuple[Optional[str], str], int] = defaultdict(int)
         self.reference_paths: Dict[str, Import] = {}
+        self.use_exact: bool = use_exact
 
     def _set_alias(self, from_: Optional[str], imports: Set[str]) -> List[str]:
         return [

datamodel_code_generator/parser/base.py

@@ -238,6 +238,14 @@
     return left, right
 
 
+def exact_import(from_: str, import_: str, short_name: str) -> Tuple[str, str]:
+    if from_ == '.':
+        # Prevents "from . import foo" becoming "from ..foo import Foo"
+        # when our imported module has the same parent
+        return f'.{import_}', short_name
+    return f'{from_}.{import_}', short_name
+
+
 @runtime_checkable
 class Child(Protocol):
     @property
@@ -392,6 +400,7 @@
         custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
         use_pendulum: bool = False,
         http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
+        use_exact_imports: bool = False,
     ) -> None:
         self.data_type_manager: DataTypeManager = data_type_manager_type(
             python_version=target_python_version,
@@ -405,7 +414,8 @@
         self.data_model_root_type: Type[DataModel] = data_model_root_type
         self.data_model_field_type: Type[DataModelFieldBase] = data_model_field_type
 
-        self.imports: Imports = Imports()
+        self.imports: Imports = Imports(use_exact_imports)
+        self.use_exact_imports: bool = use_exact_imports
         self._append_additional_imports(additional_imports=additional_imports)
 
         self.base_class: Optional[str] = base_class
@@ -700,6 +710,10 @@
                     from_, import_ = full_path = relative(
                         model.module_name, data_type.full_name
                     )
+                    if imports.use_exact:
+                        from_, import_ = exact_import(
+                            from_, import_, data_type.reference.short_name
+                        )
                     import_ = import_.replace('-', '_')
 
                 alias = scoped_model_resolver.add(full_path, import_).name
@@ -1250,7 +1264,7 @@
         processed_models: List[Processed] = []
 
         for module, models in module_models:
-            imports = module_to_import[module] = Imports()
+            imports = module_to_import[module] = Imports(self.use_exact_imports)
             init = False
             if module:
                 parent = (*module[:-1], '__init__.py')

datamodel_code_generator/parser/graphql.py

@@ -158,6 +158,7 @@ def __init__(
         custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
         use_pendulum: bool = False,
         http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
+        use_exact_imports: bool = False,
     ) -> None:
         super().__init__(
             source=source,
@@ -225,6 +226,7 @@ def __init__(
             custom_formatters_kwargs=custom_formatters_kwargs,
             use_pendulum=use_pendulum,
             http_query_parameters=http_query_parameters,
+            use_exact_imports=use_exact_imports,
         )
 
         self.data_model_scalar_type = data_model_scalar_type

datamodel_code_generator/parser/jsonschema.py

@@ -440,6 +440,7 @@ def __init__(
         custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
         use_pendulum: bool = False,
         http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
+        use_exact_imports: bool = False,
     ) -> None:
         super().__init__(
             source=source,
@@ -507,6 +508,7 @@ def __init__(
             custom_formatters_kwargs=custom_formatters_kwargs,
             use_pendulum=use_pendulum,
             http_query_parameters=http_query_parameters,
+            use_exact_imports=use_exact_imports,
         )
 
         self.remote_object_cache: DefaultPutDict[str, Dict[str, Any]] = DefaultPutDict()

datamodel_code_generator/parser/openapi.py

@@ -222,6 +222,7 @@ def __init__(
         custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
         use_pendulum: bool = False,
         http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
+        use_exact_imports: bool = False,
     ):
         super().__init__(
             source=source,
@@ -289,6 +290,7 @@ def __init__(
             custom_formatters_kwargs=custom_formatters_kwargs,
             use_pendulum=use_pendulum,
             http_query_parameters=http_query_parameters,
+            use_exact_imports=use_exact_imports,
         )
         self.open_api_scopes: List[OpenAPIScope] = openapi_scopes or [
             OpenAPIScope.Schemas

tests/parser/test_base.py

@@ -5,7 +5,12 @@
 
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model.pydantic import BaseModel, DataModelField
-from datamodel_code_generator.parser.base import Parser, relative, sort_data_models
+from datamodel_code_generator.parser.base import (
+    Parser,
+    exact_import,
+    relative,
+    sort_data_models,
+)
 from datamodel_code_generator.reference import Reference, snake_to_upper_camel
 from datamodel_code_generator.types import DataType
 
@@ -183,6 +188,19 @@ def test_relative(current_module: str, reference: str, val: Tuple[str, str]):
     assert relative(current_module, reference) == val
 
 
+@pytest.mark.parametrize(
+    'from_,import_,name,val',
+    [
+        ('.', 'mod', 'Foo', ('.mod', 'Foo')),
+        ('.a', 'mod', 'Foo', ('.a.mod', 'Foo')),
+        ('..a', 'mod', 'Foo', ('..a.mod', 'Foo')),
+        ('..a.b', 'mod', 'Foo', ('..a.b.mod', 'Foo')),
+    ],
+)
+def test_exact_import(from_: str, import_: str, name: str, val: Tuple[str, str]):
+    assert exact_import(from_, import_, name) == val
+
+
 @pytest.mark.parametrize(
     'word,expected',
     [