datamodel-code-generator 0.25.7__py3-none-any.whl → 0.25.8__py3-none-any.whl

datamodel_code_generator/__init__.py

@@ -29,6 +29,7 @@ from urllib.parse import ParseResult
 
 import yaml
 
+import datamodel_code_generator.pydantic_patch  # noqa: F401
 from datamodel_code_generator.format import PythonVersion
 from datamodel_code_generator.parser import DefaultPutDict, LiteralType
 from datamodel_code_generator.parser.base import Parser
@@ -301,6 +302,8 @@ def generate(
     custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
     use_pendulum: bool = False,
     http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
+    treat_dots_as_module: bool = False,
+    use_exact_imports: bool = False,
 ) -> None:
     remote_text_cache: DefaultPutDict[str, str] = DefaultPutDict()
     if isinstance(input_, str):
@@ -461,6 +464,8 @@ def generate(
         custom_formatters_kwargs=custom_formatters_kwargs,
         use_pendulum=use_pendulum,
         http_query_parameters=http_query_parameters,
+        treat_dots_as_module=treat_dots_as_module,
+        use_exact_imports=use_exact_imports,
         **kwargs,
     )
 

datamodel_code_generator/__main__.py

@@ -312,6 +312,8 @@ class Config(BaseModel):
     custom_formatters_kwargs: Optional[TextIOBase] = None
     use_pendulum: bool = False
     http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None
+    treat_dot_as_module: bool = False
+    use_exact_imports: bool = False
 
     def merge_args(self, args: Namespace) -> None:
         set_args = {
@@ -427,7 +429,7 @@ def main(args: Optional[Sequence[str]] = None) -> Exit:
         with config.custom_formatters_kwargs as data:
             try:
                 custom_formatters_kwargs = json.load(data)
-            except json.JSONDecodeError as e:
+            except json.JSONDecodeError as e:  # pragma: no cover
                 print(
                     f'Unable to load custom_formatters_kwargs mapping: {e}',
                     file=sys.stderr,
@@ -436,7 +438,7 @@ def main(args: Optional[Sequence[str]] = None) -> Exit:
         if not isinstance(custom_formatters_kwargs, dict) or not all(
             isinstance(k, str) and isinstance(v, str)
             for k, v in custom_formatters_kwargs.items()
-        ):
+        ):  # pragma: no cover
             print(
                 'Custom formatters kwargs mapping must be a JSON string mapping (e.g. {"from": "to", ...})',
                 file=sys.stderr,
@@ -508,6 +510,8 @@ 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,
+            treat_dots_as_module=config.treat_dot_as_module,
+            use_exact_imports=config.use_exact_imports,
         )
         return Exit.OK
     except InvalidClassNameError as e:

datamodel_code_generator/arguments.py

@@ -160,6 +160,12 @@ model_options.add_argument(
     help='target python version (default: 3.7)',
     choices=[v.value for v in PythonVersion],
 )
+model_options.add_argument(
+    '--treat-dot-as-module',
+    help='treat dotted module names as modules',
+    action='store_true',
+    default=False,
+)
 model_options.add_argument(
     '--use-schema-description',
     help='Use schema description to populate class docstring',
@@ -178,6 +184,13 @@ model_options.add_argument(
     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/model/base.py

@@ -76,7 +76,7 @@ class ConstraintsBase(_BaseModel):
             }
             constraints_class = a.__class__
         else:
-            root_type_field_constraints = {}
+            root_type_field_constraints = {}  # pragma: no cover
 
         if isinstance(b, ConstraintsBase):  # pragma: no cover
             model_field_constraints = {
@@ -86,7 +86,7 @@ class ConstraintsBase(_BaseModel):
         else:
             model_field_constraints = {}
 
-        if not issubclass(constraints_class, ConstraintsBase):
+        if not issubclass(constraints_class, ConstraintsBase):  # pragma: no cover
             return None
 
         return constraints_class.parse_obj(

datamodel_code_generator/model/pydantic_v2/base_model.py

@@ -33,7 +33,7 @@ if TYPE_CHECKING:
 else:
     try:
         from typing import Literal
-    except ImportError:
+    except ImportError:  # pragma: no cover
         from typing_extensions import Literal
 
 
@@ -106,7 +106,7 @@ class DataModelField(DataModelFieldV1):
 
     @field_validator('extras')
     def validate_extras(cls, values: Any) -> Dict[str, Any]:
-        if not isinstance(values, dict):
+        if not isinstance(values, dict):  # pragma: no cover
             return values
         if 'examples' in values:
             return values
@@ -146,7 +146,7 @@ class DataModelField(DataModelFieldV1):
         self, field_arguments: List[str]
     ) -> List[str]:
         if not self.required or self.const:
-            if self.use_default_kwarg:
+            if self.use_default_kwarg:  # pragma: no cover
                 return [
                     f'default={repr(self.default)}',
                     *field_arguments,
@@ -215,7 +215,7 @@ class BaseModel(BaseModelBase):
                     else self.extra_template_data[from_]
                 )
         for data_type in self.all_data_types:
-            if data_type.is_custom_type:
+            if data_type.is_custom_type:  # pragma: no cover
                 config_parameters['arbitrary_types_allowed'] = True
                 break
 

datamodel_code_generator/parser/base.py

@@ -238,6 +238,14 @@ def relative(current_module: str, reference: str) -> Tuple[str, str]:
     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
@@ -295,7 +303,7 @@ def _copy_data_types(data_types: List[DataType]) -> List[DataType]:
             copied_data_types.append(
                 data_type_.__class__(reference=data_type_.reference)
             )
-        elif data_type_.data_types:
+        elif data_type_.data_types:  # pragma: no cover
             copied_data_type = data_type_.copy()
             copied_data_type.data_types = _copy_data_types(data_type_.data_types)
             copied_data_types.append(copied_data_type)
@@ -392,6 +400,8 @@ class Parser(ABC):
         custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
         use_pendulum: bool = False,
         http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
+        treat_dots_as_module: bool = False,
+        use_exact_imports: bool = False,
     ) -> None:
         self.data_type_manager: DataTypeManager = data_type_manager_type(
             python_version=target_python_version,
@@ -405,7 +415,8 @@ class Parser(ABC):
         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
@@ -514,6 +525,7 @@ class Parser(ABC):
         self.known_third_party = known_third_party
         self.custom_formatter = custom_formatters
         self.custom_formatters_kwargs = custom_formatters_kwargs
+        self.treat_dots_as_module = treat_dots_as_module
 
     @property
     def iter_source(self) -> Iterator[Source]:
@@ -666,9 +678,8 @@ class Parser(ABC):
                 model.class_name = duplicate_name
                 model_names[duplicate_name] = model
 
-    @classmethod
     def __change_from_import(
-        cls,
+        self,
         models: List[DataModel],
         imports: Imports,
         scoped_model_resolver: ModelResolver,
@@ -700,7 +711,18 @@ class Parser(ABC):
                     from_, import_ = full_path = relative(
                         model.module_name, data_type.full_name
                     )
+                    if imports.use_exact:  # pragma: no cover
+                        from_, import_ = exact_import(
+                            from_, import_, data_type.reference.short_name
+                        )
                     import_ = import_.replace('-', '_')
+                    if (
+                        len(model.module_path) > 1
+                        and model.module_path[-1].count('.') > 0
+                        and not self.treat_dots_as_module
+                    ):
+                        rel_path_depth = model.module_path[-1].count('.')
+                        from_ = from_[rel_path_depth:]
 
                 alias = scoped_model_resolver.add(full_path, import_).name
 
@@ -833,11 +855,16 @@ class Parser(ABC):
                                 required=True,
                             )
                         )
-                    imports.append(
+                    literal = (
                         IMPORT_LITERAL
                         if self.target_python_version.has_literal_type
                         else IMPORT_LITERAL_BACKPORT
                     )
+                    has_imported_literal = any(
+                        literal == import_ for import_ in imports
+                    )
+                    if has_imported_literal:  # pragma: no cover
+                        imports.append(literal)
 
     @classmethod
     def _create_set_from_list(cls, data_type: DataType) -> Optional[DataType]:
@@ -959,7 +986,7 @@ class Parser(ABC):
                             if d.is_dict or d.is_union
                         )
                     ):
-                        continue
+                        continue  # pragma: no cover
 
                     # set copied data_type
                     copied_data_type = root_type_field.data_type.copy()
@@ -985,12 +1012,15 @@ class Parser(ABC):
                                 root_type_field.constraints, model_field.constraints
                             )
                         if isinstance(
-                            root_type_field, pydantic_model.DataModelField
-                        ) and not model_field.extras.get('discriminator'):  # no: pragma
+                            root_type_field,
+                            pydantic_model.DataModelField,
+                        ) and not model_field.extras.get('discriminator'):
                             discriminator = root_type_field.extras.get('discriminator')
-                            if discriminator:  # no: pragma
+                            if discriminator:
                                 model_field.extras['discriminator'] = discriminator
-                        data_type.parent.data_types.remove(data_type)
+                        data_type.parent.data_types.remove(
+                            data_type
+                        )  # pragma: no cover
                         data_type.parent.data_types.append(copied_data_type)
 
                     elif isinstance(data_type.parent, DataType):
@@ -1147,6 +1177,32 @@ class Parser(ABC):
                 if model_field.nullable is not True:  # pragma: no cover
                     model_field.nullable = False
 
+    @classmethod
+    def __postprocess_result_modules(cls, results):
+        def process(input_tuple) -> Tuple[str, ...]:
+            r = []
+            for item in input_tuple:
+                p = item.split('.')
+                if len(p) > 1:
+                    r.extend(p[:-1])
+                    r.append(p[-1])
+                else:
+                    r.append(item)
+
+            r = r[:-2] + [f'{r[-2]}.{r[-1]}']
+            return tuple(r)
+
+        results = {process(k): v for k, v in results.items()}
+
+        init_result = [v for k, v in results.items() if k[-1] == '__init__.py'][0]
+        folders = {t[:-1] if t[-1].endswith('.py') else t for t in results.keys()}
+        for folder in folders:
+            for i in range(len(folder)):
+                subfolder = folder[: i + 1]
+                init_file = subfolder + ('__init__.py',)
+                results.update({init_file: init_result})
+        return results
+
     def __change_imported_model_name(
         self,
         models: List[DataModel],
@@ -1250,7 +1306,7 @@ class Parser(ABC):
         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')
@@ -1283,6 +1339,10 @@ class Parser(ABC):
                 Processed(module, models, init, imports, scoped_model_resolver)
             )
 
+        for processed_model in processed_models:
+            for model in processed_model.models:
+                processed_model.imports.append(model.imports)
+
         for unused_model in unused_models:
             module, models = model_to_module_models[unused_model]
             if unused_model in models:  # pragma: no cover
@@ -1290,6 +1350,18 @@ class Parser(ABC):
                 imports.remove(unused_model.imports)
                 models.remove(unused_model)
 
+        for processed_model in processed_models:
+            # postprocess imports to remove unused imports.
+            model_code = str('\n'.join([str(m) for m in processed_model.models]))
+            unused_imports = [
+                (from_, import_)
+                for from_, imports_ in processed_model.imports.items()
+                for import_ in imports_
+                if import_ not in model_code
+            ]
+            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:
             # process after removing unused models
             self.__change_imported_model_name(models, imports, scoped_model_resolver)
@@ -1324,4 +1396,20 @@ class Parser(ABC):
         if [*results] == [('__init__.py',)]:
             return results[('__init__.py',)].body
 
+        results = {tuple(i.replace('-', '_') for i in k): v for k, v in results.items()}
+        results = (
+            self.__postprocess_result_modules(results)
+            if self.treat_dots_as_module
+            else {
+                tuple(
+                    (
+                        part[: part.rfind('.')].replace('.', '_')
+                        + part[part.rfind('.') :]
+                    )
+                    for part in k
+                ): v
+                for k, v in results.items()
+            }
+        )
+
         return results

datamodel_code_generator/parser/graphql.py

@@ -37,11 +37,7 @@ from datamodel_code_generator.parser.base import (
     escape_characters,
 )
 from datamodel_code_generator.reference import ModelType, Reference
-from datamodel_code_generator.types import (
-    DataTypeManager,
-    StrictTypes,
-    Types,
-)
+from datamodel_code_generator.types import DataTypeManager, StrictTypes, Types
 
 try:
     import graphql
@@ -158,6 +154,8 @@ class GraphQLParser(Parser):
         custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
         use_pendulum: bool = False,
         http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
+        treat_dots_as_module: bool = False,
+        use_exact_imports: bool = False,
     ) -> None:
         super().__init__(
             source=source,
@@ -225,18 +223,22 @@ class GraphQLParser(Parser):
             custom_formatters_kwargs=custom_formatters_kwargs,
             use_pendulum=use_pendulum,
             http_query_parameters=http_query_parameters,
+            treat_dots_as_module=treat_dots_as_module,
+            use_exact_imports=use_exact_imports,
         )
 
         self.data_model_scalar_type = data_model_scalar_type
         self.data_model_union_type = data_model_union_type
+        self.use_standard_collections = use_standard_collections
+        self.use_union_operator = use_union_operator
 
     def _get_context_source_path_parts(self) -> Iterator[Tuple[Source, List[str]]]:
         # TODO (denisart): Temporarily this method duplicates
         # the method `datamodel_code_generator.parser.jsonschema.JsonSchemaParser._get_context_source_path_parts`.
 
-        if isinstance(self.source, list) or (
+        if isinstance(self.source, list) or (  # pragma: no cover
             isinstance(self.source, Path) and self.source.is_dir()
-        ):
+        ):  # pragma: no cover
             self.current_source_path = Path()
             self.model_resolver.after_load_files = {
                 self.base_path.joinpath(s.path).resolve().as_posix()
@@ -244,11 +246,11 @@ class GraphQLParser(Parser):
             }
 
         for source in self.iter_source:
-            if isinstance(self.source, ParseResult):
+            if isinstance(self.source, ParseResult):  # pragma: no cover
                 path_parts = self.get_url_path_parts(self.source)
             else:
                 path_parts = list(source.path.parts)
-            if self.current_source_path is not None:
+            if self.current_source_path is not None:  # pragma: no cover
                 self.current_source_path = source.path
             with self.model_resolver.current_base_path_context(
                 source.path.parent
@@ -265,7 +267,7 @@ class GraphQLParser(Parser):
 
             resolved_type = graphql_resolver.kind(type_, None)
 
-            if resolved_type in self.support_graphql_types:
+            if resolved_type in self.support_graphql_types:  # pragma: no cover
                 self.all_graphql_objects[type_.name] = type_
                 # TODO: need a special method for each graph type
                 self.references[type_.name] = Reference(
@@ -279,8 +281,13 @@ class GraphQLParser(Parser):
     def _typename_field(self, name: str) -> DataModelFieldBase:
         return self.data_model_field_type(
             name='typename__',
-            data_type=DataType(literals=[name]),
+            data_type=DataType(
+                literals=[name],
+                use_union_operator=self.use_union_operator,
+                use_standard_collections=self.use_standard_collections,
+            ),
             default=name,
+            use_annotated=self.use_annotated,
             required=False,
             alias='__typename',
             use_one_literal_as_default=True,
@@ -344,7 +351,11 @@ class GraphQLParser(Parser):
         alias: str,
         field: Union[graphql.GraphQLField, graphql.GraphQLInputField],
     ) -> DataModelFieldBase:
-        final_data_type = DataType(is_optional=True)
+        final_data_type = DataType(
+            is_optional=True,
+            use_union_operator=self.use_union_operator,
+            use_standard_collections=self.use_standard_collections,
+        )
         data_type = final_data_type
         obj = field.type
 
@@ -352,11 +363,15 @@ class GraphQLParser(Parser):
             if graphql.is_list_type(obj):
                 data_type.is_list = True
 
-                new_data_type = DataType(is_optional=True)
+                new_data_type = DataType(
+                    is_optional=True,
+                    use_union_operator=self.use_union_operator,
+                    use_standard_collections=self.use_standard_collections,
+                )
                 data_type.data_types = [new_data_type]
 
                 data_type = new_data_type
-            elif graphql.is_non_null_type(obj):
+            elif graphql.is_non_null_type(obj):  # pragma: no cover
                 data_type.is_optional = False
 
             obj = obj.of_type
@@ -368,10 +383,10 @@ class GraphQLParser(Parser):
         )
         extras = {}
 
-        if hasattr(field, 'default_value'):
-            if field.default_value == graphql.pyutils.Undefined:
+        if hasattr(field, 'default_value'):  # pragma: no cover
+            if field.default_value == graphql.pyutils.Undefined:  # pragma: no cover
                 default = None
-            else:
+            else:  # pragma: no cover
                 default = field.default_value
         else:
             if required is False:
@@ -421,7 +436,7 @@ class GraphQLParser(Parser):
         fields.append(self._typename_field(obj.name))
 
         base_classes = []
-        if hasattr(obj, 'interfaces'):
+        if hasattr(obj, 'interfaces'):  # pragma: no cover
             base_classes = [self.references[i.name] for i in obj.interfaces]
 
         data_model_type = self.data_model_type(
@@ -447,7 +462,7 @@ class GraphQLParser(Parser):
     def parse_input_object(
         self, input_graphql_object: graphql.GraphQLInputObjectType
     ) -> None:
-        self.parse_object_like(input_graphql_object)
+        self.parse_object_like(input_graphql_object)  # pragma: no cover
 
     def parse_union(self, union_object: graphql.GraphQLUnionType) -> None:
         fields = []

datamodel_code_generator/parser/jsonschema.py

@@ -440,6 +440,8 @@ class JsonSchemaParser(Parser):
         custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
         use_pendulum: bool = False,
         http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
+        treat_dots_as_module: bool = False,
+        use_exact_imports: bool = False,
     ) -> None:
         super().__init__(
             source=source,
@@ -507,6 +509,8 @@ class JsonSchemaParser(Parser):
             custom_formatters_kwargs=custom_formatters_kwargs,
             use_pendulum=use_pendulum,
             http_query_parameters=http_query_parameters,
+            treat_dots_as_module=treat_dots_as_module,
+            use_exact_imports=use_exact_imports,
         )
 
         self.remote_object_cache: DefaultPutDict[str, Dict[str, Any]] = DefaultPutDict()
@@ -758,10 +762,10 @@ class JsonSchemaParser(Parser):
                 return self.data_type(reference=base_classes[0])
         if required:
             for field in fields:
-                if self.force_optional_for_required_fields or (
+                if self.force_optional_for_required_fields or (  # pragma: no cover
                     self.apply_default_values_for_required_fields and field.has_default
                 ):
-                    continue
+                    continue  # pragma: no cover
                 if (field.original_name or field.name) in required:
                     field.required = True
         if obj.required:
@@ -1310,11 +1314,11 @@ class JsonSchemaParser(Parser):
         elif obj.custom_type_path:
             data_type = self.data_type_manager.get_data_type_from_full_path(
                 obj.custom_type_path, is_custom_type=True
-            )
+            )  # pragma: no cover
         elif obj.is_array:
             data_type = self.parse_array_fields(
                 name, obj, get_special_path('array', path)
-            ).data_type
+            ).data_type  # pragma: no cover
         elif obj.anyOf or obj.oneOf:
             reference = self.model_resolver.add(
                 path, name, loaded=True, class_name=True
@@ -1328,9 +1332,9 @@ class JsonSchemaParser(Parser):
                     name, obj, get_special_path('oneOf', path)
                 )
 
-            if len(data_types) > 1:
+            if len(data_types) > 1:  # pragma: no cover
                 data_type = self.data_type(data_types=data_types)
-            elif not data_types:
+            elif not data_types:  # pragma: no cover
                 return EmptyDataType()
             else:  # pragma: no cover
                 data_type = data_types[0]
@@ -1659,7 +1663,7 @@ class JsonSchemaParser(Parser):
         elif obj.oneOf or obj.anyOf:
             data_type = self.parse_root_type(name, obj, path)
             if isinstance(data_type, EmptyDataType) and obj.properties:
-                self.parse_object(name, obj, path)
+                self.parse_object(name, obj, path)  # pragma: no cover
         elif obj.properties:
             self.parse_object(name, obj, path)
         elif obj.patternProperties:

datamodel_code_generator/parser/openapi.py

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

datamodel_code_generator/pydantic_patch.py

@@ -0,0 +1,21 @@
+import sys
+
+import pydantic.typing
+
+
+def patched_evaluate_forwardref(
+    forward_ref, globalns, localns=None
+):  # pragma: no cover
+    try:
+        return forward_ref._evaluate(
+            globalns, localns or None, set()
+        )  # pragma: no cover
+    except TypeError:
+        # Fallback for Python 3.12 compatibility
+        return forward_ref._evaluate(
+            globalns, localns or None, set(), recursive_guard=set()
+        )
+
+
+if '3.12' in sys.version:  # pragma: no cover
+    pydantic.typing.evaluate_forwardref = patched_evaluate_forwardref

datamodel_code_generator/types.py

@@ -25,12 +25,7 @@ from typing import (
 
 import pydantic
 from packaging import version
-from pydantic import (
-    StrictBool,
-    StrictInt,
-    StrictStr,
-    create_model,
-)
+from pydantic import StrictBool, StrictInt, StrictStr, create_model
 
 from datamodel_code_generator.format import PythonVersion
 from datamodel_code_generator.imports import (

datamodel_code_generator/version.py

@@ -1 +1 @@
-version: str = '0.25.7'
+version: str = '0.25.8'

{datamodel_code_generator-0.25.7.dist-info → datamodel_code_generator-0.25.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datamodel-code-generator
-Version: 0.25.7
+Version: 0.25.8
 Summary: Datamodel Code Generator
 Home-page: https://github.com/koxudaxi/datamodel-code-generator
 License: MIT
@@ -61,9 +61,6 @@ and [msgspec.Struct](https://github.com/jcrist/msgspec) from an openapi file and
 ## Help
 See [documentation](https://koxudaxi.github.io/datamodel-code-generator) for more details.
 
-## Sponsors
-[![JetBrains](https://avatars.githubusercontent.com/u/60931315?s=200&v=4)](https://github.com/JetBrainsOfficial)
-
 ## Quick Installation
 
 To install `datamodel-code-generator`:
@@ -281,13 +278,52 @@ class Apis(BaseModel):
 ```
 </details>
 
+## Supported input types
+-  OpenAPI 3 (YAML/JSON, [OpenAPI Data Type](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.2.md#data-types));
+-  JSON Schema ([JSON Schema Core](http://json-schema.org/draft/2019-09/json-schema-validation.html)/[JSON Schema Validation](http://json-schema.org/draft/2019-09/json-schema-validation.html));
+-  JSON/YAML/CSV Data (it will be converted to JSON Schema);
+-  Python dictionary (it will be converted to JSON Schema);
+-  GraphQL schema ([GraphQL Schemas and Types](https://graphql.org/learn/schema/));
+
+## Supported output types
+- [pydantic](https://docs.pydantic.dev/1.10/).BaseModel;
+- [pydantic_v2](https://docs.pydantic.dev/2.0/).BaseModel;
+- [dataclasses.dataclass](https://docs.python.org/3/library/dataclasses.html);
+- [typing.TypedDict](https://docs.python.org/3/library/typing.html#typing.TypedDict);
+- [msgspec.Struct](https://github.com/jcrist/msgspec);
+- Custom type from your [jinja2](https://jinja.palletsprojects.com/en/3.1.x/) template;
+
+## Sponsors
+<table>
+  <tr>
+    <td valign="top" align="center">
+    <a href="https://github.com/JetBrainsOfficial">
+      <img src="https://avatars.githubusercontent.com/u/60931315?s=100&v=4" alt="JetBrains Logo" style="width: 100px;">
+      <p>JetBrains</p>
+    </a>
+    </td>
+  <td valign="top" align="center">
+    <a href="https://github.com/astral-sh">
+      <img src="https://avatars.githubusercontent.com/u/115962839?s=200&v=4" alt="Astral Logo" style="width: 100px;">
+      <p>Astral</p>
+    </a>
+  </td>
+  <td valign="top" align="center">
+    <a href="https://github.com/DataDog">
+      <img src="https://avatars.githubusercontent.com/u/365230?s=200&v=4" alt="Datadog, Inc. Logo" style="width: 100px;">
+      <p>Datadog, Inc.</p>
+    </a>
+  </td>
+  </tr>
+</table>
+
 ## Projects that use datamodel-code-generator
  
 These OSS projects use datamodel-code-generator to generate many models. 
 See the following linked projects for real world examples and inspiration.
 
 - [airbytehq/airbyte](https://github.com/airbytehq/airbyte)
-  - *[code-generator/Dockerfile](https://github.com/airbytehq/airbyte/blob/master/tools/code-generator/Dockerfile)*
+  - *[Generate Python, Java/Kotlin, and Typescript protocol models](https://github.com/airbytehq/airbyte-protocol/tree/main/protocol-models/bin)*
 - [apache/iceberg](https://github.com/apache/iceberg)
   - *[Generate Python code](https://github.com/apache/iceberg/blob/d2e1094ee0cc6239d43f63ba5114272f59d605d2/open-api/README.md?plain=1#L39)* 
     *[`make generate`](https://github.com/apache/iceberg/blob/d2e1094ee0cc6239d43f63ba5114272f59d605d2/open-api/Makefile#L24-L34)*
@@ -312,21 +348,6 @@ See the following linked projects for real world examples and inspiration.
 - [SeldonIO/MLServer](https://github.com/SeldonIO/MLServer)
   - *[generate-types.sh](https://github.com/SeldonIO/MLServer/blob/master/hack/generate-types.sh)*
 
-## Supported input types
--  OpenAPI 3 (YAML/JSON, [OpenAPI Data Type](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.2.md#data-types));
--  JSON Schema ([JSON Schema Core](http://json-schema.org/draft/2019-09/json-schema-validation.html)/[JSON Schema Validation](http://json-schema.org/draft/2019-09/json-schema-validation.html));
--  JSON/YAML/CSV Data (it will be converted to JSON Schema);
--  Python dictionary (it will be converted to JSON Schema);
--  GraphQL schema ([GraphQL Schemas and Types](https://graphql.org/learn/schema/));
-
-## Supported output types
-- [pydantic](https://docs.pydantic.dev/1.10/).BaseModel;
-- [pydantic_v2](https://docs.pydantic.dev/2.0/).BaseModel;
-- [dataclasses.dataclass](https://docs.python.org/3/library/dataclasses.html);
-- [typing.TypedDict](https://docs.python.org/3/library/typing.html#typing.TypedDict);
-- [msgspec.Struct](https://github.com/jcrist/msgspec);
-- Custom type from your [jinja2](https://jinja.palletsprojects.com/en/3.1.x/) template;
-
 ## Installation
 
 To install `datamodel-code-generator`:
@@ -364,6 +385,7 @@ This method needs the [http extra option](#http-extra-option)
 ## All Command Options
 
 The `datamodel-codegen` command:
+
 ```bash
 usage:
   datamodel-codegen [options]
@@ -480,6 +502,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-0.25.7.dist-info → datamodel_code_generator-0.25.8.dist-info}/RECORD

@@ -1,11 +1,11 @@
-datamodel_code_generator/__init__.py,sha256=zqe2mCNMAgFm9BGJHz8yTAVYVdK30Gt_pOnN7CjKvx4,17951
-datamodel_code_generator/__main__.py,sha256=klyeTja8UY57kcMvWXSp6aEOtNAOCX_biB0sqsCLFfE,19483
-datamodel_code_generator/arguments.py,sha256=kjTIK3mqF7fU5hJ0ZA-3axudgKjpkypLGsc4HikHqFQ,14941
+datamodel_code_generator/__init__.py,sha256=nCulaRL1TE7CM_1ugD6QoijWwRStbYDp5_ncwv0UYEQ,18185
+datamodel_code_generator/__main__.py,sha256=xjg2pGhoHi7XxQNnbk4KG9OWT4ePrLlNRsYXfV12qC0,19714
+datamodel_code_generator/arguments.py,sha256=Tf3U00-b-ZVxd0IrUJr9QHY8kAImX5ymlJbdQSZQDK8,15334
 datamodel_code_generator/format.py,sha256=yTSOf3-jUO4X5NOljAjm-4xYC_uBJV3-RLXUYIvw-yw,8595
 datamodel_code_generator/http.py,sha256=CwLVnXO4_W_fWKJsHnJp6Q_3GuF3qjCjeAe48Ihawrs,714
-datamodel_code_generator/imports.py,sha256=zswV5jMxWwr1-UO0beiyHT9ykhTYGnMTLtTQ6YVougQ,5529
+datamodel_code_generator/imports.py,sha256=EUUgdLMD_724Jhp50-hQy2C6uMSQISGbJKhUfH3iIbo,5595
 datamodel_code_generator/model/__init__.py,sha256=A0CqnL87-lY_Te-n-99ya5v7h6l4jE6hOPP_itvcWOc,3091
-datamodel_code_generator/model/base.py,sha256=M1T8L7how4nW0aqGuunzc1LyWVSJ3OuFvRnx1Ig13hA,14019
+datamodel_code_generator/model/base.py,sha256=3a7gTAI3e_2WMdgHyhKTWqs1qELqVb18HuwcBof-2C4,14059
 datamodel_code_generator/model/dataclass.py,sha256=9meJNWb-XPYYO8kDMSLhSfO6fulGWV7r3_XIM5kA71M,3965
 datamodel_code_generator/model/enum.py,sha256=Giehhtij2DZs2LssSJnG_CIIHsSA7Mkz471GU-Cb5kI,3338
 datamodel_code_generator/model/imports.py,sha256=9-0bd-DvZRjZkWMsmw-gykL8fzTd6M-vQEqS7Rm_ty4,725
@@ -17,7 +17,7 @@ datamodel_code_generator/model/pydantic/dataclass.py,sha256=sbqTmutl8Fjf1pYngfdv
 datamodel_code_generator/model/pydantic/imports.py,sha256=2nSLYwphBUMQEa0PTSNwoLjEBslu02EQb6BdZ-S51yk,2189
 datamodel_code_generator/model/pydantic/types.py,sha256=GDh1KRforpUIj58TSLSqrbKRnXi8O1qfHT8NaoUYvME,13034
 datamodel_code_generator/model/pydantic_v2/__init__.py,sha256=6IcvuP18MzTf3b6edPz6q1sIxzjuvmXbceQfPgkz25Q,947
-datamodel_code_generator/model/pydantic_v2/base_model.py,sha256=SURD7qLZkQaJOcFqmhcuNOCTb49WWcHPpo0RsjjD0SQ,8129
+datamodel_code_generator/model/pydantic_v2/base_model.py,sha256=jaRPrnrc0UpcWeI7GjPjJomkh9Q9Ej6J9iEOyVq0IGM,8209
 datamodel_code_generator/model/pydantic_v2/imports.py,sha256=Q6XC6iE5v4LJvQ2DOXDGFtR-FnGPsaZ56KiiTiF2bIE,191
 datamodel_code_generator/model/pydantic_v2/root_model.py,sha256=ZlaNHfC8PuLJ1--OYm9AXbL1A95z1F421VoraP3mo70,951
 datamodel_code_generator/model/pydantic_v2/types.py,sha256=6KAJXO_SGs5bc8GQScCpowgqjaSmrn9W9iewpWIHack,1440
@@ -43,17 +43,18 @@ datamodel_code_generator/model/typed_dict.py,sha256=pzUaKLaVDF5rfxAaR1m4FqnhR00e
 datamodel_code_generator/model/types.py,sha256=Ti3cEtRQpBYgC4Y5ocAn6Ol-ZbnKG_P7C0nHBX9KtV8,2953
 datamodel_code_generator/model/union.py,sha256=loaVWQi-UHkV4gLfF2JhxLcgZRMsejaoJzGvjTlp_bo,1716
 datamodel_code_generator/parser/__init__.py,sha256=zHbw6RPlJC0SAQjb-XyVlyZhcOu5PfYgPidy6jlUM8M,793
-datamodel_code_generator/parser/base.py,sha256=y9lNLVYWu9SdBrLYgl2wGA-X9-0axtEp6E-1H-gUemQ,54375
-datamodel_code_generator/parser/graphql.py,sha256=n1AEOoJRbmK4Oq3_4M3VgvMaC12e3zBXFMXVrO-d2kI,20594
-datamodel_code_generator/parser/jsonschema.py,sha256=8bEBPFPwqQ4Qbxzjtfzh6E_KYBzH9zCHisg0IJOo2Bk,69658
-datamodel_code_generator/parser/openapi.py,sha256=bGLWGbFysBq4CtM-piuHero_EKW_T0-CS8miEj3Trqw,25623
+datamodel_code_generator/parser/base.py,sha256=_qrA_CpN_Wi8IhSRI08fNoJBfy1oqgyYwpNX8-iVl9M,58028
+datamodel_code_generator/parser/graphql.py,sha256=0LF2wOqVMCKQlNKih8px3SN1iMzGgIf4d9TT58xOuAQ,21639
+datamodel_code_generator/parser/jsonschema.py,sha256=RrPrZvegLvh2jFlXwT9zXA1MdUyWCsMMO8az5STB4UA,69987
+datamodel_code_generator/parser/openapi.py,sha256=zCQr12pRE78PSRWhwE7a-2_IaqtC8y0ukMkipJAJYi8,25812
 datamodel_code_generator/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamodel_code_generator/pydantic_patch.py,sha256=XDVGIvMFrJKZmp5Zk74Id2YQeizIZ8B2WqCdUR_CB6U,560
 datamodel_code_generator/reference.py,sha256=EoalUNUP5us31bfMrHDa1iiKqxL8gHrpZKY_IxgZrOg,26347
-datamodel_code_generator/types.py,sha256=xPFX0NkgPz5CEz_yqKkZa7wPFr08P0e7X4Ooheoo2Uo,19652
+datamodel_code_generator/types.py,sha256=Dadq241BMGcG3U23ZEsDTf3eUbuEr2K_8jxovKpWcGw,19631
 datamodel_code_generator/util.py,sha256=Lrjj20mmma4Glpfs42sCoGpt1cncalgUGyNZZviqWdU,3692
-datamodel_code_generator/version.py,sha256=ELV7HbvS0xRPP1KDziJGhzraG0NcEhduFjGDK9G43kM,24
-datamodel_code_generator-0.25.7.dist-info/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
-datamodel_code_generator-0.25.7.dist-info/METADATA,sha256=uR6VdHb6Kr1oLn7xxwZPzX6lk_kDEI3Zwo6xT2E4Puw,23339
-datamodel_code_generator-0.25.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-datamodel_code_generator-0.25.7.dist-info/entry_points.txt,sha256=bykbUWqOCiKfxJPGe8jpNqTqD1NG7uyRmozdnwzu7rk,76
-datamodel_code_generator-0.25.7.dist-info/RECORD,,
+datamodel_code_generator/version.py,sha256=iOqXW_23tdW5haMr--6-YJWG9wQ4ZHb8qhqin3FGLTw,24
+datamodel_code_generator-0.25.8.dist-info/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
+datamodel_code_generator-0.25.8.dist-info/METADATA,sha256=4tcSrbkNabwFUJgZxHtAjfL9AgIOZBRQxi81t4hjBGM,24212
+datamodel_code_generator-0.25.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+datamodel_code_generator-0.25.8.dist-info/entry_points.txt,sha256=bykbUWqOCiKfxJPGe8jpNqTqD1NG7uyRmozdnwzu7rk,76
+datamodel_code_generator-0.25.8.dist-info/RECORD,,