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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datamodel-code-generator
-Version: 0.21.2
+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"
@@ -321,7 +321,7 @@ $ docker pull koxudaxi/datamodel-code-generator
 ```
 
 ## Advanced Uses
-You can genearte models from a URL.
+You can generate models from a URL.
 ```bash
 $ datamodel-codegen --url https://<INPUT FILE URL> --output model.py
 ```

{datamodel_code_generator-0.21.2 → datamodel_code_generator-0.21.4}/README.md

@@ -283,7 +283,7 @@ $ docker pull koxudaxi/datamodel-code-generator
 ```
 
 ## Advanced Uses
-You can genearte models from a URL.
+You can generate models from a URL.
 ```bash
 $ datamodel-codegen --url https://<INPUT FILE URL> --output model.py
 ```

{datamodel_code_generator-0.21.2 → datamodel_code_generator-0.21.4}/datamodel_code_generator/__init__.py

@@ -224,7 +224,7 @@ def generate(
     output: Optional[Path] = None,
     output_model_type: DataModelType = DataModelType.PydanticBaseModel,
     target_python_version: PythonVersion = PythonVersion.PY_37,
-    base_class: str = DEFAULT_BASE_CLASS,
+    base_class: str = '',
     additional_imports: Optional[List[str]] = None,
     custom_template_dir: Optional[Path] = None,
     extra_template_data: Optional[DefaultDict[str, Dict[str, Any]]] = None,

{datamodel_code_generator-0.21.2 → 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.2 → datamodel_code_generator-0.21.4}/datamodel_code_generator/model/__init__.py

@@ -38,7 +38,7 @@ def get_data_model_types(
             root_model=pydantic_v2.RootModel,
             field_model=pydantic_v2.DataModelField,
             data_type_manager=pydantic_v2.DataTypeManager,
-            dump_resolve_reference_action=pydantic.dump_resolve_reference_action,
+            dump_resolve_reference_action=pydantic_v2.dump_resolve_reference_action,
         )
     elif data_model_type == DataModelType.DataclassesDataclass:
         return DataModelSet(

{datamodel_code_generator-0.21.2 → 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:
@@ -114,7 +118,10 @@ class DataModelFieldBase(_BaseModel):
             return type_hint
         elif self.required:
             return type_hint
-        return get_optional_type(type_hint, self.data_type.use_union_operator)
+        elif self.fall_back_to_nullable:
+            return get_optional_type(type_hint, self.data_type.use_union_operator)
+        else:
+            return type_hint
 
     @property
     def imports(self) -> Tuple[Import, ...]:
@@ -128,10 +135,16 @@ class DataModelFieldBase(_BaseModel):
             )
         ]
 
-        if (
-            self.nullable or (self.nullable is None and not self.required)
-        ) and not self.data_type.use_union_operator:
-            imports.append((IMPORT_OPTIONAL,))
+        if self.fall_back_to_nullable:
+            if (
+                self.nullable or (self.nullable is None and not self.required)
+            ) and not self.data_type.use_union_operator:
+                imports.append((IMPORT_OPTIONAL,))
+        else:
+            if (
+                self.nullable and not self.data_type.use_union_operator
+            ):  # pragma: no cover
+                imports.append((IMPORT_OPTIONAL,))
         if self.use_annotated:
             import_annotated = (
                 IMPORT_ANNOTATED
@@ -174,6 +187,10 @@ class DataModelFieldBase(_BaseModel):
     def has_default_factory(self) -> bool:
         return 'default_factory' in self.extras
 
+    @property
+    def fall_back_to_nullable(self) -> bool:
+        return True
+
 
 @lru_cache()
 def get_template(template_file_path: Path) -> Template:

{datamodel_code_generator-0.21.2 → datamodel_code_generator-0.21.4}/datamodel_code_generator/model/dataclass.py

@@ -6,7 +6,7 @@ from typing import Any, ClassVar, DefaultDict, Dict, List, Optional, Set, Tuple
 from datamodel_code_generator.imports import Import
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model.base import UNDEFINED
-from datamodel_code_generator.model.improts import IMPORT_DATACLASS, IMPORT_FIELD
+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.reference import Reference
 from datamodel_code_generator.types import chain_as_tuple

{datamodel_code_generator-0.21.2 → 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
 
 
@@ -155,7 +155,7 @@ class DataTypeManager(_DataTypeManager):
             use_union_operator,
         )
 
-        self.type_map: Dict[Types, DataType] = type_map_factory(
+        self.type_map: Dict[Types, DataType] = self.type_map_factory(
             self.data_type,
             strict_types=self.strict_types,
             pattern_key=self.PATTERN_KEY,
@@ -177,6 +177,14 @@ class DataTypeManager(_DataTypeManager):
             'pattern': self.PATTERN_KEY,
         }
 
+    def type_map_factory(
+        self,
+        data_type: Type[DataType],
+        strict_types: Sequence[StrictTypes],
+        pattern_key: str,
+    ) -> Dict[Types, DataType]:
+        return type_map_factory(data_type, strict_types, pattern_key)
+
     def transform_kwargs(
         self, kwargs: Dict[str, Any], filter_: Set[str]
     ) -> Dict[str, str]:
@@ -253,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.2 → datamodel_code_generator-0.21.4}/datamodel_code_generator/model/pydantic_v2/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional
+from typing import Iterable, Optional
 
 from pydantic import BaseModel as _BaseModel
 
@@ -9,6 +9,10 @@ from .root_model import RootModel
 from .types import DataTypeManager
 
 
+def dump_resolve_reference_action(class_names: Iterable[str]) -> str:
+    return '\n'.join(f'{class_name}.model_rebuild()' for class_name in class_names)
+
+
 class ConfigDict(_BaseModel):
     extra: Optional[str] = None
     title: Optional[str] = None
@@ -18,4 +22,10 @@ class ConfigDict(_BaseModel):
     arbitrary_types_allowed: Optional[bool] = None
 
 
-__all__ = ['BaseModel', 'DataModelField', 'RootModel', 'DataTypeManager']
+__all__ = [
+    'BaseModel',
+    'DataModelField',
+    'RootModel',
+    'dump_resolve_reference_action',
+    'DataTypeManager',
+]

{datamodel_code_generator-0.21.2 → 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.4/datamodel_code_generator/model/pydantic_v2/types.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import ClassVar, Dict, Sequence, Type
+
+from datamodel_code_generator.model.pydantic import DataTypeManager as _DataTypeManager
+from datamodel_code_generator.model.pydantic.imports import IMPORT_CONSTR
+from datamodel_code_generator.types import DataType, StrictTypes, Types
+
+
+class DataTypeManager(_DataTypeManager):
+    PATTERN_KEY: ClassVar[str] = 'pattern'
+
+    def type_map_factory(
+        self,
+        data_type: Type[DataType],
+        strict_types: Sequence[StrictTypes],
+        pattern_key: str,
+    ) -> Dict[Types, DataType]:
+        return {
+            **super().type_map_factory(data_type, strict_types, pattern_key),
+            Types.hostname: self.data_type.from_import(
+                IMPORT_CONSTR,
+                strict=StrictTypes.str in strict_types,
+                # https://github.com/horejsek/python-fastjsonschema/blob/61c6997a8348b8df9b22e029ca2ba35ef441fbb8/fastjsonschema/draft04.py#L31
+                kwargs={
+                    pattern_key: r"r'^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]{0,61}[A-Za-z0-9])$'",
+                    **({'strict': True} if StrictTypes.str in strict_types else {}),
+                },
+            ),
+        }

{datamodel_code_generator-0.21.2 → datamodel_code_generator-0.21.4}/datamodel_code_generator/model/typed_dict.py

@@ -16,7 +16,7 @@ from typing import (
 from datamodel_code_generator.imports import Import
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model.base import UNDEFINED
-from datamodel_code_generator.model.improts import (
+from datamodel_code_generator.model.imports import (
     IMPORT_NOT_REQUIRED,
     IMPORT_NOT_REQUIRED_BACKPORT,
     IMPORT_TYPED_DICT,
@@ -139,6 +139,10 @@ class DataModelField(DataModelFieldBase):
     def _not_required(self) -> bool:
         return not self.required and isinstance(self.parent, TypedDict)
 
+    @property
+    def fall_back_to_nullable(self) -> bool:
+        return not self._not_required
+
     @property
     def imports(self) -> Tuple[Import, ...]:
         return (

{datamodel_code_generator-0.21.2 → 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.2 → 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.2 → datamodel_code_generator-0.21.4}/datamodel_code_generator/parser/openapi.py

@@ -479,7 +479,11 @@ class OpenAPIParser(JsonSchemaParser):
 
         if OpenAPIScope.Parameters in self.open_api_scopes and fields:
             self.results.append(
-                self.data_model_type(fields=fields, reference=reference)
+                self.data_model_type(
+                    fields=fields,
+                    reference=reference,
+                    custom_base_class=self.base_class,
+                )
             )
 
     def parse_operation(

{datamodel_code_generator-0.21.2 → 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.2 → datamodel_code_generator-0.21.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "datamodel-code-generator"
-version = "0.21.2"
+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.2/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.2/datamodel_code_generator/model/pydantic_v2/types.py

@@ -1,9 +0,0 @@
-from __future__ import annotations
-
-from typing import ClassVar
-
-from datamodel_code_generator.model.pydantic import DataTypeManager as _DataTypeManager
-
-
-class DataTypeManager(_DataTypeManager):
-    PATTERN_KEY: ClassVar[str] = 'pattern'

datamodel_code_generator-0.21.2/datamodel_code_generator/version.py

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