datamodel-code-generator 0.26.2__tar.gz → 0.26.4__tar.gz

{datamodel_code_generator-0.26.2 → datamodel_code_generator-0.26.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datamodel-code-generator
-Version: 0.26.2
+Version: 0.26.4
 Summary: Datamodel Code Generator
 Home-page: https://github.com/koxudaxi/datamodel-code-generator
 License: MIT
@@ -458,6 +458,8 @@ Field customization:
   --field-include-all-keys
                         Add all keys to field parameters
   --force-optional      Force optional for required fields
+  --no-alias            Do not add a field alias. E.g., if --snake-case-field is used along
+                        with a base class, which has an alias_generator
   --original-field-name-delimiter ORIGINAL_FIELD_NAME_DELIMITER
                         Set delimiter to convert to snake case. This option only can be used
                         with --snake-case-field (default: `_` )
@@ -499,8 +501,8 @@ Model customization:
                         dataclass(kw_only=True)).
   --output-datetime-class {datetime,AwareDatetime,NaiveDatetime}
                         Choose Datetime class between AwareDatetime, NaiveDatetime or
-                        datetime. Each output model has its default mapping, and only
-                        pydantic and dataclass support this override"
+                        datetime. Each output model has its default mapping (for example
+                        pydantic: datetime, dataclass: str, ...)
   --reuse-model         Reuse models on the field when a module has the model with the same
                         content
   --target-python-version {3.6,3.7,3.8,3.9,3.10,3.11,3.12}

{datamodel_code_generator-0.26.2 → datamodel_code_generator-0.26.4}/README.md

@@ -413,6 +413,8 @@ Field customization:
   --field-include-all-keys
                         Add all keys to field parameters
   --force-optional      Force optional for required fields
+  --no-alias            Do not add a field alias. E.g., if --snake-case-field is used along
+                        with a base class, which has an alias_generator
   --original-field-name-delimiter ORIGINAL_FIELD_NAME_DELIMITER
                         Set delimiter to convert to snake case. This option only can be used
                         with --snake-case-field (default: `_` )
@@ -454,8 +456,8 @@ Model customization:
                         dataclass(kw_only=True)).
   --output-datetime-class {datetime,AwareDatetime,NaiveDatetime}
                         Choose Datetime class between AwareDatetime, NaiveDatetime or
-                        datetime. Each output model has its default mapping, and only
-                        pydantic and dataclass support this override"
+                        datetime. Each output model has its default mapping (for example
+                        pydantic: datetime, dataclass: str, ...)
   --reuse-model         Reuse models on the field when a module has the model with the same
                         content
   --target-python-version {3.6,3.7,3.8,3.9,3.10,3.11,3.12}

{datamodel_code_generator-0.26.2 → datamodel_code_generator-0.26.4}/datamodel_code_generator/__init__.py

@@ -231,7 +231,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 +303,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 +354,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 +374,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
 
@@ -478,6 +499,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,6 +510,9 @@ 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:
             input_filename = input_.name
     if not results:

{datamodel_code_generator-0.26.2 → datamodel_code_generator-0.26.4}/datamodel_code_generator/__main__.py

@@ -186,8 +186,13 @@ class Config(BaseModel):
 
     @model_validator(mode='after')
     def validate_keyword_only(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        output_model_type: DataModelType = values.get('output_model_type')
         python_target: PythonVersion = values.get('target_python_version')
-        if values.get('keyword_only') and not python_target.has_kw_only_dataclass:
+        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.'
             )
@@ -341,6 +346,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 = {
@@ -542,6 +548,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-0.26.2 → datamodel_code_generator-0.26.4}/datamodel_code_generator/arguments.py

@@ -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-0.26.2 → datamodel_code_generator-0.26.4}/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-0.26.2 → datamodel_code_generator-0.26.4}/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,8 +27,8 @@ 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: DatetimeClassType = DEFAULT_TARGET_DATETIME_CLASS,
 ) -> DataModelSet:
     from .. import DataModelType
     from . import dataclass, msgspec, pydantic, pydantic_v2, rootmodel, typed_dict
@@ -53,13 +60,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,
         )
@@ -68,7 +79,7 @@ def get_data_model_types(
             data_model=msgspec.Struct,
             root_model=msgspec.RootModel,
             field_model=msgspec.DataModelField,
-            data_type_manager=DataTypeManager,
+            data_type_manager=msgspec.DataTypeManager,
             dump_resolve_reference_action=None,
             known_third_party=['msgspec'],
         )

{datamodel_code_generator-0.26.2 → datamodel_code_generator-0.26.4}/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 (
@@ -118,6 +119,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 +152,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)
@@ -316,6 +320,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 +333,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 []
 

{datamodel_code_generator-0.26.2 → datamodel_code_generator-0.26.4}/datamodel_code_generator/model/imports.py

@@ -2,6 +2,7 @@ from datamodel_code_generator.imports import Import
 
 IMPORT_DATACLASS = Import.from_full_path('dataclasses.dataclass')
 IMPORT_FIELD = Import.from_full_path('dataclasses.field')
+IMPORT_CLASSVAR = Import.from_full_path('typing.ClassVar')
 IMPORT_TYPED_DICT = Import.from_full_path('typing.TypedDict')
 IMPORT_TYPED_DICT_BACKPORT = Import.from_full_path('typing_extensions.TypedDict')
 IMPORT_NOT_REQUIRED = Import.from_full_path('typing.NotRequired')

{datamodel_code_generator-0.26.2 → datamodel_code_generator-0.26.4}/datamodel_code_generator/model/msgspec.py

@@ -7,6 +7,7 @@ from typing import (
     Dict,
     List,
     Optional,
+    Sequence,
     Set,
     Tuple,
     Type,
@@ -15,21 +16,36 @@ from typing import (
 
 from pydantic import Field
 
-from datamodel_code_generator.imports import Import
+from datamodel_code_generator import DatetimeClassType, PythonVersion
+from datamodel_code_generator.imports import (
+    IMPORT_DATE,
+    IMPORT_DATETIME,
+    IMPORT_TIME,
+    IMPORT_TIMEDELTA,
+    Import,
+)
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model.base import UNDEFINED
 from datamodel_code_generator.model.imports import (
+    IMPORT_CLASSVAR,
     IMPORT_MSGSPEC_CONVERT,
     IMPORT_MSGSPEC_FIELD,
     IMPORT_MSGSPEC_META,
-    IMPORT_MSGSPEC_STRUCT,
 )
 from datamodel_code_generator.model.pydantic.base_model import (
     Constraints as _Constraints,
 )
 from datamodel_code_generator.model.rootmodel import RootModel as _RootModel
+from datamodel_code_generator.model.types import DataTypeManager as _DataTypeManager
+from datamodel_code_generator.model.types import type_map_factory
 from datamodel_code_generator.reference import Reference
-from datamodel_code_generator.types import chain_as_tuple, get_optional_type
+from datamodel_code_generator.types import (
+    DataType,
+    StrictTypes,
+    Types,
+    chain_as_tuple,
+    get_optional_type,
+)
 
 
 def _has_field_assignment(field: DataModelFieldBase) -> bool:
@@ -56,6 +72,8 @@ def import_extender(cls: Type[DataModelFieldBaseT]) -> Type[DataModelFieldBaseT]
             extra_imports.append(IMPORT_MSGSPEC_CONVERT)
         if self.annotated:
             extra_imports.append(IMPORT_MSGSPEC_META)
+        if self.extras.get('is_classvar'):
+            extra_imports.append(IMPORT_CLASSVAR)
         return chain_as_tuple(original_imports.fget(self), extra_imports)  # type: ignore
 
     setattr(cls, 'imports', property(new_imports))
@@ -69,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,
@@ -103,6 +121,12 @@ class Struct(DataModel):
             nullable=nullable,
             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
 
 
 class Constraints(_Constraints):
@@ -241,11 +265,16 @@ class DataModelField(DataModelFieldBase):
 
         meta = f'Meta({", ".join(meta_arguments)})'
 
-        if not self.required:
+        if not self.required and not self.extras.get('is_classvar'):
             type_hint = self.data_type.type_hint
             annotated_type = f'Annotated[{type_hint}, {meta}]'
             return get_optional_type(annotated_type, self.data_type.use_union_operator)
-        return f'Annotated[{self.type_hint}, {meta}]'
+
+        annotated_type = f'Annotated[{self.type_hint}, {meta}]'
+        if self.extras.get('is_classvar'):
+            annotated_type = f'ClassVar[{annotated_type}]'
+
+        return annotated_type
 
     def _get_default_as_struct_model(self) -> Optional[str]:
         for data_type in self.data_type.data_types or (self.data_type,):
@@ -267,3 +296,43 @@ class DataModelField(DataModelFieldBase):
             elif data_type.reference and isinstance(data_type.reference.source, Struct):
                 return f'lambda: {self._PARSE_METHOD}({repr(self.default)},  type={data_type.alias or data_type.reference.source.class_name})'
         return None
+
+
+class DataTypeManager(_DataTypeManager):
+    def __init__(
+        self,
+        python_version: PythonVersion = PythonVersion.PY_38,
+        use_standard_collections: bool = False,
+        use_generic_container_types: bool = False,
+        strict_types: Optional[Sequence[StrictTypes]] = None,
+        use_non_positive_negative_number_constrained_types: bool = False,
+        use_union_operator: bool = False,
+        use_pendulum: bool = False,
+        target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
+    ):
+        super().__init__(
+            python_version,
+            use_standard_collections,
+            use_generic_container_types,
+            strict_types,
+            use_non_positive_negative_number_constrained_types,
+            use_union_operator,
+            use_pendulum,
+            target_datetime_class,
+        )
+
+        datetime_map = (
+            {
+                Types.time: self.data_type.from_import(IMPORT_TIME),
+                Types.date: self.data_type.from_import(IMPORT_DATE),
+                Types.date_time: self.data_type.from_import(IMPORT_DATETIME),
+                Types.timedelta: self.data_type.from_import(IMPORT_TIMEDELTA),
+            }
+            if target_datetime_class is DatetimeClassType.Datetime
+            else {}
+        )
+
+        self.type_map: Dict[Types, DataType] = {
+            **type_map_factory(self.data_type),
+            **datetime_map,
+        }

{datamodel_code_generator-0.26.2 → datamodel_code_generator-0.26.4}/datamodel_code_generator/model/pydantic_v2/__init__.py

@@ -23,6 +23,7 @@ class ConfigDict(_BaseModel):
     arbitrary_types_allowed: Optional[bool] = None
     protected_namespaces: Optional[Tuple[str, ...]] = None
     regex_engine: Optional[str] = None
+    use_enum_values: Optional[bool] = None
 
 
 __all__ = [

{datamodel_code_generator-0.26.2 → datamodel_code_generator-0.26.4}/datamodel_code_generator/model/template/msgspec.jinja2

@@ -2,7 +2,9 @@
 {{ decorator }}
 {% endfor -%}
 {%- if base_class %}
-class {{ class_name }}({{ base_class }}):
+class {{ class_name }}({{ base_class }}{%- for key, value in (base_class_kwargs|default({})).items() -%}
+, {{ key }}={{ value }}
+{%- endfor -%}):
 {%- else %}
 class {{ class_name }}:
 {%- endif %}

{datamodel_code_generator-0.26.2 → datamodel_code_generator-0.26.4}/datamodel_code_generator/parser/base.py

@@ -39,6 +39,7 @@ from datamodel_code_generator.imports import (
     Imports,
 )
 from datamodel_code_generator.model import dataclass as dataclass_model
+from datamodel_code_generator.model import msgspec as msgspec_model
 from datamodel_code_generator.model import pydantic as pydantic_model
 from datamodel_code_generator.model import pydantic_v2 as pydantic_model_v2
 from datamodel_code_generator.model.base import (
@@ -411,6 +412,7 @@ class Parser(ABC):
         default_field_extras: Optional[Dict[str, Any]] = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
+        no_alias: bool = False,
     ) -> None:
         self.keyword_only = keyword_only
         self.data_type_manager: DataTypeManager = data_type_manager_type(
@@ -511,6 +513,7 @@ class Parser(ABC):
             special_field_name_prefix=special_field_name_prefix,
             remove_special_field_name_prefix=remove_special_field_name_prefix,
             capitalise_enum_members=capitalise_enum_members,
+            no_alias=no_alias,
         )
         self.class_name: Optional[str] = class_name
         self.wrap_string_literal: Optional[bool] = wrap_string_literal
@@ -803,35 +806,54 @@ class Parser(ABC):
                     if not data_type.reference:  # pragma: no cover
                         continue
                     discriminator_model = data_type.reference.source
+
                     if not isinstance(  # pragma: no cover
                         discriminator_model,
                         (
                             pydantic_model.BaseModel,
                             pydantic_model_v2.BaseModel,
                             dataclass_model.DataClass,
+                            msgspec_model.Struct,
                         ),
                     ):
                         continue  # pragma: no cover
-                    type_names = []
-                    if mapping:
+
+                    type_names: List[str] = []
+
+                    def check_paths(
+                        model: Union[
+                            pydantic_model.BaseModel,
+                            pydantic_model_v2.BaseModel,
+                            Reference,
+                        ],
+                        mapping: Dict[str, str],
+                        type_names: List[str] = type_names,
+                    ) -> None:
+                        """Helper function to validate paths for a given model."""
                         for name, path in mapping.items():
                             if (
-                                discriminator_model.path.split('#/')[-1]
-                                != path.split('#/')[-1]
+                                model.path.split('#/')[-1] != path.split('#/')[-1]
+                            ) and (
+                                path.startswith('#/')
+                                or model.path[:-1] != path.split('/')[-1]
                             ):
-                                if (
-                                    path.startswith('#/')
-                                    or discriminator_model.path[:-1]
-                                    != path.split('/')[-1]
-                                ):
-                                    t_path = path[str(path).find('/') + 1 :]
-                                    t_disc = discriminator_model.path[
-                                        : str(discriminator_model.path).find('#')
-                                    ].lstrip('../')
-                                    t_disc_2 = '/'.join(t_disc.split('/')[1:])
-                                    if t_path != t_disc and t_path != t_disc_2:
-                                        continue
+                                t_path = path[str(path).find('/') + 1 :]
+                                t_disc = model.path[: str(model.path).find('#')].lstrip(
+                                    '../'
+                                )
+                                t_disc_2 = '/'.join(t_disc.split('/')[1:])
+                                if t_path != t_disc and t_path != t_disc_2:
+                                    continue
                             type_names.append(name)
+
+                    # Check the main discriminator model path
+                    if mapping:
+                        check_paths(discriminator_model, mapping)
+
+                        # Check the base_classes if they exist
+                        if len(type_names) == 0:
+                            for base_class in discriminator_model.base_classes:
+                                check_paths(base_class.reference, mapping)
                     else:
                         type_names = [discriminator_model.path.split('/')[-1]]
                     if not type_names:  # pragma: no cover
@@ -846,13 +868,22 @@ class Parser(ABC):
                         ) != property_name:
                             continue
                         literals = discriminator_field.data_type.literals
-                        if (
-                            len(literals) == 1 and literals[0] == type_names[0]
-                            if type_names
-                            else None
+                        if len(literals) == 1 and literals[0] == (
+                            type_names[0] if type_names else None
                         ):
                             has_one_literal = True
-                            continue
+                            if isinstance(
+                                discriminator_model, msgspec_model.Struct
+                            ):  # pragma: no cover
+                                discriminator_model.add_base_class_kwarg(
+                                    'tag_field', f"'{property_name}'"
+                                )
+                                discriminator_model.add_base_class_kwarg(
+                                    'tag', discriminator_field.represented_default
+                                )
+                                discriminator_field.extras['is_classvar'] = True
+                            # Found the discriminator field, no need to keep looking
+                            break
                         for (
                             field_data_type
                         ) in discriminator_field.data_type.all_data_types:
@@ -879,7 +910,8 @@ class Parser(ABC):
                         else IMPORT_LITERAL_BACKPORT
                     )
                     has_imported_literal = any(
-                        literal == import_ for import_ in imports
+                        literal == import_  # type: ignore [comparison-overlap]
+                        for import_ in imports
                     )
                     if has_imported_literal:  # pragma: no cover
                         imports.append(literal)

{datamodel_code_generator-0.26.2 → datamodel_code_generator-0.26.4}/datamodel_code_generator/parser/graphql.py

@@ -160,6 +160,7 @@ class GraphQLParser(Parser):
         default_field_extras: Optional[Dict[str, Any]] = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
+        no_alias: bool = False,
     ) -> None:
         super().__init__(
             source=source,
@@ -232,6 +233,7 @@ class GraphQLParser(Parser):
             default_field_extras=default_field_extras,
             target_datetime_class=target_datetime_class,
             keyword_only=keyword_only,
+            no_alias=no_alias,
         )
 
         self.data_model_scalar_type = data_model_scalar_type

{datamodel_code_generator-0.26.2 → datamodel_code_generator-0.26.4}/datamodel_code_generator/parser/jsonschema.py

@@ -448,6 +448,7 @@ class JsonSchemaParser(Parser):
         default_field_extras: Optional[Dict[str, Any]] = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
+        no_alias: bool = False,
     ) -> None:
         super().__init__(
             source=source,
@@ -520,6 +521,7 @@ class JsonSchemaParser(Parser):
             default_field_extras=default_field_extras,
             target_datetime_class=target_datetime_class,
             keyword_only=keyword_only,
+            no_alias=no_alias,
         )
 
         self.remote_object_cache: DefaultPutDict[str, Dict[str, Any]] = DefaultPutDict()
@@ -618,6 +620,7 @@ class JsonSchemaParser(Parser):
             use_default_kwarg=self.use_default_kwarg,
             original_name=original_field_name,
             has_default=field.has_default,
+            type_has_null=field.type_has_null,
         )
 
     def get_data_type(self, obj: JsonSchemaObject) -> DataType:
@@ -1715,6 +1718,9 @@ class JsonSchemaParser(Parser):
     def parse_raw(self) -> None:
         for source, path_parts in self._get_context_source_path_parts():
             self.raw_obj = load_yaml(source.text)
+            if self.raw_obj is None:  # pragma: no cover
+                warn(f'{source.path} is empty. Skipping this file')
+                continue
             if self.custom_class_name_generator:
                 obj_name = self.raw_obj.get('title', 'Model')
             else:

{datamodel_code_generator-0.26.2 → datamodel_code_generator-0.26.4}/datamodel_code_generator/parser/openapi.py

@@ -228,6 +228,7 @@ class OpenAPIParser(JsonSchemaParser):
         default_field_extras: Optional[Dict[str, Any]] = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
+        no_alias: bool = False,
     ):
         super().__init__(
             source=source,
@@ -300,6 +301,7 @@ class OpenAPIParser(JsonSchemaParser):
             default_field_extras=default_field_extras,
             target_datetime_class=target_datetime_class,
             keyword_only=keyword_only,
+            no_alias=no_alias,
         )
         self.open_api_scopes: List[OpenAPIScope] = openapi_scopes or [
             OpenAPIScope.Schemas
@@ -314,8 +316,10 @@ class OpenAPIParser(JsonSchemaParser):
         return get_model_by_path(ref_body, ref_path.split('/')[1:])
 
     def get_data_type(self, obj: JsonSchemaObject) -> DataType:
-        # OpenAPI doesn't allow `null` in `type` field and list of types
+        # OpenAPI 3.0 doesn't allow `null` in the `type` field and list of types
         # https://swagger.io/docs/specification/data-models/data-types/#null
+        # OpenAPI 3.1 does allow `null` in the `type` field and is equivalent to
+        # a `nullable` flag on the property itself
         if obj.nullable and self.strict_nullable and isinstance(obj.type, str):
             obj.type = [obj.type, 'null']
 
@@ -504,6 +508,9 @@ class OpenAPIParser(JsonSchemaParser):
                         has_default=object_schema.has_default
                         if object_schema
                         else False,
+                        type_has_null=object_schema.type_has_null
+                        if object_schema
+                        else None,
                     )
                 )
 
@@ -513,6 +520,7 @@ class OpenAPIParser(JsonSchemaParser):
                     fields=fields,
                     reference=reference,
                     custom_base_class=self.base_class,
+                    custom_template_dir=self.custom_template_dir,
                     keyword_only=self.keyword_only,
                 )
             )

{datamodel_code_generator-0.26.2 → datamodel_code_generator-0.26.4}/datamodel_code_generator/reference.py

@@ -198,6 +198,7 @@ class FieldNameResolver:
         special_field_name_prefix: Optional[str] = None,
         remove_special_field_name_prefix: bool = False,
         capitalise_enum_members: bool = False,
+        no_alias: bool = False,
     ):
         self.aliases: Mapping[str, str] = {} if aliases is None else {**aliases}
         self.empty_field_name: str = empty_field_name or '_'
@@ -208,6 +209,7 @@ class FieldNameResolver:
         )
         self.remove_special_field_name_prefix: bool = remove_special_field_name_prefix
         self.capitalise_enum_members: bool = capitalise_enum_members
+        self.no_alias = no_alias
 
     @classmethod
     def _validate_field_name(cls, field_name: str) -> bool:
@@ -274,7 +276,10 @@ class FieldNameResolver:
         if field_name in self.aliases:
             return self.aliases[field_name], field_name
         valid_name = self.get_valid_name(field_name, excludes=excludes)
-        return valid_name, None if field_name == valid_name else field_name
+        return (
+            valid_name,
+            None if self.no_alias or field_name == valid_name else field_name,
+        )
 
 
 class PydanticFieldNameResolver(FieldNameResolver):
@@ -354,6 +359,7 @@ class ModelResolver:
         special_field_name_prefix: Optional[str] = None,
         remove_special_field_name_prefix: bool = False,
         capitalise_enum_members: bool = False,
+        no_alias: bool = False,
     ) -> None:
         self.references: Dict[str, Reference] = {}
         self._current_root: Sequence[str] = []
@@ -383,6 +389,7 @@ class ModelResolver:
                 capitalise_enum_members=capitalise_enum_members
                 if k == ModelType.ENUM
                 else False,
+                no_alias=no_alias,
             )
             for k, v in merged_field_name_resolver_classes.items()
         }
@@ -566,11 +573,13 @@ class ModelResolver:
         split_ref = ref.rsplit('/', 1)
         if len(split_ref) == 1:
             original_name = Path(
-                split_ref[0][:-1] if self.is_external_root_ref(path) else split_ref[0]
+                split_ref[0].rstrip('#')
+                if self.is_external_root_ref(path)
+                else split_ref[0]
             ).stem
         else:
             original_name = (
-                Path(split_ref[1][:-1]).stem
+                Path(split_ref[1].rstrip('#')).stem
                 if self.is_external_root_ref(path)
                 else split_ref[1]
             )

datamodel_code_generator-0.26.4/datamodel_code_generator/version.py

@@ -0,0 +1 @@
+version: str = '0.26.4'

{datamodel_code_generator-0.26.2 → datamodel_code_generator-0.26.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "datamodel-code-generator"
-version = "0.26.2"
+version = "0.26.4"
 description = "Datamodel Code Generator"
 authors = ["Koudai Aono <koxudaxi@gmail.com>"]
 readme = "README.md"
@@ -19,6 +19,7 @@ classifiers = [
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
         "Programming Language :: Python :: Implementation :: CPython"]
 
 [build-system]
@@ -68,7 +69,7 @@ pytest-benchmark = "*"
 pytest-cov = ">=2.12.1"
 pytest-mock = "*"
 mypy = ">=1.4.1,<1.5.0"
-black = "^23.3.0"
+black = ">=23.3,<25.0"
 freezegun = "*"
 types-Jinja2 = "*"
 types-PyYAML = "*"
@@ -77,8 +78,8 @@ types-setuptools = ">=67.6.0.5,<70.0.0.0"
 pydantic = "*"
 httpx = ">=0.24.1"
 PySnooper = "*"
-ruff = ">=0.0.290,<0.5.7"
-ruff-lsp = ">=0.0.39,<0.0.41"
+ruff = ">=0.0.290,<0.7.5"
+ruff-lsp = ">=0.0.39,<0.0.60"
 pre-commit = "*"
 pytest-xdist = "^3.3.1"
 prance = "*"

datamodel_code_generator-0.26.2/datamodel_code_generator/version.py

@@ -1 +0,0 @@
-version: str = '0.26.2'