datamodel-code-generator 0.21.3__tar.gz → 0.21.4__tar.gz

{datamodel_code_generator-0.21.3 → datamodel_code_generator-0.21.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datamodel-code-generator
-Version: 0.21.3
+Version: 0.21.4
 Summary: Datamodel Code Generator
 Home-page: https://github.com/koxudaxi/datamodel-code-generator
 License: MIT
@@ -26,7 +26,7 @@ Requires-Dist: httpx ; extra == "http"
 Requires-Dist: inflect (>=4.1.0,<6.0)
 Requires-Dist: isort (>=4.3.21,<6.0)
 Requires-Dist: jinja2 (>=2.10.1,<4.0)
-Requires-Dist: openapi-spec-validator (>=0.2.8,<=0.5.2)
+Requires-Dist: openapi-spec-validator (>=0.2.8,<=0.5.7)
 Requires-Dist: packaging
 Requires-Dist: prance (>=0.18.2)
 Requires-Dist: pydantic[email] (>=1.10.0,<3.0) ; python_version >= "3.11" and python_version < "4.0"

{datamodel_code_generator-0.21.3 → datamodel_code_generator-0.21.4}/datamodel_code_generator/__main__.py

@@ -36,8 +36,10 @@ import black
 import toml
 from pydantic import BaseModel
 
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
 from datamodel_code_generator import (
-    DEFAULT_BASE_CLASS,
     DataModelType,
     Error,
     InputFileType,
@@ -470,9 +472,6 @@ class Config(BaseModel):
         def __getitem__(self, item: str) -> Any:
             return self.get(item)
 
-        def __setitem__(self, key: str, value: Any) -> None:
-            setattr(self, key, value)
-
         if TYPE_CHECKING:
 
             @classmethod
@@ -580,23 +579,21 @@ class Config(BaseModel):
             return [validate_each_item(each_item) for each_item in value]
         return value  # pragma: no cover
 
-    @model_validator(mode='after')
-    def validate_root(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        values = cls._validate_use_annotated(values)
-        return cls._validate_base_class(values)
-
-    @classmethod
-    def _validate_use_annotated(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if values.get('use_annotated'):
-            values['field_constraints'] = True
-        return values
+    if PYDANTIC_V2:
 
-    @classmethod
-    def _validate_base_class(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if 'base_class' not in values and 'output_model_type' in values:
-            if values['output_model_type'] != DataModelType.PydanticBaseModel.value:
-                values['base_class'] = ''
-        return values
+        @model_validator(mode='after')  # type: ignore
+        def validate_root(self: Self) -> Self:
+            if self.use_annotated:
+                self.field_constraints = True
+            return self
+
+    else:
+
+        @model_validator(mode='after')
+        def validate_root(cls, values: Any) -> Any:
+            if values.get('use_annotated'):
+                values['field_constraints'] = True
+            return values
 
     input: Optional[Union[Path, str]] = None
     input_file_type: InputFileType = InputFileType.Auto
@@ -605,7 +602,7 @@ class Config(BaseModel):
     debug: bool = False
     disable_warnings: bool = False
     target_python_version: PythonVersion = PythonVersion.PY_37
-    base_class: str = DEFAULT_BASE_CLASS
+    base_class: str = ''
     custom_template_dir: Optional[Path] = None
     extra_template_data: Optional[TextIOBase] = None
     validation: bool = False
@@ -666,9 +663,11 @@ class Config(BaseModel):
             for f in self.get_fields()
             if getattr(args, f) is not None
         }
-        set_args = self._validate_use_annotated(set_args)
-        set_args = self._validate_base_class(set_args)
-        parsed_args = self.parse_obj(set_args)
+
+        if set_args.get('use_annotated'):
+            set_args['field_constraints'] = True
+
+        parsed_args = Config.parse_obj(set_args)
         for field_name in set_args:
             setattr(self, field_name, getattr(parsed_args, field_name))
 

{datamodel_code_generator-0.21.3 → datamodel_code_generator-0.21.4}/datamodel_code_generator/model/base.py

@@ -92,11 +92,15 @@ class DataModelFieldBase(_BaseModel):
             super().__init__(**data)
             if self.data_type.reference or self.data_type.data_types:
                 self.data_type.parent = self
-            if 'const' in self.extras:
-                self.default = self.extras['const']
-                self.const = True
-                self.required = False
-                self.nullable = False
+            self.process_const()
+
+    def process_const(self) -> None:
+        if 'const' not in self.extras:
+            return None
+        self.default = self.extras['const']
+        self.const = True
+        self.required = False
+        self.nullable = False
 
     @property
     def type_hint(self) -> str:

{datamodel_code_generator-0.21.3 → datamodel_code_generator-0.21.4}/datamodel_code_generator/model/pydantic/types.py

@@ -44,7 +44,7 @@ from datamodel_code_generator.model.pydantic.imports import (
     IMPORT_UUID4,
     IMPORT_UUID5,
 )
-from datamodel_code_generator.types import DataType, StrictTypes, Types
+from datamodel_code_generator.types import DataType, StrictTypes, Types, UnionIntFloat
 from datamodel_code_generator.types import DataTypeManager as _DataTypeManager
 
 
@@ -261,7 +261,10 @@ class DataTypeManager(_DataTypeManager):
         if data_type_kwargs:
             return self.data_type.from_import(
                 IMPORT_CONDECIMAL,
-                kwargs={k: Decimal(v) for k, v in data_type_kwargs.items()},
+                kwargs={
+                    k: Decimal(str(v) if isinstance(v, UnionIntFloat) else v)
+                    for k, v in data_type_kwargs.items()
+                },
             )
         return self.type_map[types]
 

{datamodel_code_generator-0.21.3 → datamodel_code_generator-0.21.4}/datamodel_code_generator/model/pydantic_v2/base_model.py

@@ -61,6 +61,17 @@ class DataModelField(DataModelFieldV1):
     constraints: Optional[Constraints] = None
     _PARSE_METHOD: ClassVar[str] = 'model_validate'
 
+    def process_const(self) -> None:
+        if 'const' not in self.extras:
+            return None
+        self.const = True
+        self.nullable = False
+        const = self.extras['const']
+        if self.data_type.type == 'str' and isinstance(
+            const, str
+        ):  # pragma: no cover # Literal supports only str
+            self.data_type = self.data_type.__class__(literals=[const])
+
     def _process_data_in_str(self, data: Dict[str, Any]) -> None:
         if self.const:
             # const is removed in pydantic 2.0

datamodel_code_generator-0.21.4/datamodel_code_generator/model/pydantic_v2/root_model.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from typing import Any, ClassVar
+
+from datamodel_code_generator.model.pydantic_v2.base_model import BaseModel
+
+
+class RootModel(BaseModel):
+    TEMPLATE_FILE_PATH: ClassVar[str] = 'pydantic_v2/RootModel.jinja2'
+    BASE_CLASS: ClassVar[str] = 'pydantic.RootModel'
+
+    def __init__(
+        self,
+        **kwargs: Any,
+    ) -> None:
+        # Remove custom_base_class for Pydantic V2 models; behaviour is different from Pydantic V1 as it will not
+        # be treated as a root model. custom_base_class cannot both implement BaseModel and RootModel!
+        if 'custom_base_class' in kwargs:
+            kwargs.pop('custom_base_class')
+
+        super().__init__(**kwargs)

{datamodel_code_generator-0.21.3 → datamodel_code_generator-0.21.4}/datamodel_code_generator/parser/base.py

@@ -28,7 +28,6 @@ from pydantic import BaseModel
 from datamodel_code_generator.format import CodeFormatter, PythonVersion
 from datamodel_code_generator.imports import IMPORT_ANNOTATIONS, Import, Imports
 from datamodel_code_generator.model import pydantic as pydantic_model
-from datamodel_code_generator.model import pydantic_v2 as pydantic_v2_model
 from datamodel_code_generator.model.base import (
     ALL_MODEL,
     UNDEFINED,
@@ -38,6 +37,7 @@ from datamodel_code_generator.model.base import (
     DataModelFieldBase,
 )
 from datamodel_code_generator.model.enum import Enum, Member
+from datamodel_code_generator.model.pydantic_v2 import RootModel
 from datamodel_code_generator.parser import DefaultPutDict, LiteralType
 from datamodel_code_generator.reference import ModelResolver, Reference
 from datamodel_code_generator.types import DataType, DataTypeManager, StrictTypes
@@ -723,10 +723,7 @@ class Parser(ABC):
     def __replace_unique_list_to_set(self, models: List[DataModel]) -> None:
         for model in models:
             for model_field in model.fields:
-                if not (
-                    isinstance(model_field, pydantic_v2_model.DataModelField)
-                    or self.use_unique_items_as_set
-                ):
+                if not self.use_unique_items_as_set:
                     continue
 
                 if not (
@@ -797,10 +794,11 @@ class Parser(ABC):
             models.remove(duplicate)
 
     def __collapse_root_models(
-        self, models: List[DataModel], unused_models: List[DataModel]
+        self, models: List[DataModel], unused_models: List[DataModel], imports: Imports
     ) -> None:
         if not self.collapse_root_models:
             return None
+        unused_model_count = len(unused_models)
         for model in models:
             for model_field in model.fields:
                 for data_type in model_field.data_type.all_data_types:
@@ -834,6 +832,8 @@ class Parser(ABC):
                         model_field.extras = dict(
                             root_type_field.extras, **model_field.extras
                         )
+                        model_field.process_const()
+
                         if self.field_constraints:
                             if isinstance(
                                 root_type_field.constraints, ConstraintsBase
@@ -876,6 +876,17 @@ class Parser(ABC):
                     if not root_type_model.reference.children:
                         unused_models.append(root_type_model)
 
+        if self.data_model_root_type == RootModel and unused_model_count != len(
+            unused_models
+        ):
+            if {m for m in models if isinstance(m, RootModel)} - {  # pragma: no cover
+                m for m in unused_models if isinstance(m, RootModel)
+            }:
+                return None  # pragma: no cover
+
+            if 'RootModel' in imports['pydantic']:  # pragma: no cover
+                imports['pydantic'].remove('RootModel')
+
     def __set_default_enum_member(
         self,
         models: List[DataModel],
@@ -1096,7 +1107,7 @@ class Parser(ABC):
             self.__extract_inherited_enum(models)
             self.__set_reference_default_value_to_field(models)
             self.__reuse_model(models, require_update_action_models)
-            self.__collapse_root_models(models, unused_models)
+            self.__collapse_root_models(models, unused_models, imports)
             self.__set_default_enum_member(models)
             self.__override_required_field(models)
             self.__sort_models(models, imports)

{datamodel_code_generator-0.21.3 → datamodel_code_generator-0.21.4}/datamodel_code_generator/parser/jsonschema.py

@@ -173,6 +173,10 @@ class JsonSchemaObject(BaseModel):
             def get_fields(cls) -> Dict[str, Any]:
                 return cls.__fields__
 
+            @classmethod
+            def model_rebuild(cls) -> None:
+                cls.update_forward_refs()
+
     __constraint_fields__: Set[str] = {
         'exclusiveMinimum',
         'minimum',
@@ -339,7 +343,7 @@ def _get_type(type_: str, format__: Optional[str] = None) -> Types:
     return json_schema_data_formats[type_]['default']
 
 
-JsonSchemaObject.update_forward_refs()
+JsonSchemaObject.model_rebuild()
 
 DEFAULT_FIELD_KEYS: Set[str] = {
     'example',

{datamodel_code_generator-0.21.3 → datamodel_code_generator-0.21.4}/datamodel_code_generator/types.py

@@ -110,6 +110,9 @@ class UnionIntFloat:
     def __float__(self) -> float:
         return float(self.value)
 
+    def __str__(self) -> str:
+        return str(self.value)
+
     @classmethod
     def __get_validators__(cls) -> Iterator[Callable[[Any], Any]]:
         yield cls.validate
@@ -234,6 +237,11 @@ class DataType(_BaseModel):
             revalidate_instances='never',
         )
     else:
+        if not TYPE_CHECKING:
+
+            @classmethod
+            def model_rebuild(cls) -> None:
+                cls.update_forward_refs()
 
         class Config:
             extra = 'forbid'
@@ -498,7 +506,7 @@ class DataType(_BaseModel):
         return len(self.data_types) > 1
 
 
-DataType.update_forward_refs()
+DataType.model_rebuild()
 
 DataTypeT = TypeVar('DataTypeT', bound=DataType)
 

datamodel_code_generator-0.21.4/datamodel_code_generator/version.py

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

{datamodel_code_generator-0.21.3 → datamodel_code_generator-0.21.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "datamodel-code-generator"
-version = "0.21.3"
+version = "0.21.4"
 description = "Datamodel Code Generator"
 authors = ["Koudai Aono <koxudaxi@gmail.com>"]
 readme = "README.md"
@@ -48,7 +48,7 @@ pydantic =  [
 ]
 argcomplete = ">=1.10,<4.0"
 prance = ">=0.18.2"
-openapi-spec-validator = ">=0.2.8,<=0.5.2"
+openapi-spec-validator = ">=0.2.8,<=0.5.7"
 jinja2 = ">=2.10.1,<4.0"
 inflect = ">=4.1.0,<6.0"
 black = ">=19.10b0"

datamodel_code_generator-0.21.3/datamodel_code_generator/model/pydantic_v2/root_model.py

@@ -1,10 +0,0 @@
-from __future__ import annotations
-
-from typing import ClassVar
-
-from datamodel_code_generator.model.pydantic_v2.base_model import BaseModel
-
-
-class RootModel(BaseModel):
-    TEMPLATE_FILE_PATH: ClassVar[str] = 'pydantic_v2/RootModel.jinja2'
-    BASE_CLASS: ClassVar[str] = 'pydantic.RootModel'

datamodel_code_generator-0.21.3/datamodel_code_generator/version.py

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