datamodel-code-generator 0.26.0__py3-none-any.whl → 0.26.2__py3-none-any.whl

datamodel_code_generator/__init__.py

@@ -30,7 +30,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.format import DatetimeClassType, PythonVersion
 from datamodel_code_generator.model.pydantic_v2 import UnionMode
 from datamodel_code_generator.parser import DefaultPutDict, LiteralType
 from datamodel_code_generator.parser.base import Parser
@@ -301,6 +301,8 @@ def generate(
     treat_dots_as_module: bool = False,
     use_exact_imports: bool = False,
     union_mode: Optional[UnionMode] = None,
+    output_datetime_class: Optional[DatetimeClassType] = None,
+    keyword_only: bool = False,
 ) -> None:
     remote_text_cache: DefaultPutDict[str, str] = DefaultPutDict()
     if isinstance(input_, str):
@@ -395,9 +397,12 @@ def generate(
             raise Error('union_mode is only supported for pydantic_v2.BaseModel')
     else:
         default_field_extras = None
+
     from datamodel_code_generator.model import get_data_model_types
 
-    data_model_types = get_data_model_types(output_model_type, target_python_version)
+    data_model_types = get_data_model_types(
+        output_model_type, target_python_version, output_datetime_class
+    )
     parser = parser_class(
         source=input_text or input_,
         data_model_type=data_model_types.data_model,
@@ -471,6 +476,8 @@ def generate(
         treat_dots_as_module=treat_dots_as_module,
         use_exact_imports=use_exact_imports,
         default_field_extras=default_field_extras,
+        target_datetime_class=output_datetime_class,
+        keyword_only=keyword_only,
         **kwargs,
     )
 

datamodel_code_generator/__main__.py

@@ -51,6 +51,7 @@ from datamodel_code_generator import (
 )
 from datamodel_code_generator.arguments import DEFAULT_ENCODING, arg_parser, namespace
 from datamodel_code_generator.format import (
+    DatetimeClassType,
     PythonVersion,
     black_find_project_root,
     is_supported_in_black,
@@ -159,7 +160,7 @@ class Config(BaseModel):
             target_python_version: PythonVersion = values['target_python_version']
             if target_python_version == target_python_version.PY_36:
                 raise Error(
-                    f'`--use-generic-container-types` can not be used with `--target-python_version` {target_python_version.PY_36.value}.\n'
+                    f'`--use-generic-container-types` can not be used with `--target-python-version` {target_python_version.PY_36.value}.\n'
                     ' The version will be not supported in a future version'
                 )
         return values
@@ -183,6 +184,31 @@ class Config(BaseModel):
             )  # pragma: no cover
         return values
 
+    @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:
+            raise Error(
+                f'`--keyword-only` requires `--target-python-version` {PythonVersion.PY_310.value} or higher.'
+            )
+        return values
+
+    @model_validator(mode='after')
+    def validate_output_datetime_class(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        datetime_class_type: Optional[DatetimeClassType] = values.get(
+            'output_datetime_class'
+        )
+        if (
+            datetime_class_type
+            and datetime_class_type is not DatetimeClassType.Datetime
+            and values.get('output_model_type') == DataModelType.DataclassesDataclass
+        ):
+            raise Error(
+                '`--output-datetime-class` only allows "datetime" for '
+                f'`--output-model-type` {DataModelType.DataclassesDataclass.value}'
+            )
+        return values
+
     # Pydantic 1.5.1 doesn't support each_item=True correctly
     @field_validator('http_headers', mode='before')
     def validate_http_headers(cls, value: Any) -> Optional[List[Tuple[str, str]]]:
@@ -313,6 +339,8 @@ class Config(BaseModel):
     treat_dot_as_module: bool = False
     use_exact_imports: bool = False
     union_mode: Optional[UnionMode] = None
+    output_datetime_class: Optional[DatetimeClassType] = None
+    keyword_only: bool = False
 
     def merge_args(self, args: Namespace) -> None:
         set_args = {
@@ -512,6 +540,8 @@ def main(args: Optional[Sequence[str]] = None) -> Exit:
             treat_dots_as_module=config.treat_dot_as_module,
             use_exact_imports=config.use_exact_imports,
             union_mode=config.union_mode,
+            output_datetime_class=config.output_datetime_class,
+            keyword_only=config.keyword_only,
         )
         return Exit.OK
     except InvalidClassNameError as e:

datamodel_code_generator/arguments.py

@@ -6,7 +6,7 @@ from operator import attrgetter
 from typing import TYPE_CHECKING
 
 from datamodel_code_generator import DataModelType, InputFileType, OpenAPIScope
-from datamodel_code_generator.format import PythonVersion
+from datamodel_code_generator.format import DatetimeClassType, PythonVersion
 from datamodel_code_generator.model.pydantic_v2 import UnionMode
 from datamodel_code_generator.parser import LiteralType
 from datamodel_code_generator.types import StrictTypes
@@ -150,6 +150,12 @@ model_options.add_argument(
     action='store_true',
     default=None,
 )
+model_options.add_argument(
+    '--keyword-only',
+    help='Defined models as keyword only (for example dataclass(kw_only=True)).',
+    action='store_true',
+    default=None,
+)
 model_options.add_argument(
     '--reuse-model',
     help='Reuse models on the field when a module has the model with the same content',
@@ -192,6 +198,13 @@ model_options.add_argument(
     action='store_true',
     default=False,
 )
+model_options.add_argument(
+    '--output-datetime-class',
+    help='Choose Datetime class between AwareDatetime, NaiveDatetime or datetime. '
+    'Each output model has its default mapping (for example pydantic: datetime, dataclass: str, ...)',
+    choices=[i.value for i in DatetimeClassType],
+    default=None,
+)
 
 # ======================================================================================
 # Typing options for generated models

datamodel_code_generator/format.py

@@ -17,6 +17,12 @@ except ImportError:  # pragma: no cover
     black.mode = None
 
 
+class DatetimeClassType(Enum):
+    Datetime = 'datetime'
+    Awaredatetime = 'AwareDatetime'
+    Naivedatetime = 'NaiveDatetime'
+
+
 class PythonVersion(Enum):
     PY_36 = '3.6'
     PY_37 = '3.7'
@@ -73,6 +79,10 @@ class PythonVersion(Enum):
     def has_typed_dict_non_required(self) -> bool:
         return self._is_py_311_or_later
 
+    @property
+    def has_kw_only_dataclass(self) -> bool:
+        return self._is_py_310_or_later
+
 
 if TYPE_CHECKING:
 

datamodel_code_generator/imports.py

@@ -117,9 +117,11 @@ IMPORT_DICT = Import.from_full_path('typing.Dict')
 IMPORT_DECIMAL = Import.from_full_path('decimal.Decimal')
 IMPORT_DATE = Import.from_full_path('datetime.date')
 IMPORT_DATETIME = Import.from_full_path('datetime.datetime')
+IMPORT_TIMEDELTA = Import.from_full_path('datetime.timedelta')
 IMPORT_PATH = Import.from_full_path('pathlib.Path')
 IMPORT_TIME = Import.from_full_path('datetime.time')
 IMPORT_UUID = Import.from_full_path('uuid.UUID')
 IMPORT_PENDULUM_DATE = Import.from_full_path('pendulum.Date')
 IMPORT_PENDULUM_DATETIME = Import.from_full_path('pendulum.DateTime')
+IMPORT_PENDULUM_DURATION = Import.from_full_path('pendulum.Duration')
 IMPORT_PENDULUM_TIME = Import.from_full_path('pendulum.Time')

datamodel_code_generator/model/__init__.py

@@ -6,7 +6,7 @@ from ..types import DataTypeManager as DataTypeManagerABC
 from .base import ConstraintsBase, DataModel, DataModelFieldBase
 
 if TYPE_CHECKING:
-    from .. import DataModelType, PythonVersion
+    from .. import DataModelType, DatetimeClassType, PythonVersion
 
 
 class DataModelSet(NamedTuple):
@@ -19,7 +19,9 @@ class DataModelSet(NamedTuple):
 
 
 def get_data_model_types(
-    data_model_type: DataModelType, target_python_version: PythonVersion
+    data_model_type: DataModelType,
+    target_python_version: PythonVersion,
+    target_datetime_class: DatetimeClassType,
 ) -> DataModelSet:
     from .. import DataModelType
     from . import dataclass, msgspec, pydantic, pydantic_v2, rootmodel, typed_dict
@@ -46,7 +48,7 @@ def get_data_model_types(
             data_model=dataclass.DataClass,
             root_model=rootmodel.RootModel,
             field_model=dataclass.DataModelField,
-            data_type_manager=DataTypeManager,
+            data_type_manager=dataclass.DataTypeManager,
             dump_resolve_reference_action=None,
         )
     elif data_model_type == DataModelType.TypingTypedDict:

datamodel_code_generator/model/base.py

@@ -293,7 +293,9 @@ class DataModel(TemplateBase, Nullable, ABC):
         description: Optional[str] = None,
         default: Any = UNDEFINED,
         nullable: bool = False,
+        keyword_only: bool = False,
     ) -> None:
+        self.keyword_only = keyword_only
         if not self.TEMPLATE_FILE_PATH:
             raise Exception('TEMPLATE_FILE_PATH is undefined')
 
@@ -452,6 +454,7 @@ class DataModel(TemplateBase, Nullable, ABC):
             base_class=self.base_class,
             methods=self.methods,
             description=self.description,
+            keyword_only=self.keyword_only,
             **self.extra_template_data,
         )
         return response

datamodel_code_generator/model/dataclass.py

@@ -1,13 +1,32 @@
 from pathlib import Path
-from typing import Any, ClassVar, DefaultDict, Dict, List, Optional, Set, Tuple
-
-from datamodel_code_generator.imports import Import
+from typing import (
+    Any,
+    ClassVar,
+    DefaultDict,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+)
+
+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_DATACLASS, IMPORT_FIELD
 from datamodel_code_generator.model.pydantic.base_model import Constraints
+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
+from datamodel_code_generator.types import DataType, StrictTypes, Types, chain_as_tuple
 
 
 def _has_field_assignment(field: DataModelFieldBase) -> bool:
@@ -36,6 +55,7 @@ class DataClass(DataModel):
         description: Optional[str] = None,
         default: Any = UNDEFINED,
         nullable: bool = False,
+        keyword_only: bool = False,
     ) -> None:
         super().__init__(
             reference=reference,
@@ -50,6 +70,7 @@ class DataClass(DataModel):
             description=description,
             default=default,
             nullable=nullable,
+            keyword_only=keyword_only,
         )
 
 
@@ -118,3 +139,43 @@ class DataModelField(DataModelFieldBase):
             f'{k}={v if k == "default_factory" else repr(v)}' for k, v in data.items()
         ]
         return f'field({", ".join(kwargs)})'
+
+
+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/model/enum.py

@@ -47,6 +47,7 @@ class Enum(DataModel):
         type_: Optional[Types] = None,
         default: Any = UNDEFINED,
         nullable: bool = False,
+        keyword_only: bool = False,
     ):
         super().__init__(
             reference=reference,
@@ -61,6 +62,7 @@ class Enum(DataModel):
             description=description,
             default=default,
             nullable=nullable,
+            keyword_only=keyword_only,
         )
 
         if not base_classes and type_:

datamodel_code_generator/model/msgspec.py

@@ -86,6 +86,7 @@ class Struct(DataModel):
         description: Optional[str] = None,
         default: Any = UNDEFINED,
         nullable: bool = False,
+        keyword_only: bool = False,
     ) -> None:
         super().__init__(
             reference=reference,
@@ -100,6 +101,7 @@ class Struct(DataModel):
             description=description,
             default=default,
             nullable=nullable,
+            keyword_only=keyword_only,
         )
 
 

datamodel_code_generator/model/pydantic/base_model.py

@@ -225,6 +225,7 @@ class BaseModelBase(DataModel, ABC):
         description: Optional[str] = None,
         default: Any = UNDEFINED,
         nullable: bool = False,
+        keyword_only: bool = False,
     ) -> None:
         methods: List[str] = [field.method for field in fields if field.method]
 
@@ -241,6 +242,7 @@ class BaseModelBase(DataModel, ABC):
             description=description,
             default=default,
             nullable=nullable,
+            keyword_only=keyword_only,
         )
 
     @cached_property
@@ -275,6 +277,7 @@ class BaseModel(BaseModelBase):
         description: Optional[str] = None,
         default: Any = UNDEFINED,
         nullable: bool = False,
+        keyword_only: bool = False,
     ) -> None:
         super().__init__(
             reference=reference,
@@ -288,6 +291,7 @@ class BaseModel(BaseModelBase):
             description=description,
             default=default,
             nullable=nullable,
+            keyword_only=keyword_only,
         )
         config_parameters: Dict[str, Any] = {}
 

datamodel_code_generator/model/pydantic/types.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from decimal import Decimal
 from typing import Any, ClassVar, Dict, Optional, Sequence, Set, Type
 
-from datamodel_code_generator.format import PythonVersion
+from datamodel_code_generator.format import DatetimeClassType, PythonVersion
 from datamodel_code_generator.imports import (
     IMPORT_ANY,
     IMPORT_DATE,
@@ -12,8 +12,10 @@ from datamodel_code_generator.imports import (
     IMPORT_PATH,
     IMPORT_PENDULUM_DATE,
     IMPORT_PENDULUM_DATETIME,
+    IMPORT_PENDULUM_DURATION,
     IMPORT_PENDULUM_TIME,
     IMPORT_TIME,
+    IMPORT_TIMEDELTA,
     IMPORT_UUID,
 )
 from datamodel_code_generator.model.pydantic.imports import (
@@ -57,6 +59,7 @@ def type_map_factory(
     strict_types: Sequence[StrictTypes],
     pattern_key: str,
     use_pendulum: bool,
+    target_datetime_class: DatetimeClassType,
 ) -> Dict[Types, DataType]:
     data_type_int = data_type(type='int')
     data_type_float = data_type(type='float')
@@ -75,6 +78,7 @@ def type_map_factory(
         Types.binary: data_type(type='bytes'),
         Types.date: data_type.from_import(IMPORT_DATE),
         Types.date_time: data_type.from_import(IMPORT_DATETIME),
+        Types.timedelta: data_type.from_import(IMPORT_TIMEDELTA),
         Types.path: data_type.from_import(IMPORT_PATH),
         Types.password: data_type.from_import(IMPORT_SECRET_STR),
         Types.email: data_type.from_import(IMPORT_EMAIL_STR),
@@ -108,6 +112,7 @@ def type_map_factory(
         result[Types.date] = data_type.from_import(IMPORT_PENDULUM_DATE)
         result[Types.date_time] = data_type.from_import(IMPORT_PENDULUM_DATETIME)
         result[Types.time] = data_type.from_import(IMPORT_PENDULUM_TIME)
+        result[Types.timedelta] = data_type.from_import(IMPORT_PENDULUM_DURATION)
 
     return result
 
@@ -158,6 +163,7 @@ class DataTypeManager(_DataTypeManager):
         use_non_positive_negative_number_constrained_types: bool = False,
         use_union_operator: bool = False,
         use_pendulum: bool = False,
+        target_datetime_class: Optional[DatetimeClassType] = None,
     ):
         super().__init__(
             python_version,
@@ -167,12 +173,14 @@ class DataTypeManager(_DataTypeManager):
             use_non_positive_negative_number_constrained_types,
             use_union_operator,
             use_pendulum,
+            target_datetime_class,
         )
 
         self.type_map: Dict[Types, DataType] = self.type_map_factory(
             self.data_type,
             strict_types=self.strict_types,
             pattern_key=self.PATTERN_KEY,
+            target_datetime_class=target_datetime_class,
         )
         self.strict_type_map: Dict[StrictTypes, DataType] = strict_type_map_factory(
             self.data_type,
@@ -196,8 +204,15 @@ class DataTypeManager(_DataTypeManager):
         data_type: Type[DataType],
         strict_types: Sequence[StrictTypes],
         pattern_key: str,
+        target_datetime_class: DatetimeClassType,
     ) -> Dict[Types, DataType]:
-        return type_map_factory(data_type, strict_types, pattern_key, self.use_pendulum)
+        return type_map_factory(
+            data_type,
+            strict_types,
+            pattern_key,
+            self.use_pendulum,
+            self.target_datetime_class,
+        )
 
     def transform_kwargs(
         self, kwargs: Dict[str, Any], filter_: Set[str]

datamodel_code_generator/model/pydantic_v2/base_model.py

@@ -183,6 +183,7 @@ class BaseModel(BaseModelBase):
         description: Optional[str] = None,
         default: Any = UNDEFINED,
         nullable: bool = False,
+        keyword_only: bool = False,
     ) -> None:
         super().__init__(
             reference=reference,
@@ -196,6 +197,7 @@ class BaseModel(BaseModelBase):
             description=description,
             default=default,
             nullable=nullable,
+            keyword_only=keyword_only,
         )
         config_parameters: Dict[str, Any] = {}
 

datamodel_code_generator/model/pydantic_v2/imports.py

@@ -2,3 +2,4 @@ from datamodel_code_generator.imports import Import
 
 IMPORT_CONFIG_DICT = Import.from_full_path('pydantic.ConfigDict')
 IMPORT_AWARE_DATETIME = Import.from_full_path('pydantic.AwareDatetime')
+IMPORT_NAIVE_DATETIME = Import.from_full_path('pydantic.NaiveDatetime')

datamodel_code_generator/model/pydantic_v2/types.py

@@ -1,10 +1,14 @@
 from __future__ import annotations
 
-from typing import ClassVar, Dict, Sequence, Type
+from typing import ClassVar, Dict, Optional, Sequence, Type
 
+from datamodel_code_generator.format import DatetimeClassType
 from datamodel_code_generator.model.pydantic import DataTypeManager as _DataTypeManager
 from datamodel_code_generator.model.pydantic.imports import IMPORT_CONSTR
-from datamodel_code_generator.model.pydantic_v2.imports import IMPORT_AWARE_DATETIME
+from datamodel_code_generator.model.pydantic_v2.imports import (
+    IMPORT_AWARE_DATETIME,
+    IMPORT_NAIVE_DATETIME,
+)
 from datamodel_code_generator.types import DataType, StrictTypes, Types
 
 
@@ -16,9 +20,12 @@ class DataTypeManager(_DataTypeManager):
         data_type: Type[DataType],
         strict_types: Sequence[StrictTypes],
         pattern_key: str,
+        target_datetime_class: Optional[DatetimeClassType] = None,
     ) -> Dict[Types, DataType]:
-        return {
-            **super().type_map_factory(data_type, strict_types, pattern_key),
+        result = {
+            **super().type_map_factory(
+                data_type, strict_types, pattern_key, target_datetime_class
+            ),
             Types.hostname: self.data_type.from_import(
                 IMPORT_CONSTR,
                 strict=StrictTypes.str in strict_types,
@@ -28,5 +35,9 @@ class DataTypeManager(_DataTypeManager):
                     **({'strict': True} if StrictTypes.str in strict_types else {}),
                 },
             ),
-            Types.date_time: data_type.from_import(IMPORT_AWARE_DATETIME),
         }
+        if target_datetime_class == DatetimeClassType.Awaredatetime:
+            result[Types.date_time] = data_type.from_import(IMPORT_AWARE_DATETIME)
+        if target_datetime_class == DatetimeClassType.Naivedatetime:
+            result[Types.date_time] = data_type.from_import(IMPORT_NAIVE_DATETIME)
+        return result

datamodel_code_generator/model/scalar.py

@@ -46,6 +46,7 @@ class DataTypeScalar(DataModel):
         description: Optional[str] = None,
         default: Any = UNDEFINED,
         nullable: bool = False,
+        keyword_only: bool = False,
     ):
         extra_template_data = extra_template_data or defaultdict(dict)
 
@@ -75,4 +76,5 @@ class DataTypeScalar(DataModel):
             description=description,
             default=default,
             nullable=nullable,
+            keyword_only=keyword_only,
         )

datamodel_code_generator/model/template/dataclass.jinja2

@@ -1,7 +1,7 @@
 {% for decorator in decorators -%}
 {{ decorator }}
 {% endfor -%}
-@dataclass
+@dataclass{%- if keyword_only -%}(kw_only=True){%- endif %}
 {%- if base_class %}
 class {{ class_name }}({{ base_class }}):
 {%- else %}

datamodel_code_generator/model/typed_dict.py

@@ -63,6 +63,7 @@ class TypedDict(DataModel):
         description: Optional[str] = None,
         default: Any = UNDEFINED,
         nullable: bool = False,
+        keyword_only: bool = False,
     ) -> None:
         super().__init__(
             reference=reference,
@@ -77,6 +78,7 @@ class TypedDict(DataModel):
             description=description,
             default=default,
             nullable=nullable,
+            keyword_only=keyword_only,
         )
 
     @property

datamodel_code_generator/model/types.py

@@ -1,14 +1,16 @@
 from typing import Any, Dict, Optional, Sequence, Type
 
-from datamodel_code_generator import PythonVersion
-from datamodel_code_generator.imports import IMPORT_ANY, IMPORT_DECIMAL
+from datamodel_code_generator import DatetimeClassType, PythonVersion
+from datamodel_code_generator.imports import (
+    IMPORT_ANY,
+    IMPORT_DECIMAL,
+    IMPORT_TIMEDELTA,
+)
 from datamodel_code_generator.types import DataType, StrictTypes, Types
 from datamodel_code_generator.types import DataTypeManager as _DataTypeManager
 
 
-def type_map_factory(
-    data_type: Type[DataType],
-) -> Dict[Types, DataType]:
+def type_map_factory(data_type: Type[DataType]) -> Dict[Types, DataType]:
     data_type_int = data_type(type='int')
     data_type_float = data_type(type='float')
     data_type_str = data_type(type='str')
@@ -27,6 +29,7 @@ def type_map_factory(
         Types.binary: data_type(type='bytes'),
         Types.date: data_type_str,
         Types.date_time: data_type_str,
+        Types.timedelta: data_type.from_import(IMPORT_TIMEDELTA),
         Types.password: data_type_str,
         Types.email: data_type_str,
         Types.uuid: data_type_str,
@@ -59,6 +62,7 @@ class DataTypeManager(_DataTypeManager):
         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,
@@ -68,11 +72,10 @@ class DataTypeManager(_DataTypeManager):
             use_non_positive_negative_number_constrained_types,
             use_union_operator,
             use_pendulum,
+            target_datetime_class,
         )
 
-        self.type_map: Dict[Types, DataType] = type_map_factory(
-            self.data_type,
-        )
+        self.type_map: Dict[Types, DataType] = type_map_factory(self.data_type)
 
     def get_data_type(
         self,

datamodel_code_generator/model/union.py

@@ -32,6 +32,7 @@ class DataTypeUnion(DataModel):
         description: Optional[str] = None,
         default: Any = UNDEFINED,
         nullable: bool = False,
+        keyword_only: bool = False,
     ):
         super().__init__(
             reference=reference,
@@ -46,4 +47,5 @@ class DataTypeUnion(DataModel):
             description=description,
             default=default,
             nullable=nullable,
+            keyword_only=keyword_only,
         )

datamodel_code_generator/parser/base.py

@@ -26,7 +26,11 @@ from urllib.parse import ParseResult
 
 from pydantic import BaseModel
 
-from datamodel_code_generator.format import CodeFormatter, PythonVersion
+from datamodel_code_generator.format import (
+    CodeFormatter,
+    DatetimeClassType,
+    PythonVersion,
+)
 from datamodel_code_generator.imports import (
     IMPORT_ANNOTATIONS,
     IMPORT_LITERAL,
@@ -34,6 +38,7 @@ from datamodel_code_generator.imports import (
     Import,
     Imports,
 )
+from datamodel_code_generator.model import dataclass as dataclass_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 (
@@ -239,10 +244,11 @@ def relative(current_module: str, reference: str) -> Tuple[str, str]:
 
 
 def exact_import(from_: str, import_: str, short_name: str) -> Tuple[str, str]:
-    if from_ == '.':
+    if from_ == len(from_) * '.':
         # Prevents "from . import foo" becoming "from ..foo import Foo"
+        # or "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
     return f'{from_}.{import_}', short_name
 
 
@@ -403,7 +409,10 @@ class Parser(ABC):
         treat_dots_as_module: bool = False,
         use_exact_imports: bool = False,
         default_field_extras: Optional[Dict[str, Any]] = None,
+        target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
+        keyword_only: bool = False,
     ) -> None:
+        self.keyword_only = keyword_only
         self.data_type_manager: DataTypeManager = data_type_manager_type(
             python_version=target_python_version,
             use_standard_collections=use_standard_collections,
@@ -411,6 +420,7 @@ class Parser(ABC):
             strict_types=strict_types,
             use_union_operator=use_union_operator,
             use_pendulum=use_pendulum,
+            target_datetime_class=target_datetime_class,
         )
         self.data_model_type: Type[DataModel] = data_model_type
         self.data_model_root_type: Type[DataModel] = data_model_root_type
@@ -795,7 +805,11 @@ class Parser(ABC):
                     discriminator_model = data_type.reference.source
                     if not isinstance(  # pragma: no cover
                         discriminator_model,
-                        (pydantic_model.BaseModel, pydantic_model_v2.BaseModel),
+                        (
+                            pydantic_model.BaseModel,
+                            pydantic_model_v2.BaseModel,
+                            dataclass_model.DataClass,
+                        ),
                     ):
                         continue  # pragma: no cover
                     type_names = []
@@ -1370,8 +1384,8 @@ class Parser(ABC):
             )
             self.__set_default_enum_member(models)
             self.__sort_models(models, imports)
-            self.__set_one_literal_on_default(models)
             self.__apply_discriminator_type(models, imports)
+            self.__set_one_literal_on_default(models)
 
             processed_models.append(
                 Processed(module, models, init, imports, scoped_model_resolver)

datamodel_code_generator/parser/graphql.py

@@ -46,6 +46,7 @@ except ImportError:  # pragma: no cover
         "Please run `$pip install 'datamodel-code-generator[graphql]`' to generate data-model from a GraphQL schema."
     )
 
+from datamodel_code_generator.format import DatetimeClassType
 
 graphql_resolver = graphql.type.introspection.TypeResolvers()
 
@@ -157,6 +158,8 @@ class GraphQLParser(Parser):
         treat_dots_as_module: bool = False,
         use_exact_imports: bool = False,
         default_field_extras: Optional[Dict[str, Any]] = None,
+        target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
+        keyword_only: bool = False,
     ) -> None:
         super().__init__(
             source=source,
@@ -227,6 +230,8 @@ class GraphQLParser(Parser):
             treat_dots_as_module=treat_dots_as_module,
             use_exact_imports=use_exact_imports,
             default_field_extras=default_field_extras,
+            target_datetime_class=target_datetime_class,
+            keyword_only=keyword_only,
         )
 
         self.data_model_scalar_type = data_model_scalar_type
@@ -460,6 +465,7 @@ class GraphQLParser(Parser):
             extra_template_data=self.extra_template_data,
             path=self.current_source_path,
             description=obj.description,
+            keyword_only=self.keyword_only,
         )
         self.results.append(data_model_type)
 

datamodel_code_generator/parser/jsonschema.py

@@ -71,6 +71,8 @@ from datamodel_code_generator.util import (
 if PYDANTIC_V2:
     from pydantic import ConfigDict
 
+from datamodel_code_generator.format import DatetimeClassType
+
 
 def get_model_by_path(
     schema: Union[Dict[str, Any], List[Any]], keys: Union[List[str], List[int]]
@@ -116,6 +118,7 @@ json_schema_data_formats: Dict[str, Dict[str, Types]] = {
         'binary': Types.binary,
         'date': Types.date,
         'date-time': Types.date_time,
+        'duration': Types.timedelta,
         'time': Types.time,
         'password': Types.password,
         'path': Types.path,
@@ -443,6 +446,8 @@ class JsonSchemaParser(Parser):
         treat_dots_as_module: bool = False,
         use_exact_imports: bool = False,
         default_field_extras: Optional[Dict[str, Any]] = None,
+        target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
+        keyword_only: bool = False,
     ) -> None:
         super().__init__(
             source=source,
@@ -513,6 +518,8 @@ class JsonSchemaParser(Parser):
             treat_dots_as_module=treat_dots_as_module,
             use_exact_imports=use_exact_imports,
             default_field_extras=default_field_extras,
+            target_datetime_class=target_datetime_class,
+            keyword_only=keyword_only,
         )
 
         self.remote_object_cache: DefaultPutDict[str, Dict[str, Any]] = DefaultPutDict()
@@ -803,6 +810,7 @@ class JsonSchemaParser(Parser):
             extra_template_data=self.extra_template_data,
             path=self.current_source_path,
             description=obj.description if self.use_schema_description else None,
+            keyword_only=self.keyword_only,
         )
         self.results.append(data_model_type)
 
@@ -1046,6 +1054,7 @@ class JsonSchemaParser(Parser):
             path=self.current_source_path,
             description=obj.description if self.use_schema_description else None,
             nullable=obj.type_has_null,
+            keyword_only=self.keyword_only,
         )
         self.results.append(data_model_type)
         return self.data_type(reference=reference)

datamodel_code_generator/parser/openapi.py

@@ -36,6 +36,7 @@ from datamodel_code_generator import (
     load_yaml,
     snooper_to_methods,
 )
+from datamodel_code_generator.format import DatetimeClassType
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model import pydantic as pydantic_model
 from datamodel_code_generator.parser.base import get_special_path
@@ -225,6 +226,8 @@ class OpenAPIParser(JsonSchemaParser):
         treat_dots_as_module: bool = False,
         use_exact_imports: bool = False,
         default_field_extras: Optional[Dict[str, Any]] = None,
+        target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
+        keyword_only: bool = False,
     ):
         super().__init__(
             source=source,
@@ -295,6 +298,8 @@ class OpenAPIParser(JsonSchemaParser):
             treat_dots_as_module=treat_dots_as_module,
             use_exact_imports=use_exact_imports,
             default_field_extras=default_field_extras,
+            target_datetime_class=target_datetime_class,
+            keyword_only=keyword_only,
         )
         self.open_api_scopes: List[OpenAPIScope] = openapi_scopes or [
             OpenAPIScope.Schemas
@@ -508,6 +513,7 @@ class OpenAPIParser(JsonSchemaParser):
                     fields=fields,
                     reference=reference,
                     custom_base_class=self.base_class,
+                    keyword_only=self.keyword_only,
                 )
             )
 

datamodel_code_generator/types.py

@@ -27,7 +27,7 @@ import pydantic
 from packaging import version
 from pydantic import StrictBool, StrictInt, StrictStr, create_model
 
-from datamodel_code_generator.format import PythonVersion
+from datamodel_code_generator.format import DatetimeClassType, PythonVersion
 from datamodel_code_generator.imports import (
     IMPORT_ABC_MAPPING,
     IMPORT_ABC_SEQUENCE,
@@ -542,6 +542,7 @@ class Types(Enum):
     binary = auto()
     date = auto()
     date_time = auto()
+    timedelta = auto()
     password = auto()
     path = auto()
     email = auto()
@@ -574,6 +575,7 @@ class DataTypeManager(ABC):
         use_non_positive_negative_number_constrained_types: bool = False,
         use_union_operator: bool = False,
         use_pendulum: bool = False,
+        target_datetime_class: Optional[DatetimeClassType] = None,
     ) -> None:
         self.python_version = python_version
         self.use_standard_collections: bool = use_standard_collections
@@ -584,6 +586,7 @@ class DataTypeManager(ABC):
         )
         self.use_union_operator: bool = use_union_operator
         self.use_pendulum: bool = use_pendulum
+        self.target_datetime_class: DatetimeClassType = target_datetime_class
 
         if (
             use_generic_container_types and python_version == PythonVersion.PY_36

datamodel_code_generator/version.py

@@ -1 +1 @@
-version: str = '0.26.0'
+version: str = '0.26.2'

{datamodel_code_generator-0.26.0.dist-info → datamodel_code_generator-0.26.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datamodel-code-generator
-Version: 0.26.0
+Version: 0.26.2
 Summary: Datamodel Code Generator
 Home-page: https://github.com/koxudaxi/datamodel-code-generator
 License: MIT
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Provides-Extra: debug
 Provides-Extra: graphql
@@ -494,6 +495,12 @@ Model customization:
   --enable-version-header
                         Enable package version on file headers
   --keep-model-order    Keep generated models'' order
+  --keyword-only        Defined models as keyword only (for example
+                        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"
   --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.0.dist-info → datamodel_code_generator-0.26.2.dist-info}/RECORD

@@ -1,35 +1,35 @@
-datamodel_code_generator/__init__.py,sha256=HjG9D_8lr44liXSIOEsYYj3xgn-jEz_2iK2uwc0dJao,18517
-datamodel_code_generator/__main__.py,sha256=MWBehWH8aY4zqSOUUwuZ4fUBOlnuJ16ZOna4NL28HFo,19746
-datamodel_code_generator/arguments.py,sha256=DCiFpkhqvq5OvHNgABCtNtw6eckp0U7U5fYT1e8NCHM,15558
-datamodel_code_generator/format.py,sha256=keAejlYYIBdfUNbkr-IFMfro0on9ZzaqlVulNgpnKco,8653
+datamodel_code_generator/__init__.py,sha256=iNtaR-iP5McYCDelHc_67DiuKlx-EU7j9rLbCJnYHII,18757
+datamodel_code_generator/__main__.py,sha256=oWeH6qccmFP5DJJWqCGmtLCXCExizYbro6hUb6Q4uGk,21085
+datamodel_code_generator/arguments.py,sha256=Q3LxZut72yqazXGjEG4CN1w4WFvpmldwOrgRhi_gL2o,16070
+datamodel_code_generator/format.py,sha256=kA2rESd51uCDGAzTCz4wX24WitU7X1Zi68v4a_59wmc,8884
 datamodel_code_generator/http.py,sha256=CwLVnXO4_W_fWKJsHnJp6Q_3GuF3qjCjeAe48Ihawrs,714
-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=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/imports.py,sha256=RagA3hne8OtrbZwDA7TaORQll6tKIzket-A6ShOWf8s,5728
+datamodel_code_generator/model/__init__.py,sha256=-5-3m6xlNia1ROePCqmV2lvvvwyzgFS9zFGUzqQzQf8,3171
+datamodel_code_generator/model/base.py,sha256=KMrVsxoQEeKhA5akGLxM-nUzHINM0GTt2t6HTF9SrKQ,14180
+datamodel_code_generator/model/dataclass.py,sha256=Ebn48PRvCOCcyKhxYxgYBbRcpIvXko-VomZ6N8gKrLA,5871
+datamodel_code_generator/model/enum.py,sha256=HTFMCNoHmJRHUoNqQCat3kLbtdmSVX666BubN3bcF1I,3413
 datamodel_code_generator/model/imports.py,sha256=9-0bd-DvZRjZkWMsmw-gykL8fzTd6M-vQEqS7Rm_ty4,725
-datamodel_code_generator/model/msgspec.py,sha256=J4U8aroVzBdMkv8CfuOf9mV3X7k83lom-CW4ATpbCfk,9093
+datamodel_code_generator/model/msgspec.py,sha256=GONU6gRJ84piJpNDrmU9gTg_n_eY7Sd5KeCUQJN5IaE,9168
 datamodel_code_generator/model/pydantic/__init__.py,sha256=AYMjDCtnV4vweYqe1asTRCYdOo8IGLBhd8pEdxyY8ok,1372
-datamodel_code_generator/model/pydantic/base_model.py,sha256=Y2GSlcLBvQh8hrlwGE3rGLTsQLKxERBts0so5BcUP6Y,11970
+datamodel_code_generator/model/pydantic/base_model.py,sha256=sTxrFItp7wpL0OxBYOGLyyjWWrzGDuV_pFeHPsSQ4Gs,12120
 datamodel_code_generator/model/pydantic/custom_root_type.py,sha256=XOeJqzUEAYE21C3hPAnRIz9iDWIjZvUOWDc9MCrpdvw,299
 datamodel_code_generator/model/pydantic/dataclass.py,sha256=sbqTmutl8Fjf1pYngfdv0NMXt904QcTRpHqmZy6GUiQ,424
 datamodel_code_generator/model/pydantic/imports.py,sha256=2nSLYwphBUMQEa0PTSNwoLjEBslu02EQb6BdZ-S51yk,2189
-datamodel_code_generator/model/pydantic/types.py,sha256=2ghckIyBX-QmFT1GAAjKuCLyD5hjpNqmRftOlgcS5Fo,13034
+datamodel_code_generator/model/pydantic/types.py,sha256=xtkdfQc295ACRvsSig0Zo-mxCw8Xdfu2VXeDbLF_l0Y,13607
 datamodel_code_generator/model/pydantic_v2/__init__.py,sha256=4CS-uI5_4xnvxBKl-Ht1a4E_4fIsfZ8T4jdst0cbZDk,975
-datamodel_code_generator/model/pydantic_v2/base_model.py,sha256=kObU_n-RN7RSR7lfiH2oxjqGD8cALPxi24AHlFdFEgE,7958
-datamodel_code_generator/model/pydantic_v2/imports.py,sha256=Q6XC6iE5v4LJvQ2DOXDGFtR-FnGPsaZ56KiiTiF2bIE,191
+datamodel_code_generator/model/pydantic_v2/base_model.py,sha256=JHUirMIITztUFtvL1vc_tkE0tRhum3f-JNydmVuzngs,8033
+datamodel_code_generator/model/pydantic_v2/imports.py,sha256=n0yWg5QGDDzOseN35RJFlEbmV6oKMLQ8Kju1w4N6D08,263
 datamodel_code_generator/model/pydantic_v2/root_model.py,sha256=iApUz1uGe4hHV8RyOK8rGjaEJcnqTJZqo-0uSfyVMGc,884
-datamodel_code_generator/model/pydantic_v2/types.py,sha256=6KAJXO_SGs5bc8GQScCpowgqjaSmrn9W9iewpWIHack,1440
+datamodel_code_generator/model/pydantic_v2/types.py,sha256=JV2m0TOPbh-1oHpN_W12KKuNf19RI-V2oehAUJtDIn4,1921
 datamodel_code_generator/model/rootmodel.py,sha256=8bW7emVQtDGe2iUAmqtlQb607LvTRL0TBSP66pIeNzY,202
-datamodel_code_generator/model/scalar.py,sha256=d4vqDW9OcvPR1I0lrlss2wDprWbUt9kPv767VYZi_Ks,2521
+datamodel_code_generator/model/scalar.py,sha256=md13JdHahWqjuASbivhywvy4MQ8sZhCAaClhEvWrY3M,2596
 datamodel_code_generator/model/template/Enum.jinja2,sha256=k9lB8iQUsB94bPi8e3xJEd0AGk2ciWL-pSZuGY5kNPQ,378
 datamodel_code_generator/model/template/Scalar.jinja2,sha256=Ss22-mYG3Vez-pbqmW2zFzwxGVhXkbQcAVTMV7POpg8,104
 datamodel_code_generator/model/template/TypedDict.jinja2,sha256=J_Pe_CiuvTOb-EUCExXPaeTEFzn2keyrKB0wglZ8HgA,135
 datamodel_code_generator/model/template/TypedDictClass.jinja2,sha256=URwp5__WyR8G21Hoyc17aMzoast-NppXnXe19VFi5wQ,377
 datamodel_code_generator/model/template/TypedDictFunction.jinja2,sha256=KjSij5_w4ow4a12SR3orYOndmXGkIvJBBUN735bQ6G0,321
 datamodel_code_generator/model/template/Union.jinja2,sha256=sq7o--2ESUSfIL4kCfgnr5ZXPFa_VeioqbATTY-N-5I,258
-datamodel_code_generator/model/template/dataclass.jinja2,sha256=U-zwO9xoClVcNmNCDBnvZQo0_xcRWsPYh2QfsNMyUsQ,816
+datamodel_code_generator/model/template/dataclass.jinja2,sha256=wRSy2g11Dr1GN9YUl13OZt2xg37bQyFwKn2wEsQIndE,865
 datamodel_code_generator/model/template/msgspec.jinja2,sha256=DVYCuXV5VpOx-8xiDsaqKwBzDuGAmMuD3dgWCM6-o4o,1070
 datamodel_code_generator/model/template/pydantic/BaseModel.jinja2,sha256=sYZa-47YAXqZrd5cYKVnPrsbDvLkHEJOUd7M0nAosP8,1084
 datamodel_code_generator/model/template/pydantic/BaseModel_root.jinja2,sha256=WDdTXYNTrkIw-B4OvPVxOaETTknLs0zdNuq_iDQ2Bcw,1000
@@ -39,22 +39,22 @@ datamodel_code_generator/model/template/pydantic_v2/BaseModel.jinja2,sha256=XdSC
 datamodel_code_generator/model/template/pydantic_v2/ConfigDict.jinja2,sha256=xHvBYrh__32O1xRCSl6_u5zbyYIjB8a5k8fZiTo0spY,149
 datamodel_code_generator/model/template/pydantic_v2/RootModel.jinja2,sha256=XQBlML7Hm5hN6_AExENNvVc_yxNWijcIfTTbbmegCpE,1223
 datamodel_code_generator/model/template/root.jinja2,sha256=3OTtibxLcGA-FMdR0QDCJUJQgf_kRW0OafeCTPFSFFo,162
-datamodel_code_generator/model/typed_dict.py,sha256=pzUaKLaVDF5rfxAaR1m4FqnhR00eE6AIP30oGTj67fY,4717
-datamodel_code_generator/model/types.py,sha256=7YQqPc-_yf5LhrLomB4msyOB_1cn0kKxfDHmGfVvDmA,2953
-datamodel_code_generator/model/union.py,sha256=loaVWQi-UHkV4gLfF2JhxLcgZRMsejaoJzGvjTlp_bo,1716
+datamodel_code_generator/model/typed_dict.py,sha256=W1r3NRy8uFkYe3YVnjL9PAGZdGyoSDcd-Otq7cxFDMM,4792
+datamodel_code_generator/model/types.py,sha256=T3Xxa7MToHXIH1zXHT1P6PzE49aah0IhnwkCbYVc79c,3157
+datamodel_code_generator/model/union.py,sha256=4LT5E46c2OH1dvQmvRWM7mX1Pziu_oWBHwXsGsylUbY,1791
 datamodel_code_generator/parser/__init__.py,sha256=zHbw6RPlJC0SAQjb-XyVlyZhcOu5PfYgPidy6jlUM8M,793
-datamodel_code_generator/parser/base.py,sha256=L45svycaIX4XLMqaCl3yameLmusLXw0Exrve-1Xydb4,59825
-datamodel_code_generator/parser/graphql.py,sha256=LmPQZuu7VYQ3JBD6RUCqDQNlSZuqIZSwFcbZouo-4qc,22037
-datamodel_code_generator/parser/jsonschema.py,sha256=rVKSw5zg7MtQs-gTwhsmgHGJ5JyQGQqPhBzBTM-zdnI,70222
-datamodel_code_generator/parser/openapi.py,sha256=mawqfJeOqDvkX1_63uqRhLC1EaYR8QkAyZ93MneeMK8,25930
+datamodel_code_generator/parser/base.py,sha256=mHnU_EJbbChqL4JrmS_MluWNfGKDBdR2PTJy_xz4YZs,60371
+datamodel_code_generator/parser/graphql.py,sha256=QpLHwyCw5F51w6_Iui_cL1cAblQ74ZrRx1vfzYh0Uo0,22354
+datamodel_code_generator/parser/jsonschema.py,sha256=L_QxO4lG6lzHbcVl33ImEQP6mNlZWUH3ootPMrtmHQI,70621
+datamodel_code_generator/parser/openapi.py,sha256=ENpjBKcqZyjcxgVfLKMbI5sDWfQufY1JmPXzir_IwCE,26255
 datamodel_code_generator/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datamodel_code_generator/pydantic_patch.py,sha256=5UKotLqor9HixzXk463CUevyCcH2zmQljMAPRyTOxiM,570
 datamodel_code_generator/reference.py,sha256=EoalUNUP5us31bfMrHDa1iiKqxL8gHrpZKY_IxgZrOg,26347
-datamodel_code_generator/types.py,sha256=lVKp5TsW-8DK81jQMGUqEANr8DcI2kjdqA1VciITDAI,19631
+datamodel_code_generator/types.py,sha256=Mtp-owOLiNlbbXU9tTFJH0MBFP3UYyFLL4jENdDD6es,19818
 datamodel_code_generator/util.py,sha256=OmYaVP0z0fGPnvmZQx63qmdMwFnMAIVHfTwSkExpoKk,2829
-datamodel_code_generator/version.py,sha256=I58_7Ue2SKeM60Nu76Yg9NVQ2egVERIo4F3HJGgMRSo,24
-datamodel_code_generator-0.26.0.dist-info/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
-datamodel_code_generator-0.26.0.dist-info/METADATA,sha256=zmlwGEAR-LflJhbkg2a3hgIK-LrrDytfIUX15N9G9VA,24317
-datamodel_code_generator-0.26.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-datamodel_code_generator-0.26.0.dist-info/entry_points.txt,sha256=bykbUWqOCiKfxJPGe8jpNqTqD1NG7uyRmozdnwzu7rk,76
-datamodel_code_generator-0.26.0.dist-info/RECORD,,
+datamodel_code_generator/version.py,sha256=2wxCCX8dkrhCy1rddbMrBMdf8znpK_gbbznigtdWVUk,24
+datamodel_code_generator-0.26.2.dist-info/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
+datamodel_code_generator-0.26.2.dist-info/METADATA,sha256=Ejj598KgHsENHFlQDdWl07onYpZG1ge38ucnRLqWZRY,24793
+datamodel_code_generator-0.26.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+datamodel_code_generator-0.26.2.dist-info/entry_points.txt,sha256=bykbUWqOCiKfxJPGe8jpNqTqD1NG7uyRmozdnwzu7rk,76
+datamodel_code_generator-0.26.2.dist-info/RECORD,,

{datamodel_code_generator-0.26.0.dist-info → datamodel_code_generator-0.26.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 1.9.1
 Root-Is-Purelib: true
 Tag: py3-none-any