datamodel-code-generator 0.26.3__py3-none-any.whl → 0.27.0__py3-none-any.whl

datamodel_code_generator/__init__.py

@@ -81,6 +81,9 @@ def enable_debug_message() -> None:  # pragma: no cover
     pysnooper.tracer.DISABLED = False
 
 
+DEFAULT_MAX_VARIABLE_LENGTH: int = 100
+
+
 def snooper_to_methods(  # type: ignore
     output=None,
     watch=(),
@@ -90,7 +93,7 @@ def snooper_to_methods(  # type: ignore
     overwrite=False,
     thread_info=False,
     custom_repr=(),
-    max_variable_length=100,
+    max_variable_length: Optional[int] = DEFAULT_MAX_VARIABLE_LENGTH,
 ) -> Callable[..., Any]:
     def inner(cls: Type[T]) -> Type[T]:
         if not pysnooper:
@@ -108,7 +111,9 @@ def snooper_to_methods(  # type: ignore
                 overwrite,
                 thread_info,
                 custom_repr,
-                max_variable_length,
+                max_variable_length
+                if max_variable_length is not None
+                else DEFAULT_MAX_VARIABLE_LENGTH,
             )(method)
             setattr(cls, name, snooper_method)
         return cls
@@ -231,7 +236,7 @@ def get_first_file(path: Path) -> Path:  # pragma: no cover
 
 
 def generate(
-    input_: Union[Path, str, ParseResult],
+    input_: Union[Path, str, ParseResult, Mapping[str, Any]],
     *,
     input_filename: Optional[str] = None,
     input_file_type: InputFileType = InputFileType.Auto,
@@ -303,6 +308,7 @@ def generate(
     union_mode: Optional[UnionMode] = None,
     output_datetime_class: Optional[DatetimeClassType] = None,
     keyword_only: bool = False,
+    no_alias: bool = False,
 ) -> None:
     remote_text_cache: DefaultPutDict[str, str] = DefaultPutDict()
     if isinstance(input_, str):
@@ -353,6 +359,8 @@ def generate(
         parser_class = JsonSchemaParser
 
         if input_file_type in RAW_DATA_TYPES:
+            import json
+
             try:
                 if isinstance(input_, Path) and input_.is_dir():  # pragma: no cover
                     raise Error(f'Input must be a file for {input_file_type}')
@@ -371,15 +379,33 @@ def generate(
                         import io
 
                         obj = get_header_and_first_line(io.StringIO(input_text))
-                else:
+                elif input_file_type == InputFileType.Yaml:
                     obj = load_yaml(
                         input_.read_text(encoding=encoding)  # type: ignore
                         if isinstance(input_, Path)
                         else input_text
                     )
+                elif input_file_type == InputFileType.Json:
+                    obj = json.loads(
+                        input_.read_text(encoding=encoding)  # type: ignore
+                        if isinstance(input_, Path)
+                        else input_text
+                    )
+                elif input_file_type == InputFileType.Dict:
+                    import ast
+
+                    # Input can be a dict object stored in a python file
+                    obj = (
+                        ast.literal_eval(
+                            input_.read_text(encoding=encoding)  # type: ignore
+                        )
+                        if isinstance(input_, Path)
+                        else input_
+                    )
+                else:  # pragma: no cover
+                    raise Error(f'Unsupported input file type: {input_file_type}')
             except:  # noqa
                 raise Error('Invalid file format')
-            import json
 
             from genson import SchemaBuilder
 
@@ -403,8 +429,10 @@ def generate(
     data_model_types = get_data_model_types(
         output_model_type, target_python_version, output_datetime_class
     )
+    source = input_text or input_
+    assert not isinstance(source, Mapping)
     parser = parser_class(
-        source=input_text or input_,
+        source=source,
         data_model_type=data_model_types.data_model,
         data_model_root_type=data_model_types.root_model,
         data_model_field_type=data_model_types.field_model,
@@ -478,6 +506,7 @@ def generate(
         default_field_extras=default_field_extras,
         target_datetime_class=output_datetime_class,
         keyword_only=keyword_only,
+        no_alias=no_alias,
         **kwargs,
     )
 
@@ -488,7 +517,11 @@ def generate(
             input_filename = '<stdin>'
         elif isinstance(input_, ParseResult):
             input_filename = input_.geturl()
+        elif input_file_type == InputFileType.Dict:
+            # input_ might be a dict object provided directly, and missing a name field
+            input_filename = getattr(input_, 'name', '<dict>')
         else:
+            assert isinstance(input_, Path)
             input_filename = input_.name
     if not results:
         raise Error('Models not found in the input data')

datamodel_code_generator/__main__.py

@@ -53,7 +53,6 @@ from datamodel_code_generator.arguments import DEFAULT_ENCODING, arg_parser, nam
 from datamodel_code_generator.format import (
     DatetimeClassType,
     PythonVersion,
-    black_find_project_root,
     is_supported_in_black,
 )
 from datamodel_code_generator.parser import LiteralType
@@ -86,7 +85,7 @@ signal.signal(signal.SIGINT, sig_int_handler)
 
 class Config(BaseModel):
     if PYDANTIC_V2:
-        model_config = ConfigDict(arbitrary_types_allowed=True)
+        model_config = ConfigDict(arbitrary_types_allowed=True)  # pyright: ignore [reportAssignmentType]
 
         def get(self, item: str) -> Any:
             return getattr(self, item)
@@ -186,8 +185,13 @@ class Config(BaseModel):
 
     @model_validator(mode='after')
     def validate_keyword_only(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        python_target: PythonVersion = values.get('target_python_version')
-        if values.get('keyword_only') and not python_target.has_kw_only_dataclass:
+        output_model_type: DataModelType = values.get('output_model_type')  # pyright: ignore [reportAssignmentType]
+        python_target: PythonVersion = values.get('target_python_version')  # pyright: ignore [reportAssignmentType]
+        if (
+            values.get('keyword_only')
+            and output_model_type == DataModelType.DataclassesDataclass
+            and not python_target.has_kw_only_dataclass
+        ):
             raise Error(
                 f'`--keyword-only` requires `--target-python-version` {PythonVersion.PY_310.value} or higher.'
             )
@@ -215,7 +219,7 @@ class Config(BaseModel):
         def validate_each_item(each_item: Any) -> Tuple[str, str]:
             if isinstance(each_item, str):  # pragma: no cover
                 try:
-                    field_name, field_value = each_item.split(':', maxsplit=1)  # type: str, str
+                    field_name, field_value = each_item.split(':', maxsplit=1)
                     return field_name, field_value.lstrip()
                 except ValueError:
                     raise Error(f'Invalid http header: {each_item!r}')
@@ -232,7 +236,7 @@ class Config(BaseModel):
         def validate_each_item(each_item: Any) -> Tuple[str, str]:
             if isinstance(each_item, str):  # pragma: no cover
                 try:
-                    field_name, field_value = each_item.split('=', maxsplit=1)  # type: str, str
+                    field_name, field_value = each_item.split('=', maxsplit=1)
                     return field_name, field_value.lstrip()
                 except ValueError:
                     raise Error(f'Invalid http query parameter: {each_item!r}')
@@ -244,14 +248,16 @@ class Config(BaseModel):
 
     @model_validator(mode='before')
     def validate_additional_imports(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if values.get('additional_imports') is not None:
-            values['additional_imports'] = values.get('additional_imports').split(',')
+        additional_imports = values.get('additional_imports')
+        if additional_imports is not None:
+            values['additional_imports'] = additional_imports.split(',')
         return values
 
     @model_validator(mode='before')
     def validate_custom_formatters(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if values.get('custom_formatters') is not None:
-            values['custom_formatters'] = values.get('custom_formatters').split(',')
+        custom_formatters = values.get('custom_formatters')
+        if custom_formatters is not None:
+            values['custom_formatters'] = custom_formatters.split(',')
         return values
 
     if PYDANTIC_V2:
@@ -278,7 +284,7 @@ class Config(BaseModel):
     disable_warnings: bool = False
     target_python_version: PythonVersion = PythonVersion.PY_38
     base_class: str = ''
-    additional_imports: Optional[List[str]] = (None,)
+    additional_imports: Optional[List[str]] = None
     custom_template_dir: Optional[Path] = None
     extra_template_data: Optional[TextIOBase] = None
     validation: bool = False
@@ -341,6 +347,7 @@ class Config(BaseModel):
     union_mode: Optional[UnionMode] = None
     output_datetime_class: Optional[DatetimeClassType] = None
     keyword_only: bool = False
+    no_alias: bool = False
 
     def merge_args(self, args: Namespace) -> None:
         set_args = {
@@ -360,6 +367,26 @@ class Config(BaseModel):
             setattr(self, field_name, getattr(parsed_args, field_name))
 
 
+def _get_pyproject_toml_config(source: Path) -> Optional[Dict[str, Any]]:
+    """Find and return the [tool.datamodel-codgen] section of the closest
+    pyproject.toml if it exists.
+    """
+
+    current_path = source
+    while current_path != current_path.parent:
+        if (current_path / 'pyproject.toml').is_file():
+            pyproject_toml = load_toml(current_path / 'pyproject.toml')
+            if 'datamodel-codegen' in pyproject_toml.get('tool', {}):
+                return pyproject_toml['tool']['datamodel-codegen']
+
+        if (current_path / '.git').exists():
+            # Stop early if we see a git repository root.
+            return None
+
+        current_path = current_path.parent
+    return None
+
+
 def main(args: Optional[Sequence[str]] = None) -> Exit:
     """Main function."""
 
@@ -377,16 +404,9 @@ def main(args: Optional[Sequence[str]] = None) -> Exit:
         print(version)
         exit(0)
 
-    root = black_find_project_root((Path().resolve(),))
-    pyproject_toml_path = root / 'pyproject.toml'
-    if pyproject_toml_path.is_file():
-        pyproject_toml: Dict[str, Any] = {
-            k.replace('-', '_'): v
-            for k, v in load_toml(pyproject_toml_path)
-            .get('tool', {})
-            .get('datamodel-codegen', {})
-            .items()
-        }
+    pyproject_config = _get_pyproject_toml_config(Path().resolve())
+    if pyproject_config is not None:
+        pyproject_toml = {k.replace('-', '_'): v for k, v in pyproject_config.items()}
     else:
         pyproject_toml = {}
 
@@ -542,6 +562,7 @@ def main(args: Optional[Sequence[str]] = None) -> Exit:
             union_mode=config.union_mode,
             output_datetime_class=config.output_datetime_class,
             keyword_only=config.keyword_only,
+            no_alias=config.no_alias,
         )
         return Exit.OK
     except InvalidClassNameError as e:

datamodel_code_generator/arguments.py

@@ -98,7 +98,7 @@ base_options.add_argument(
 # ======================================================================================
 model_options.add_argument(
     '--allow-extra-fields',
-    help='Allow to pass extra fields, if this flag is not passed, extra fields are forbidden.',
+    help='Allow passing extra fields, if this flag is not passed, extra fields are forbidden.',
     action='store_true',
     default=None,
 )
@@ -381,6 +381,13 @@ field_options.add_argument(
     choices=[u.value for u in UnionMode],
     default=None,
 )
+field_options.add_argument(
+    '--no-alias',
+    help="""Do not add a field alias. E.g., if --snake-case-field is used along with a base class, which has an 
+            alias_generator""",
+    action='store_true',
+    default=None,
+)
 
 # ======================================================================================
 # Options for templating output

datamodel_code_generator/format.py

@@ -31,6 +31,7 @@ class PythonVersion(Enum):
     PY_310 = '3.10'
     PY_311 = '3.11'
     PY_312 = '3.12'
+    PY_313 = '3.13'
 
     @cached_property
     def _is_py_38_or_later(self) -> bool:  # pragma: no cover

datamodel_code_generator/http.py

@@ -21,7 +21,8 @@ def get_body(
         headers=headers,
         verify=not ignore_tls,
         follow_redirects=True,
-        params=query_parameters,
+        params=query_parameters,  # pyright: ignore [reportArgumentType]
+        # TODO: Improve params type
     ).text
 
 

datamodel_code_generator/imports.py

@@ -14,7 +14,7 @@ class Import(BaseModel):
     reference_path: Optional[str] = None
 
     @classmethod
-    @lru_cache()
+    @lru_cache
     def from_full_path(cls, class_path: str) -> Import:
         split_class_path: List[str] = class_path.split('.')
         return Import(
@@ -43,7 +43,7 @@ class Imports(DefaultDict[Optional[str], Set[str]]):
 
     def create_line(self, from_: Optional[str], imports: Set[str]) -> str:
         if from_:
-            return f"from {from_} import {', '.join(self._set_alias(from_, imports))}"
+            return f'from {from_} import {", ".join(self._set_alias(from_, imports))}'
         return '\n'.join(f'import {i}' for i in self._set_alias(from_, imports))
 
     def dump(self) -> str:

datamodel_code_generator/model/__init__.py

@@ -1,12 +1,19 @@
 from __future__ import annotations
 
+import sys
 from typing import TYPE_CHECKING, Callable, Iterable, List, NamedTuple, Optional, Type
 
+from .. import DatetimeClassType, PythonVersion
 from ..types import DataTypeManager as DataTypeManagerABC
 from .base import ConstraintsBase, DataModel, DataModelFieldBase
 
 if TYPE_CHECKING:
-    from .. import DataModelType, DatetimeClassType, PythonVersion
+    from .. import DataModelType
+
+DEFAULT_TARGET_DATETIME_CLASS = DatetimeClassType.Datetime
+DEFAULT_TARGET_PYTHON_VERSION = PythonVersion(
+    f'{sys.version_info.major}.{sys.version_info.minor}'
+)
 
 
 class DataModelSet(NamedTuple):
@@ -20,13 +27,15 @@ class DataModelSet(NamedTuple):
 
 def get_data_model_types(
     data_model_type: DataModelType,
-    target_python_version: PythonVersion,
-    target_datetime_class: DatetimeClassType,
+    target_python_version: PythonVersion = DEFAULT_TARGET_PYTHON_VERSION,
+    target_datetime_class: Optional[DatetimeClassType] = None,
 ) -> DataModelSet:
     from .. import DataModelType
     from . import dataclass, msgspec, pydantic, pydantic_v2, rootmodel, typed_dict
     from .types import DataTypeManager
 
+    if target_datetime_class is None:
+        target_datetime_class = DEFAULT_TARGET_DATETIME_CLASS
     if data_model_type == DataModelType.PydanticBaseModel:
         return DataModelSet(
             data_model=pydantic.BaseModel,
@@ -53,13 +62,17 @@ def get_data_model_types(
         )
     elif data_model_type == DataModelType.TypingTypedDict:
         return DataModelSet(
-            data_model=typed_dict.TypedDict
-            if target_python_version.has_typed_dict
-            else typed_dict.TypedDictBackport,
+            data_model=(
+                typed_dict.TypedDict
+                if target_python_version.has_typed_dict
+                else typed_dict.TypedDictBackport
+            ),
             root_model=rootmodel.RootModel,
-            field_model=typed_dict.DataModelField
-            if target_python_version.has_typed_dict_non_required
-            else typed_dict.DataModelFieldBackport,
+            field_model=(
+                typed_dict.DataModelField
+                if target_python_version.has_typed_dict_non_required
+                else typed_dict.DataModelFieldBackport
+            ),
             data_type_manager=DataTypeManager,
             dump_resolve_reference_action=None,
         )

datamodel_code_generator/model/base.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 from collections import defaultdict
+from copy import deepcopy
 from functools import lru_cache
 from pathlib import Path
 from typing import (
@@ -52,7 +53,7 @@ class ConstraintsBase(_BaseModel):
     unique_items: Optional[bool] = Field(None, alias='uniqueItems')
     _exclude_fields: ClassVar[Set[str]] = {'has_constraints'}
     if PYDANTIC_V2:
-        model_config = ConfigDict(
+        model_config = ConfigDict(  # pyright: ignore [reportAssignmentType]
             arbitrary_types_allowed=True, ignored_types=(cached_property,)
         )
     else:
@@ -86,7 +87,9 @@ class ConstraintsBase(_BaseModel):
         else:
             model_field_constraints = {}
 
-        if not issubclass(constraints_class, ConstraintsBase):  # pragma: no cover
+        if constraints_class is None or not issubclass(
+            constraints_class, ConstraintsBase
+        ):  # pragma: no cover
             return None
 
         return constraints_class.parse_obj(
@@ -118,6 +121,7 @@ class DataModelFieldBase(_BaseModel):
     _exclude_fields: ClassVar[Set[str]] = {'parent'}
     _pass_fields: ClassVar[Set[str]] = {'parent', 'data_type'}
     can_have_extra_keys: ClassVar[bool] = True
+    type_has_null: Optional[bool] = None
 
     if not TYPE_CHECKING:
 
@@ -150,6 +154,8 @@ class DataModelFieldBase(_BaseModel):
                 return get_optional_type(type_hint, self.data_type.use_union_operator)
             return type_hint
         elif self.required:
+            if self.type_has_null:
+                return get_optional_type(type_hint, self.data_type.use_union_operator)
             return type_hint
         elif self.fall_back_to_nullable:
             return get_optional_type(type_hint, self.data_type.use_union_operator)
@@ -161,7 +167,7 @@ class DataModelFieldBase(_BaseModel):
         type_hint = self.type_hint
         has_union = not self.data_type.use_union_operator and UNION_PREFIX in type_hint
         imports: List[Union[Tuple[Import], Iterator[Import]]] = [
-            (
+            iter(
                 i
                 for i in self.data_type.all_imports
                 if not (not has_union and i == IMPORT_UNION)
@@ -225,7 +231,7 @@ class DataModelFieldBase(_BaseModel):
         return True
 
 
-@lru_cache()
+@lru_cache
 def get_template(template_file_path: Path) -> Template:
     loader = FileSystemLoader(str(TEMPLATE_DIR / template_file_path.parent))
     environment: Environment = Environment(loader=loader)
@@ -247,7 +253,7 @@ def get_module_name(name: str, file_path: Optional[Path]) -> str:
 
 
 class TemplateBase(ABC):
-    @property
+    @cached_property
     @abstractmethod
     def template_file_path(self) -> Path:
         raise NotImplementedError
@@ -316,6 +322,8 @@ class DataModel(TemplateBase, Nullable, ABC):
         self.reference.source = self
 
         self.extra_template_data = (
+            # The supplied defaultdict will either create a new entry,
+            # or already contain a predefined entry for this type
             extra_template_data[self.name]
             if extra_template_data is not None
             else defaultdict(dict)
@@ -327,10 +335,12 @@ class DataModel(TemplateBase, Nullable, ABC):
             if base_class.reference:
                 base_class.reference.children.append(self)
 
-        if extra_template_data:
+        if extra_template_data is not None:
             all_model_extra_template_data = extra_template_data.get(ALL_MODEL)
             if all_model_extra_template_data:
-                self.extra_template_data.update(all_model_extra_template_data)
+                # The deepcopy is needed here to ensure that different models don't
+                # end up inadvertently sharing state (such as "base_class_kwargs")
+                self.extra_template_data.update(deepcopy(all_model_extra_template_data))
 
         self.methods: List[str] = methods or []
 
@@ -415,7 +425,7 @@ class DataModel(TemplateBase, Nullable, ABC):
     def class_name(self, class_name: str) -> None:
         if '.' in self.reference.name:
             self.reference.name = (
-                f"{self.reference.name.rsplit('.', 1)[0]}.{class_name}"
+                f'{self.reference.name.rsplit(".", 1)[0]}.{class_name}'
             )
         else:
             self.reference.name = class_name

datamodel_code_generator/model/enum.py

@@ -82,10 +82,22 @@ class Enum(DataModel):
 
     def find_member(self, value: Any) -> Optional[Member]:
         repr_value = repr(value)
-        for field in self.fields:  # pragma: no cover
-            if field.default == repr_value:
+        # Remove surrounding quotes from the string representation
+        str_value = str(value).strip('\'"')
+
+        for field in self.fields:
+            # Remove surrounding quotes from field default value
+            field_default = (field.default or '').strip('\'"')
+
+            # Compare values after removing quotes
+            if field_default == str_value:
                 return self.get_member(field)
-        return None  # pragma: no cover
+
+            # Keep original comparison for backwards compatibility
+            if field.default == repr_value:  # pragma: no cover
+                return self.get_member(field)
+
+        return None
 
     @property
     def imports(self) -> Tuple[Import, ...]:

datamodel_code_generator/model/msgspec.py

@@ -31,7 +31,6 @@ from datamodel_code_generator.model.imports import (
     IMPORT_MSGSPEC_CONVERT,
     IMPORT_MSGSPEC_FIELD,
     IMPORT_MSGSPEC_META,
-    IMPORT_MSGSPEC_STRUCT,
 )
 from datamodel_code_generator.model.pydantic.base_model import (
     Constraints as _Constraints,
@@ -88,7 +87,7 @@ class RootModel(_RootModel):
 class Struct(DataModel):
     TEMPLATE_FILE_PATH: ClassVar[str] = 'msgspec.jinja2'
     BASE_CLASS: ClassVar[str] = 'msgspec.Struct'
-    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = (IMPORT_MSGSPEC_STRUCT,)
+    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = ()
 
     def __init__(
         self,
@@ -123,6 +122,8 @@ class Struct(DataModel):
             keyword_only=keyword_only,
         )
         self.extra_template_data.setdefault('base_class_kwargs', {})
+        if self.keyword_only:
+            self.add_base_class_kwarg('kw_only', 'True')
 
     def add_base_class_kwarg(self, name: str, value):
         self.extra_template_data['base_class_kwargs'][name] = value

datamodel_code_generator/model/pydantic/base_model.py

@@ -322,4 +322,4 @@ class BaseModel(BaseModelBase):
         if config_parameters:
             from datamodel_code_generator.model.pydantic import Config
 
-            self.extra_template_data['config'] = Config.parse_obj(config_parameters)
+            self.extra_template_data['config'] = Config.parse_obj(config_parameters)  # pyright: ignore [reportArgumentType]

datamodel_code_generator/model/pydantic/types.py

@@ -180,7 +180,7 @@ class DataTypeManager(_DataTypeManager):
             self.data_type,
             strict_types=self.strict_types,
             pattern_key=self.PATTERN_KEY,
-            target_datetime_class=target_datetime_class,
+            target_datetime_class=self.target_datetime_class,
         )
         self.strict_type_map: Dict[StrictTypes, DataType] = strict_type_map_factory(
             self.data_type,

datamodel_code_generator/model/pydantic_v2/base_model.py

@@ -98,7 +98,7 @@ class DataModelField(DataModelFieldV1):
         'max_length',
         'union_mode',
     }
-    constraints: Optional[Constraints] = None
+    constraints: Optional[Constraints] = None  # pyright: ignore [reportIncompatibleVariableOverride]
     _PARSE_METHOD: ClassVar[str] = 'model_validate'
     can_have_extra_keys: ClassVar[bool] = False
 
@@ -234,7 +234,7 @@ class BaseModel(BaseModelBase):
         if config_parameters:
             from datamodel_code_generator.model.pydantic_v2 import ConfigDict
 
-            self.extra_template_data['config'] = ConfigDict.parse_obj(config_parameters)
+            self.extra_template_data['config'] = ConfigDict.parse_obj(config_parameters)  # pyright: ignore [reportArgumentType]
             self._additional_imports.append(IMPORT_CONFIG_DICT)
 
     def _get_config_extra(self) -> Optional[Literal["'allow'", "'forbid'"]]:

datamodel_code_generator/model/pydantic_v2/types.py

@@ -24,7 +24,10 @@ class DataTypeManager(_DataTypeManager):
     ) -> Dict[Types, DataType]:
         result = {
             **super().type_map_factory(
-                data_type, strict_types, pattern_key, target_datetime_class
+                data_type,
+                strict_types,
+                pattern_key,
+                target_datetime_class or DatetimeClassType.Datetime,
             ),
             Types.hostname: self.data_type.from_import(
                 IMPORT_CONSTR,