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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datamodel-code-generator
-Version: 0.26.2
+Version: 0.26.3
 Summary: Datamodel Code Generator
 Home-page: https://github.com/koxudaxi/datamodel-code-generator
 License: MIT
@@ -500,7 +500,7 @@ Model customization:
   --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"
+                        pydantic, dataclass, and msgspec support this override"
   --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.3}/README.md

@@ -455,7 +455,7 @@ Model customization:
   --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"
+                        pydantic, dataclass, and msgspec support this override"
   --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.3}/datamodel_code_generator/model/__init__.py

@@ -68,7 +68,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.3}/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.3}/datamodel_code_generator/model/msgspec.py

@@ -7,6 +7,7 @@ from typing import (
     Dict,
     List,
     Optional,
+    Sequence,
     Set,
     Tuple,
     Type,
@@ -15,10 +16,18 @@ 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,
@@ -28,8 +37,16 @@ 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 +73,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))
@@ -103,6 +122,10 @@ class Struct(DataModel):
             nullable=nullable,
             keyword_only=keyword_only,
         )
+        self.extra_template_data.setdefault('base_class_kwargs', {})
+
+    def add_base_class_kwarg(self, name: str, value):
+        self.extra_template_data['base_class_kwargs'][name] = value
 
 
 class Constraints(_Constraints):
@@ -241,11 +264,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 +295,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.3}/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.3}/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.3}/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 (
@@ -803,35 +804,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
@@ -852,6 +872,16 @@ class Parser(ABC):
                             else None
                         ):
                             has_one_literal = True
+                            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
                             continue
                         for (
                             field_data_type
@@ -879,7 +909,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.3/datamodel_code_generator/version.py

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

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "datamodel-code-generator"
-version = "0.26.2"
+version = "0.26.3"
 description = "Datamodel Code Generator"
 authors = ["Koudai Aono <koxudaxi@gmail.com>"]
 readme = "README.md"
@@ -68,7 +68,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,7 +77,7 @@ types-setuptools = ">=67.6.0.5,<70.0.0.0"
 pydantic = "*"
 httpx = ">=0.24.1"
 PySnooper = "*"
-ruff = ">=0.0.290,<0.5.7"
+ruff = ">=0.0.290,<0.6.10"
 ruff-lsp = ">=0.0.39,<0.0.41"
 pre-commit = "*"
 pytest-xdist = "^3.3.1"

datamodel_code_generator-0.26.2/datamodel_code_generator/version.py

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