datamodel-code-generator 0.26.4__py3-none-any.whl → 0.27.0__py3-none-any.whl

datamodel_code_generator/__init__.py

@@ -81,6 +81,9 @@ def enable_debug_message() -> None:  # pragma: no cover
     pysnooper.tracer.DISABLED = False
 
 
+DEFAULT_MAX_VARIABLE_LENGTH: int = 100
+
+
 def snooper_to_methods(  # type: ignore
     output=None,
     watch=(),
@@ -90,7 +93,7 @@ def snooper_to_methods(  # type: ignore
     overwrite=False,
     thread_info=False,
     custom_repr=(),
-    max_variable_length=100,
+    max_variable_length: Optional[int] = DEFAULT_MAX_VARIABLE_LENGTH,
 ) -> Callable[..., Any]:
     def inner(cls: Type[T]) -> Type[T]:
         if not pysnooper:
@@ -108,7 +111,9 @@ def snooper_to_methods(  # type: ignore
                 overwrite,
                 thread_info,
                 custom_repr,
-                max_variable_length,
+                max_variable_length
+                if max_variable_length is not None
+                else DEFAULT_MAX_VARIABLE_LENGTH,
             )(method)
             setattr(cls, name, snooper_method)
         return cls
@@ -424,8 +429,10 @@ def generate(
     data_model_types = get_data_model_types(
         output_model_type, target_python_version, output_datetime_class
     )
+    source = input_text or input_
+    assert not isinstance(source, Mapping)
     parser = parser_class(
-        source=input_text or input_,
+        source=source,
         data_model_type=data_model_types.data_model,
         data_model_root_type=data_model_types.root_model,
         data_model_field_type=data_model_types.field_model,
@@ -514,6 +521,7 @@ def generate(
             # input_ might be a dict object provided directly, and missing a name field
             input_filename = getattr(input_, 'name', '<dict>')
         else:
+            assert isinstance(input_, Path)
             input_filename = input_.name
     if not results:
         raise Error('Models not found in the input data')

datamodel_code_generator/__main__.py

@@ -53,7 +53,6 @@ from datamodel_code_generator.arguments import DEFAULT_ENCODING, arg_parser, nam
 from datamodel_code_generator.format import (
     DatetimeClassType,
     PythonVersion,
-    black_find_project_root,
     is_supported_in_black,
 )
 from datamodel_code_generator.parser import LiteralType
@@ -86,7 +85,7 @@ signal.signal(signal.SIGINT, sig_int_handler)
 
 class Config(BaseModel):
     if PYDANTIC_V2:
-        model_config = ConfigDict(arbitrary_types_allowed=True)
+        model_config = ConfigDict(arbitrary_types_allowed=True)  # pyright: ignore [reportAssignmentType]
 
         def get(self, item: str) -> Any:
             return getattr(self, item)
@@ -186,8 +185,8 @@ class Config(BaseModel):
 
     @model_validator(mode='after')
     def validate_keyword_only(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        output_model_type: DataModelType = values.get('output_model_type')
-        python_target: PythonVersion = values.get('target_python_version')
+        output_model_type: DataModelType = values.get('output_model_type')  # pyright: ignore [reportAssignmentType]
+        python_target: PythonVersion = values.get('target_python_version')  # pyright: ignore [reportAssignmentType]
         if (
             values.get('keyword_only')
             and output_model_type == DataModelType.DataclassesDataclass
@@ -220,7 +219,7 @@ class Config(BaseModel):
         def validate_each_item(each_item: Any) -> Tuple[str, str]:
             if isinstance(each_item, str):  # pragma: no cover
                 try:
-                    field_name, field_value = each_item.split(':', maxsplit=1)  # type: str, str
+                    field_name, field_value = each_item.split(':', maxsplit=1)
                     return field_name, field_value.lstrip()
                 except ValueError:
                     raise Error(f'Invalid http header: {each_item!r}')
@@ -237,7 +236,7 @@ class Config(BaseModel):
         def validate_each_item(each_item: Any) -> Tuple[str, str]:
             if isinstance(each_item, str):  # pragma: no cover
                 try:
-                    field_name, field_value = each_item.split('=', maxsplit=1)  # type: str, str
+                    field_name, field_value = each_item.split('=', maxsplit=1)
                     return field_name, field_value.lstrip()
                 except ValueError:
                     raise Error(f'Invalid http query parameter: {each_item!r}')
@@ -249,14 +248,16 @@ class Config(BaseModel):
 
     @model_validator(mode='before')
     def validate_additional_imports(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if values.get('additional_imports') is not None:
-            values['additional_imports'] = values.get('additional_imports').split(',')
+        additional_imports = values.get('additional_imports')
+        if additional_imports is not None:
+            values['additional_imports'] = additional_imports.split(',')
         return values
 
     @model_validator(mode='before')
     def validate_custom_formatters(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if values.get('custom_formatters') is not None:
-            values['custom_formatters'] = values.get('custom_formatters').split(',')
+        custom_formatters = values.get('custom_formatters')
+        if custom_formatters is not None:
+            values['custom_formatters'] = custom_formatters.split(',')
         return values
 
     if PYDANTIC_V2:
@@ -283,7 +284,7 @@ class Config(BaseModel):
     disable_warnings: bool = False
     target_python_version: PythonVersion = PythonVersion.PY_38
     base_class: str = ''
-    additional_imports: Optional[List[str]] = (None,)
+    additional_imports: Optional[List[str]] = None
     custom_template_dir: Optional[Path] = None
     extra_template_data: Optional[TextIOBase] = None
     validation: bool = False
@@ -366,6 +367,26 @@ class Config(BaseModel):
             setattr(self, field_name, getattr(parsed_args, field_name))
 
 
+def _get_pyproject_toml_config(source: Path) -> Optional[Dict[str, Any]]:
+    """Find and return the [tool.datamodel-codgen] section of the closest
+    pyproject.toml if it exists.
+    """
+
+    current_path = source
+    while current_path != current_path.parent:
+        if (current_path / 'pyproject.toml').is_file():
+            pyproject_toml = load_toml(current_path / 'pyproject.toml')
+            if 'datamodel-codegen' in pyproject_toml.get('tool', {}):
+                return pyproject_toml['tool']['datamodel-codegen']
+
+        if (current_path / '.git').exists():
+            # Stop early if we see a git repository root.
+            return None
+
+        current_path = current_path.parent
+    return None
+
+
 def main(args: Optional[Sequence[str]] = None) -> Exit:
     """Main function."""
 
@@ -383,16 +404,9 @@ def main(args: Optional[Sequence[str]] = None) -> Exit:
         print(version)
         exit(0)
 
-    root = black_find_project_root((Path().resolve(),))
-    pyproject_toml_path = root / 'pyproject.toml'
-    if pyproject_toml_path.is_file():
-        pyproject_toml: Dict[str, Any] = {
-            k.replace('-', '_'): v
-            for k, v in load_toml(pyproject_toml_path)
-            .get('tool', {})
-            .get('datamodel-codegen', {})
-            .items()
-        }
+    pyproject_config = _get_pyproject_toml_config(Path().resolve())
+    if pyproject_config is not None:
+        pyproject_toml = {k.replace('-', '_'): v for k, v in pyproject_config.items()}
     else:
         pyproject_toml = {}
 

datamodel_code_generator/arguments.py

@@ -98,7 +98,7 @@ base_options.add_argument(
 # ======================================================================================
 model_options.add_argument(
     '--allow-extra-fields',
-    help='Allow to pass extra fields, if this flag is not passed, extra fields are forbidden.',
+    help='Allow passing extra fields, if this flag is not passed, extra fields are forbidden.',
     action='store_true',
     default=None,
 )

datamodel_code_generator/http.py

@@ -21,7 +21,8 @@ def get_body(
         headers=headers,
         verify=not ignore_tls,
         follow_redirects=True,
-        params=query_parameters,
+        params=query_parameters,  # pyright: ignore [reportArgumentType]
+        # TODO: Improve params type
     ).text
 
 

datamodel_code_generator/imports.py

@@ -14,7 +14,7 @@ class Import(BaseModel):
     reference_path: Optional[str] = None
 
     @classmethod
-    @lru_cache()
+    @lru_cache
     def from_full_path(cls, class_path: str) -> Import:
         split_class_path: List[str] = class_path.split('.')
         return Import(
@@ -43,7 +43,7 @@ class Imports(DefaultDict[Optional[str], Set[str]]):
 
     def create_line(self, from_: Optional[str], imports: Set[str]) -> str:
         if from_:
-            return f"from {from_} import {', '.join(self._set_alias(from_, imports))}"
+            return f'from {from_} import {", ".join(self._set_alias(from_, imports))}'
         return '\n'.join(f'import {i}' for i in self._set_alias(from_, imports))
 
     def dump(self) -> str:

datamodel_code_generator/model/__init__.py

@@ -28,12 +28,14 @@ class DataModelSet(NamedTuple):
 def get_data_model_types(
     data_model_type: DataModelType,
     target_python_version: PythonVersion = DEFAULT_TARGET_PYTHON_VERSION,
-    target_datetime_class: DatetimeClassType = DEFAULT_TARGET_DATETIME_CLASS,
+    target_datetime_class: Optional[DatetimeClassType] = None,
 ) -> DataModelSet:
     from .. import DataModelType
     from . import dataclass, msgspec, pydantic, pydantic_v2, rootmodel, typed_dict
     from .types import DataTypeManager
 
+    if target_datetime_class is None:
+        target_datetime_class = DEFAULT_TARGET_DATETIME_CLASS
     if data_model_type == DataModelType.PydanticBaseModel:
         return DataModelSet(
             data_model=pydantic.BaseModel,

datamodel_code_generator/model/base.py

@@ -53,7 +53,7 @@ class ConstraintsBase(_BaseModel):
     unique_items: Optional[bool] = Field(None, alias='uniqueItems')
     _exclude_fields: ClassVar[Set[str]] = {'has_constraints'}
     if PYDANTIC_V2:
-        model_config = ConfigDict(
+        model_config = ConfigDict(  # pyright: ignore [reportAssignmentType]
             arbitrary_types_allowed=True, ignored_types=(cached_property,)
         )
     else:
@@ -87,7 +87,9 @@ class ConstraintsBase(_BaseModel):
         else:
             model_field_constraints = {}
 
-        if not issubclass(constraints_class, ConstraintsBase):  # pragma: no cover
+        if constraints_class is None or not issubclass(
+            constraints_class, ConstraintsBase
+        ):  # pragma: no cover
             return None
 
         return constraints_class.parse_obj(
@@ -165,7 +167,7 @@ class DataModelFieldBase(_BaseModel):
         type_hint = self.type_hint
         has_union = not self.data_type.use_union_operator and UNION_PREFIX in type_hint
         imports: List[Union[Tuple[Import], Iterator[Import]]] = [
-            (
+            iter(
                 i
                 for i in self.data_type.all_imports
                 if not (not has_union and i == IMPORT_UNION)
@@ -229,7 +231,7 @@ class DataModelFieldBase(_BaseModel):
         return True
 
 
-@lru_cache()
+@lru_cache
 def get_template(template_file_path: Path) -> Template:
     loader = FileSystemLoader(str(TEMPLATE_DIR / template_file_path.parent))
     environment: Environment = Environment(loader=loader)
@@ -251,7 +253,7 @@ def get_module_name(name: str, file_path: Optional[Path]) -> str:
 
 
 class TemplateBase(ABC):
-    @property
+    @cached_property
     @abstractmethod
     def template_file_path(self) -> Path:
         raise NotImplementedError
@@ -423,7 +425,7 @@ class DataModel(TemplateBase, Nullable, ABC):
     def class_name(self, class_name: str) -> None:
         if '.' in self.reference.name:
             self.reference.name = (
-                f"{self.reference.name.rsplit('.', 1)[0]}.{class_name}"
+                f'{self.reference.name.rsplit(".", 1)[0]}.{class_name}'
             )
         else:
             self.reference.name = class_name

datamodel_code_generator/model/enum.py

@@ -82,10 +82,22 @@ class Enum(DataModel):
 
     def find_member(self, value: Any) -> Optional[Member]:
         repr_value = repr(value)
-        for field in self.fields:  # pragma: no cover
-            if field.default == repr_value:
+        # Remove surrounding quotes from the string representation
+        str_value = str(value).strip('\'"')
+
+        for field in self.fields:
+            # Remove surrounding quotes from field default value
+            field_default = (field.default or '').strip('\'"')
+
+            # Compare values after removing quotes
+            if field_default == str_value:
                 return self.get_member(field)
-        return None  # pragma: no cover
+
+            # Keep original comparison for backwards compatibility
+            if field.default == repr_value:  # pragma: no cover
+                return self.get_member(field)
+
+        return None
 
     @property
     def imports(self) -> Tuple[Import, ...]:

datamodel_code_generator/model/pydantic/base_model.py

@@ -322,4 +322,4 @@ class BaseModel(BaseModelBase):
         if config_parameters:
             from datamodel_code_generator.model.pydantic import Config
 
-            self.extra_template_data['config'] = Config.parse_obj(config_parameters)
+            self.extra_template_data['config'] = Config.parse_obj(config_parameters)  # pyright: ignore [reportArgumentType]

datamodel_code_generator/model/pydantic/types.py

@@ -180,7 +180,7 @@ class DataTypeManager(_DataTypeManager):
             self.data_type,
             strict_types=self.strict_types,
             pattern_key=self.PATTERN_KEY,
-            target_datetime_class=target_datetime_class,
+            target_datetime_class=self.target_datetime_class,
         )
         self.strict_type_map: Dict[StrictTypes, DataType] = strict_type_map_factory(
             self.data_type,

datamodel_code_generator/model/pydantic_v2/base_model.py

@@ -98,7 +98,7 @@ class DataModelField(DataModelFieldV1):
         'max_length',
         'union_mode',
     }
-    constraints: Optional[Constraints] = None
+    constraints: Optional[Constraints] = None  # pyright: ignore [reportIncompatibleVariableOverride]
     _PARSE_METHOD: ClassVar[str] = 'model_validate'
     can_have_extra_keys: ClassVar[bool] = False
 
@@ -234,7 +234,7 @@ class BaseModel(BaseModelBase):
         if config_parameters:
             from datamodel_code_generator.model.pydantic_v2 import ConfigDict
 
-            self.extra_template_data['config'] = ConfigDict.parse_obj(config_parameters)
+            self.extra_template_data['config'] = ConfigDict.parse_obj(config_parameters)  # pyright: ignore [reportArgumentType]
             self._additional_imports.append(IMPORT_CONFIG_DICT)
 
     def _get_config_extra(self) -> Optional[Literal["'allow'", "'forbid'"]]:

datamodel_code_generator/model/pydantic_v2/types.py

@@ -24,7 +24,10 @@ class DataTypeManager(_DataTypeManager):
     ) -> Dict[Types, DataType]:
         result = {
             **super().type_map_factory(
-                data_type, strict_types, pattern_key, target_datetime_class
+                data_type,
+                strict_types,
+                pattern_key,
+                target_datetime_class or DatetimeClassType.Datetime,
             ),
             Types.hostname: self.data_type.from_import(
                 IMPORT_CONSTR,

datamodel_code_generator/parser/base.py

@@ -65,6 +65,7 @@ def get_special_path(keyword: str, path: List[str]) -> List[str]:
 
 escape_characters = str.maketrans(
     {
+        '\u0000': r'\x00',  # Null byte
         '\\': r'\\',
         "'": r'\'',
         '\b': r'\b',
@@ -410,7 +411,7 @@ 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,
+        target_datetime_class: Optional[DatetimeClassType] = DatetimeClassType.Datetime,
         keyword_only: bool = False,
         no_alias: bool = False,
     ) -> None:
@@ -667,7 +668,16 @@ class Parser(ABC):
         for model, duplicate_models in model_to_duplicate_models.items():
             for duplicate_model in duplicate_models:
                 for child in duplicate_model.reference.children[:]:
-                    child.replace_reference(model.reference)
+                    if isinstance(child, DataType):
+                        child.replace_reference(model.reference)
+                    # simplify if introduce duplicate base classes
+                    if isinstance(child, DataModel):
+                        child.base_classes = list(
+                            {
+                                f'{c.module_name}.{c.type_hint}': c
+                                for c in child.base_classes
+                            }.values()
+                        )
                 models.remove(duplicate_model)
 
     @classmethod
@@ -848,12 +858,12 @@ class Parser(ABC):
 
                     # Check the main discriminator model path
                     if mapping:
-                        check_paths(discriminator_model, mapping)
+                        check_paths(discriminator_model, mapping)  # pyright: ignore [reportArgumentType]
 
                         # 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)
+                                check_paths(base_class.reference, mapping)  # pyright: ignore [reportArgumentType]
                     else:
                         type_names = [discriminator_model.path.split('/')[-1]]
                     if not type_names:  # pragma: no cover
@@ -1037,7 +1047,7 @@ class Parser(ABC):
                         and any(
                             d
                             for d in model_field.data_type.all_data_types
-                            if d.is_dict or d.is_union
+                            if d.is_dict or d.is_union or d.is_list
                         )
                     ):
                         continue  # pragma: no cover
@@ -1060,7 +1070,7 @@ class Parser(ABC):
 
                         data_type.parent.data_type = copied_data_type
 
-                    elif data_type.parent.is_list:
+                    elif data_type.parent is not None and data_type.parent.is_list:
                         if self.field_constraints:
                             model_field.constraints = ConstraintsBase.merge_constraints(
                                 root_type_field.constraints, model_field.constraints
@@ -1072,6 +1082,7 @@ class Parser(ABC):
                             discriminator = root_type_field.extras.get('discriminator')
                             if discriminator:
                                 model_field.extras['discriminator'] = discriminator
+                        assert isinstance(data_type.parent, DataType)
                         data_type.parent.data_types.remove(
                             data_type
                         )  # pragma: no cover
@@ -1357,7 +1368,7 @@ class Parser(ABC):
         module_to_import: Dict[Tuple[str, ...], Imports] = {}
 
         previous_module = ()  # type: Tuple[str, ...]
-        for module, models in ((k, [*v]) for k, v in grouped_models):  # type: Tuple[str, ...], List[DataModel]
+        for module, models in ((k, [*v]) for k, v in grouped_models):
             for model in models:
                 model_to_module_models[model] = module, models
             self.__delete_duplicate_models(models)

datamodel_code_generator/parser/graphql.py

@@ -373,7 +373,7 @@ class GraphQLParser(Parser):
     def parse_field(
         self,
         field_name: str,
-        alias: str,
+        alias: Optional[str],
         field: Union[graphql.GraphQLField, graphql.GraphQLInputField],
     ) -> DataModelFieldBase:
         final_data_type = DataType(
@@ -399,9 +399,9 @@ class GraphQLParser(Parser):
             elif graphql.is_non_null_type(obj):  # pragma: no cover
                 data_type.is_optional = False
 
-            obj = obj.of_type
+            obj = obj.of_type  # pyright: ignore [reportAttributeAccessIssue]
 
-        data_type.type = obj.name
+        data_type.type = obj.name  # pyright: ignore [reportAttributeAccessIssue]
 
         required = (not self.force_optional_for_required_fields) and (
             not final_data_type.is_optional
@@ -456,7 +456,7 @@ class GraphQLParser(Parser):
 
         base_classes = []
         if hasattr(obj, 'interfaces'):  # pragma: no cover
-            base_classes = [self.references[i.name] for i in obj.interfaces]
+            base_classes = [self.references[i.name] for i in obj.interfaces]  # pyright: ignore [reportAttributeAccessIssue]
 
         data_model_type = self.data_model_type(
             reference=self.references[obj.name],

datamodel_code_generator/parser/jsonschema.py

@@ -258,7 +258,7 @@ class JsonSchemaObject(BaseModel):
     extras: Dict[str, Any] = Field(alias=__extra_key__, default_factory=dict)
     discriminator: Union[Discriminator, str, None] = None
     if PYDANTIC_V2:
-        model_config = ConfigDict(
+        model_config = ConfigDict(  # pyright: ignore [reportPossiblyUnboundVariable]
             arbitrary_types_allowed=True,
             ignored_types=(cached_property,),
         )
@@ -320,7 +320,7 @@ class JsonSchemaObject(BaseModel):
         return isinstance(self.type, list) and 'null' in self.type
 
 
-@lru_cache()
+@lru_cache
 def get_ref_type(ref: str) -> JSONReference:
     if ref[0] == '#':
         return JSONReference.LOCAL
@@ -338,7 +338,7 @@ def _get_type(type_: str, format__: Optional[str] = None) -> Types:
     if data_formats is not None:
         return data_formats
 
-    warn(f'format of {format__!r} not understood for {type_!r} - using default' '')
+    warn(f'format of {format__!r} not understood for {type_!r} - using default')
     return json_schema_data_formats[type_]['default']
 
 
@@ -360,7 +360,7 @@ EXCLUDE_FIELD_KEYS_IN_JSON_SCHEMA: Set[str] = {
 }
 
 EXCLUDE_FIELD_KEYS = (
-    set(JsonSchemaObject.get_fields())
+    set(JsonSchemaObject.get_fields())  # pyright: ignore [reportAttributeAccessIssue]
     - DEFAULT_FIELD_KEYS
     - EXCLUDE_FIELD_KEYS_IN_JSON_SCHEMA
 ) | {
@@ -528,7 +528,7 @@ class JsonSchemaParser(Parser):
         self.raw_obj: Dict[Any, Any] = {}
         self._root_id: Optional[str] = None
         self._root_id_base_path: Optional[str] = None
-        self.reserved_refs: DefaultDict[Tuple[str], Set[str]] = defaultdict(set)
+        self.reserved_refs: DefaultDict[Tuple[str, ...], Set[str]] = defaultdict(set)
         self.field_keys: Set[str] = {
             *DEFAULT_FIELD_KEYS,
             *self.field_extra_keys,
@@ -1798,6 +1798,7 @@ class JsonSchemaParser(Parser):
                 root_obj = self.SCHEMA_OBJECT_TYPE.parse_obj(raw)
                 self.parse_id(root_obj, path_parts)
                 definitions: Optional[Dict[Any, Any]] = None
+                schema_path = ''
                 for schema_path, split_schema_path in self.schema_paths:
                     try:
                         definitions = get_model_by_path(raw, split_schema_path)

datamodel_code_generator/parser/openapi.py

@@ -367,7 +367,7 @@ class OpenAPIParser(JsonSchemaParser):
         for (
             media_type,
             media_obj,
-        ) in request_body.content.items():  # type: str, MediaObject
+        ) in request_body.content.items():
             if isinstance(media_obj.schema_, JsonSchemaObject):
                 self.parse_schema(name, media_obj.schema_, [*path, media_type])
 
@@ -400,11 +400,13 @@ class OpenAPIParser(JsonSchemaParser):
                 if not object_schema:  # pragma: no cover
                     continue
                 if isinstance(object_schema, JsonSchemaObject):
-                    data_types[status_code][content_type] = self.parse_schema(
-                        name, object_schema, [*path, str(status_code), content_type]
+                    data_types[status_code][content_type] = self.parse_schema(  # pyright: ignore [reportArgumentType]
+                        name,
+                        object_schema,
+                        [*path, str(status_code), content_type],  # pyright: ignore [reportArgumentType]
                     )
                 else:
-                    data_types[status_code][content_type] = self.get_ref_data_type(
+                    data_types[status_code][content_type] = self.get_ref_data_type(  # pyright: ignore [reportArgumentType]
                         object_schema.ref
                     )
 
@@ -604,7 +606,7 @@ class OpenAPIParser(JsonSchemaParser):
                 for (
                     obj_name,
                     raw_obj,
-                ) in schemas.items():  # type: str, Dict[Any, Any]
+                ) in schemas.items():
                     self.parse_raw_obj(
                         obj_name,
                         raw_obj,

datamodel_code_generator/pydantic_patch.py

@@ -19,4 +19,4 @@ def patched_evaluate_forwardref(
 
 # Patch only Python3.12
 if sys.version_info >= (3, 12):
-    pydantic.typing.evaluate_forwardref = patched_evaluate_forwardref
+    pydantic.typing.evaluate_forwardref = patched_evaluate_forwardref  # pyright: ignore [reportAttributeAccessIssue]

datamodel_code_generator/reference.py

@@ -138,7 +138,7 @@ class Reference(_BaseModel):
     if PYDANTIC_V2:
         # TODO[pydantic]: The following keys were removed: `copy_on_model_validation`.
         # Check https://docs.pydantic.dev/dev-v2/migration/#changes-to-config for more information.
-        model_config = ConfigDict(
+        model_config = ConfigDict(  # pyright: ignore [reportAssignmentType]
             arbitrary_types_allowed=True,
             ignored_types=(cached_property,),
             revalidate_instances='never',
@@ -182,7 +182,7 @@ _UNDER_SCORE_1: Pattern[str] = re.compile(r'([^_])([A-Z][a-z]+)')
 _UNDER_SCORE_2: Pattern[str] = re.compile('([a-z0-9])([A-Z])')
 
 
-@lru_cache()
+@lru_cache
 def camel_to_snake(string: str) -> str:
     subbed = _UNDER_SCORE_1.sub(r'\1_\2', string)
     return _UNDER_SCORE_2.sub(r'\1_\2', subbed).lower()
@@ -473,7 +473,7 @@ class ModelResolver:
         else:
             joined_path = self.join_path(path)
         if joined_path == '#':
-            return f"{'/'.join(self.current_root)}#"
+            return f'{"/".join(self.current_root)}#'
         if (
             self.current_base_path
             and not self.base_url
@@ -498,7 +498,7 @@ class ModelResolver:
 
             delimiter = joined_path.index('#')
             file_path = ''.join(joined_path[:delimiter])
-            ref = f"{''.join(joined_path[:delimiter])}#{''.join(joined_path[delimiter + 1:])}"
+            ref = f'{"".join(joined_path[:delimiter])}#{"".join(joined_path[delimiter + 1 :])}'
             if self.root_id_base_path and not (
                 is_url(joined_path) or Path(self._base_path, file_path).is_file()
             ):
@@ -750,15 +750,15 @@ class ModelResolver:
         )
 
 
-@lru_cache()
+@lru_cache
 def get_singular_name(name: str, suffix: str = SINGULAR_NAME_SUFFIX) -> str:
     singular_name = inflect_engine.singular_noun(name)
     if singular_name is False:
         singular_name = f'{name}{suffix}'
-    return singular_name
+    return singular_name  # pyright: ignore [reportReturnType]
 
 
-@lru_cache()
+@lru_cache
 def snake_to_upper_camel(word: str, delimiter: str = '_') -> str:
     prefix = ''
     if word.startswith(delimiter):

datamodel_code_generator/types.py

@@ -114,25 +114,25 @@ class UnionIntFloat:
     def __get_pydantic_core_schema__(
         cls, _source_type: Any, _handler: 'GetCoreSchemaHandler'
     ) -> 'core_schema.CoreSchema':
-        from_int_schema = core_schema.chain_schema(
+        from_int_schema = core_schema.chain_schema(  # pyright: ignore [reportPossiblyUnboundVariable]
             [
-                core_schema.union_schema(
-                    [core_schema.int_schema(), core_schema.float_schema()]
+                core_schema.union_schema(  # pyright: ignore [reportPossiblyUnboundVariable]
+                    [core_schema.int_schema(), core_schema.float_schema()]  # pyright: ignore [reportPossiblyUnboundVariable]
                 ),
-                core_schema.no_info_plain_validator_function(cls.validate),
+                core_schema.no_info_plain_validator_function(cls.validate),  # pyright: ignore [reportPossiblyUnboundVariable]
             ]
         )
 
-        return core_schema.json_or_python_schema(
+        return core_schema.json_or_python_schema(  # pyright: ignore [reportPossiblyUnboundVariable]
             json_schema=from_int_schema,
-            python_schema=core_schema.union_schema(
+            python_schema=core_schema.union_schema(  # pyright: ignore [reportPossiblyUnboundVariable]
                 [
                     # check if it's an instance first before doing any further work
-                    core_schema.is_instance_schema(UnionIntFloat),
+                    core_schema.is_instance_schema(UnionIntFloat),  # pyright: ignore [reportPossiblyUnboundVariable]
                     from_int_schema,
                 ]
             ),
-            serialization=core_schema.plain_serializer_function_ser_schema(
+            serialization=core_schema.plain_serializer_function_ser_schema(  # pyright: ignore [reportPossiblyUnboundVariable]
                 lambda instance: instance.value
             ),
         )
@@ -161,7 +161,7 @@ def chain_as_tuple(*iterables: Iterable[T]) -> Tuple[T, ...]:
     return tuple(chain(*iterables))
 
 
-@lru_cache()
+@lru_cache
 def _remove_none_from_type(
     type_: str, split_pattern: Pattern[str], delimiter: str
 ) -> List[str]:
@@ -207,7 +207,7 @@ def _remove_none_from_union(type_: str, use_union_operator: bool) -> str:
     return f'{UNION_PREFIX}{UNION_DELIMITER.join(inner_types)}]'
 
 
-@lru_cache()
+@lru_cache
 def get_optional_type(type_: str, use_union_operator: bool) -> str:
     type_ = _remove_none_from_union(type_, use_union_operator)
 
@@ -236,7 +236,7 @@ class DataType(_BaseModel):
     if PYDANTIC_V2:
         # TODO[pydantic]: The following keys were removed: `copy_on_model_validation`.
         # Check https://docs.pydantic.dev/dev-v2/migration/#changes-to-config for more information.
-        model_config = ConfigDict(
+        model_config = ConfigDict(  # pyright: ignore [reportAssignmentType]
             extra='forbid',
             revalidate_instances='never',
         )
@@ -362,22 +362,21 @@ class DataType(_BaseModel):
 
     @property
     def imports(self) -> Iterator[Import]:
+        # Add base import if exists
         if self.import_:
             yield self.import_
+
+        # Define required imports based on type features and conditions
         imports: Tuple[Tuple[bool, Import], ...] = (
             (self.is_optional and not self.use_union_operator, IMPORT_OPTIONAL),
             (len(self.data_types) > 1 and not self.use_union_operator, IMPORT_UNION),
-        )
-        if any(self.literals):
-            import_literal = (
+            (
+                bool(self.literals),
                 IMPORT_LITERAL
                 if self.python_version.has_literal_type
-                else IMPORT_LITERAL_BACKPORT
-            )
-            imports = (
-                *imports,
-                (any(self.literals), import_literal),
-            )
+                else IMPORT_LITERAL_BACKPORT,
+            ),
+        )
 
         if self.use_generic_container:
             if self.use_standard_collections:
@@ -401,10 +400,13 @@ class DataType(_BaseModel):
                 (self.is_set, IMPORT_SET),
                 (self.is_dict, IMPORT_DICT),
             )
+
+        # Yield imports based on conditions
         for field, import_ in imports:
             if field and import_ != self.import_:
                 yield import_
 
+        # Propagate imports from any dict_key type
         if self.dict_key:
             yield from self.dict_key.imports
 
@@ -463,7 +465,7 @@ class DataType(_BaseModel):
             elif len(self.data_types) == 1:
                 type_ = self.data_types[0].type_hint
             elif self.literals:
-                type_ = f"{LITERAL}[{', '.join(repr(literal) for literal in self.literals)}]"
+                type_ = f'{LITERAL}[{", ".join(repr(literal) for literal in self.literals)}]'
             else:
                 if self.reference:
                     type_ = self.reference.short_name
@@ -586,7 +588,9 @@ 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
+        self.target_datetime_class: DatetimeClassType = (
+            target_datetime_class or DatetimeClassType.Datetime
+        )
 
         if (
             use_generic_container_types and python_version == PythonVersion.PY_36

datamodel_code_generator/util.py

@@ -37,17 +37,13 @@ else:
         from yaml import SafeLoader
 
     try:
-        import tomllib
-
-        def load_toml(path: Path) -> Dict[str, Any]:
-            with path.open('rb') as f:
-                return tomllib.load(f)
-
+        from tomllib import load as load_tomllib
     except ImportError:
-        import toml
+        from tomli import load as load_tomllib
 
-        def load_toml(path: Path) -> Dict[str, Any]:
-            return toml.load(path)
+    def load_toml(path: Path) -> Dict[str, Any]:
+        with path.open('rb') as f:
+            return load_tomllib(f)
 
 
 SafeLoaderTemp = copy.deepcopy(SafeLoader)
@@ -81,7 +77,7 @@ def field_validator(
     field_name: str,
     *fields: str,
     mode: Literal['before', 'after'] = 'after',
-) -> Callable[[Any], Callable[[Model, Any], Any]]:
+) -> Callable[[Any], Callable[[BaseModel, Any], Any]]:
     def inner(method: Callable[[Model, Any], Any]) -> Callable[[Model, Any], Any]:
         if PYDANTIC_V2:
             from pydantic import field_validator as field_validator_v2
@@ -103,4 +99,4 @@ else:
 
 class BaseModel(_BaseModel):
     if PYDANTIC_V2:
-        model_config = ConfigDict(strict=False)
+        model_config = ConfigDict(strict=False)  # pyright: ignore [reportAssignmentType]

datamodel_code_generator/version.py

@@ -1 +1 @@
-version: str = '0.26.4'
+version: str = '0.0.0'

{datamodel_code_generator-0.26.4.dist-info → datamodel_code_generator-0.27.0.dist-info}/METADATA

@@ -1,16 +1,16 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: datamodel-code-generator
-Version: 0.26.4
+Version: 0.27.0
 Summary: Datamodel Code Generator
-Home-page: https://github.com/koxudaxi/datamodel-code-generator
-License: MIT
-Author: Koudai Aono
-Author-email: koxudaxi@gmail.com
-Requires-Python: >=3.8,<4.0
+Project-URL: Homepage, https://github.com/koxudaxi/datamodel-code-generator
+Project-URL: Source, https://github.com/koxudaxi/datamodel-code-generator
+Author-email: Koudai Aono <koxudaxi@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
-Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -18,29 +18,31 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.8
+Requires-Dist: argcomplete<4,>=2.10.1
+Requires-Dist: black>=19.10b0
+Requires-Dist: genson<2,>=1.2.1
+Requires-Dist: graphql-core>=3.2.3
+Requires-Dist: httpx>=0.24.1
+Requires-Dist: inflect<6,>=4.1
+Requires-Dist: isort<6,>=4.3.21
+Requires-Dist: jinja2<4,>=2.10.1
+Requires-Dist: openapi-spec-validator<0.7,>=0.2.8
+Requires-Dist: packaging
+Requires-Dist: prance>=0.18.2
+Requires-Dist: pydantic>=1.5
+Requires-Dist: pysnooper<2,>=0.4.1
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: tomli<3,>=2.2.1; python_version <= '3.11'
 Provides-Extra: debug
+Requires-Dist: pysnooper; extra == 'debug'
 Provides-Extra: graphql
+Requires-Dist: graphql-core; extra == 'graphql'
 Provides-Extra: http
+Requires-Dist: httpx; extra == 'http'
 Provides-Extra: validation
-Requires-Dist: PySnooper (>=0.4.1,<2.0.0) ; extra == "debug"
-Requires-Dist: argcomplete (>=1.10,<4.0)
-Requires-Dist: black (>=19.10b0)
-Requires-Dist: genson (>=1.2.1,<2.0)
-Requires-Dist: graphql-core (>=3.2.3,<4.0.0) ; extra == "graphql"
-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.7.0) ; extra == "validation"
-Requires-Dist: packaging
-Requires-Dist: prance (>=0.18.2) ; extra == "validation"
-Requires-Dist: pydantic[email] (>=1.10.0,!=2.0.0,!=2.0.1,<3.0,!=2.4.0) ; python_version >= "3.12" and python_version < "4.0"
-Requires-Dist: pydantic[email] (>=1.10.0,<3.0,!=2.4.0) ; python_version >= "3.11" and python_version < "4.0"
-Requires-Dist: pydantic[email] (>=1.5.1,<3.0,!=2.4.0) ; python_version < "3.10"
-Requires-Dist: pydantic[email] (>=1.9.0,<3.0,!=2.4.0) ; python_version >= "3.10" and python_version < "3.11"
-Requires-Dist: pyyaml (>=6.0.1)
-Requires-Dist: toml (>=0.10.0,<1.0.0) ; python_version < "3.11"
-Project-URL: Repository, https://github.com/koxudaxi/datamodel-code-generator
+Requires-Dist: openapi-spec-validator; extra == 'validation'
+Requires-Dist: prance; extra == 'validation'
 Description-Content-Type: text/markdown
 
 # datamodel-code-generator
@@ -331,6 +333,8 @@ See the following linked projects for real world examples and inspiration.
   - *[`Makefile`](https://github.com/argoproj-labs/hera/blob/c8cbf0c7a676de57469ca3d6aeacde7a5e84f8b7/Makefile#L53-L62)*
 - [awslabs/aws-lambda-powertools-python](https://github.com/awslabs/aws-lambda-powertools-python)
   - *Recommended for [advanced-use-cases](https://awslabs.github.io/aws-lambda-powertools-python/2.6.0/utilities/parser/#advanced-use-cases) in the official documentation*
+- [cloudcoil/cloudcoil](https://github.com/cloudcoil/cloudcoil)
+  - *[Cloudcoil - Model generation](https://github.com/cloudcoil/cloudcoil#%EF%B8%8F-model-generation)
 - [DataDog/integrations-core](https://github.com/DataDog/integrations-core)
   - *[Config models](https://github.com/DataDog/integrations-core/blob/master/docs/developer/meta/config-models.md)*
 - [hashintel/hash](https://github.com/hashintel/hash)
@@ -480,7 +484,7 @@ Field customization:
                         Use schema description to populate field docstring
 
 Model customization:
-  --allow-extra-fields  Allow to pass extra fields, if this flag is not passed, extra fields
+  --allow-extra-fields  Allow passing extra fields, if this flag is not passed, extra fields
                         are forbidden.
   --allow-population-by-field-name
                         Allow population by field name
@@ -505,7 +509,7 @@ Model customization:
                         pydantic: datetime, dataclass: str, ...)
   --reuse-model         Reuse models on the field when a module has the model with the same
                         content
-  --target-python-version {3.6,3.7,3.8,3.9,3.10,3.11,3.12}
+  --target-python-version {3.6,3.7,3.8,3.9,3.10,3.11,3.12,3.13}
                         target python version (default: 3.8)
   --treat-dot-as-module
                         treat dotted module names as modules
@@ -577,4 +581,3 @@ See `docs/development-contributing.md` for how to get started!
 ## License
 
 datamodel-code-generator is released under the MIT License. http://www.opensource.org/licenses/mit-license
-

{datamodel_code_generator-0.26.4.dist-info → datamodel_code_generator-0.27.0.dist-info}/RECORD

@@ -1,28 +1,37 @@
-datamodel_code_generator/__init__.py,sha256=OrU_lId2PgS_G7Mhn8ih2AmgGc-CXPMtWDgqONlCzfA,19937
-datamodel_code_generator/__main__.py,sha256=pRnaCIrCFL-C-H7D_ng4AusD3vdjj4Gtk2vYUyoV0mA,21333
-datamodel_code_generator/arguments.py,sha256=ae-RWX7OMSXgNjjIefawoZ9ct1mQwd98nb3yyhqKDws,16306
+datamodel_code_generator/__init__.py,sha256=3PRzUWeQD0qxsojEAidP65pv0NgYlGA3QZ46ZR1yoiE,20226
+datamodel_code_generator/__main__.py,sha256=tjyIaFYJdSTvuLrexxOIuRzlMaMdpZLsmPBz848jnSM,21988
+datamodel_code_generator/arguments.py,sha256=jf5LnhDl6LnCqRs05iAzvnUwt3bFnfUA43PIbv1xhks,16306
 datamodel_code_generator/format.py,sha256=M2lag7AeB4eIHaTORu1A_RzMdIflINbypoeqsEYEEGY,8904
-datamodel_code_generator/http.py,sha256=CwLVnXO4_W_fWKJsHnJp6Q_3GuF3qjCjeAe48Ihawrs,714
-datamodel_code_generator/imports.py,sha256=RagA3hne8OtrbZwDA7TaORQll6tKIzket-A6ShOWf8s,5728
-datamodel_code_generator/model/__init__.py,sha256=PywJfSVTqeTh74jv0uLRIs1dcVrrO2OXPRoP39udqUM,3514
-datamodel_code_generator/model/base.py,sha256=V7E2A89Q1J_K4AFz9ygVMtfJgl6SiQOgA5pN1FPLiHc,14695
+datamodel_code_generator/http.py,sha256=9TkK7um8DgHnjPDMSwoGQdbEDmWcmx0j0eeLgmfo9Vc,790
+datamodel_code_generator/imports.py,sha256=EjeVsxdyEBK4U7a5mn2RrECHt5URJEZKL46Qiwdc0jo,5726
+datamodel_code_generator/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamodel_code_generator/pydantic_patch.py,sha256=OJz79KF1hvZ0oDMsmSaA1Qh0XfPEDq0yBexAyEsHbL0,618
+datamodel_code_generator/reference.py,sha256=BsKVIKGZrLAZHVzc30RfiibYH3qwXk8-7OGtu1MVXyk,26654
+datamodel_code_generator/types.py,sha256=xVXM61xqgYFk1i6DBNhYJp36Z3S-aXuUW2W8j2w5ass,20396
+datamodel_code_generator/util.py,sha256=r07oxWGC8Da6HaT-_wI6fBW9NG834IIZgyy_z2Z-2zc,2826
+datamodel_code_generator/version.py,sha256=KLpVFVnIDy_pSX7qu-Ah9lWn181WwRZ2U3EoOfd7mKs,23
+datamodel_code_generator/model/__init__.py,sha256=VpIso4gfS7rD6mr2bu2RAbsijt4WCwMRFSocUKd20gA,3599
+datamodel_code_generator/model/base.py,sha256=dEMsUSwosHiQTchy37K_EVLJZut6WPHTw_Jb3X4L4mM,14797
 datamodel_code_generator/model/dataclass.py,sha256=Ebn48PRvCOCcyKhxYxgYBbRcpIvXko-VomZ6N8gKrLA,5871
-datamodel_code_generator/model/enum.py,sha256=HTFMCNoHmJRHUoNqQCat3kLbtdmSVX666BubN3bcF1I,3413
+datamodel_code_generator/model/enum.py,sha256=4sSOd7I-57YLdY3hnOZH_o3Cgai-UphO9RvoOUe5s1o,3843
 datamodel_code_generator/model/imports.py,sha256=9-JLfcilbRz9LI4Q9_YAVpRdIusULBaLsMhHE_6j0-w,784
 datamodel_code_generator/model/msgspec.py,sha256=TevwsJDtgEzlpd7TvIpcMZ1HGw6gwLkm6yR86b_w8fY,11514
+datamodel_code_generator/model/rootmodel.py,sha256=8bW7emVQtDGe2iUAmqtlQb607LvTRL0TBSP66pIeNzY,202
+datamodel_code_generator/model/scalar.py,sha256=md13JdHahWqjuASbivhywvy4MQ8sZhCAaClhEvWrY3M,2596
+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/model/pydantic/__init__.py,sha256=AYMjDCtnV4vweYqe1asTRCYdOo8IGLBhd8pEdxyY8ok,1372
-datamodel_code_generator/model/pydantic/base_model.py,sha256=sTxrFItp7wpL0OxBYOGLyyjWWrzGDuV_pFeHPsSQ4Gs,12120
+datamodel_code_generator/model/pydantic/base_model.py,sha256=DlwdmDftlnygHs_BWSzK4YqfO3A6iygeDRWZJJpVxRg,12160
 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=xtkdfQc295ACRvsSig0Zo-mxCw8Xdfu2VXeDbLF_l0Y,13607
+datamodel_code_generator/model/pydantic/types.py,sha256=zWDeJpB3f3dIpAAtTS0UqIqUJSlm_ZU4bAmSnzBcFH8,13612
 datamodel_code_generator/model/pydantic_v2/__init__.py,sha256=PWG0jyOaAIgaoPNKyko2-wihSOwzlkRAyEriagl09Cc,1018
-datamodel_code_generator/model/pydantic_v2/base_model.py,sha256=JHUirMIITztUFtvL1vc_tkE0tRhum3f-JNydmVuzngs,8033
+datamodel_code_generator/model/pydantic_v2/base_model.py,sha256=87vOqeHr1WfRwpwGpspy16IILAl3dizJCFqV81Ql5h4,8129
 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=JV2m0TOPbh-1oHpN_W12KKuNf19RI-V2oehAUJtDIn4,1921
-datamodel_code_generator/model/rootmodel.py,sha256=8bW7emVQtDGe2iUAmqtlQb607LvTRL0TBSP66pIeNzY,202
-datamodel_code_generator/model/scalar.py,sha256=md13JdHahWqjuASbivhywvy4MQ8sZhCAaClhEvWrY3M,2596
+datamodel_code_generator/model/pydantic_v2/types.py,sha256=Y23PAyPxIG1-xmD1dc5HMMoSAaJ6J7V6iqZ_P7_huaw,2000
 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
@@ -31,6 +40,7 @@ datamodel_code_generator/model/template/TypedDictFunction.jinja2,sha256=KjSij5_w
 datamodel_code_generator/model/template/Union.jinja2,sha256=sq7o--2ESUSfIL4kCfgnr5ZXPFa_VeioqbATTY-N-5I,258
 datamodel_code_generator/model/template/dataclass.jinja2,sha256=wRSy2g11Dr1GN9YUl13OZt2xg37bQyFwKn2wEsQIndE,865
 datamodel_code_generator/model/template/msgspec.jinja2,sha256=qMuFOH6SFFh558wImdI6uIjG4Mtam3J_ox8Hmgqkv0g,1174
+datamodel_code_generator/model/template/root.jinja2,sha256=3OTtibxLcGA-FMdR0QDCJUJQgf_kRW0OafeCTPFSFFo,162
 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
 datamodel_code_generator/model/template/pydantic/Config.jinja2,sha256=Ik028qdqQhDfEP207TCbwVv2b5Do1-nRNDPKzBHKzwM,135
@@ -38,23 +48,13 @@ datamodel_code_generator/model/template/pydantic/dataclass.jinja2,sha256=hM4OZTV
 datamodel_code_generator/model/template/pydantic_v2/BaseModel.jinja2,sha256=XdSCvA0hSdjkMtI9CA3M-2xBgieCOV-sWIfQvJPnJ4I,1119
 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=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=0j6bWKv0hBtzgWoG5bOd2YrbCZI7Z9nmqiJFCYzwZqg,61947
-datamodel_code_generator/parser/graphql.py,sha256=MwaLVmEcYky8CRueOYxB2n5MKU4FOmASy9stKIUGBVo,22417
-datamodel_code_generator/parser/jsonschema.py,sha256=x5NrwTDGJ21QqbaSBRMJv6iX0XnoGfe9FG8GaGLIVqc,70881
-datamodel_code_generator/parser/openapi.py,sha256=UMvLzvlNcNxik9ttPvjBl3PGUBhGhYedKcbGnrSNaIQ,26666
-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=GC1MNq8RqbxvWNxCZjTXeQc0Gp9Bp6tuM2xzV-QOv78,26579
-datamodel_code_generator/types.py,sha256=Mtp-owOLiNlbbXU9tTFJH0MBFP3UYyFLL4jENdDD6es,19818
-datamodel_code_generator/util.py,sha256=OmYaVP0z0fGPnvmZQx63qmdMwFnMAIVHfTwSkExpoKk,2829
-datamodel_code_generator/version.py,sha256=AEZHDNPY1s8e-e8dAzmhlWLlyKJsKL0RQW6iWL56XTo,24
-datamodel_code_generator-0.26.4.dist-info/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
-datamodel_code_generator-0.26.4.dist-info/METADATA,sha256=PBa68YPe7sJyUsVqmhoPKRrC0zBzizvVtNeU7FD9r2Y,24955
-datamodel_code_generator-0.26.4.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-datamodel_code_generator-0.26.4.dist-info/entry_points.txt,sha256=bykbUWqOCiKfxJPGe8jpNqTqD1NG7uyRmozdnwzu7rk,76
-datamodel_code_generator-0.26.4.dist-info/RECORD,,
+datamodel_code_generator/parser/base.py,sha256=cqSN9MWNz4Cqj2aWgDmCJmutf2XiCvHuhUXMicwuffQ,62601
+datamodel_code_generator/parser/graphql.py,sha256=vg0tiKsZFRKL_AEbhISXHALr7yqDeiMVZZoqiKC51zA,22571
+datamodel_code_generator/parser/jsonschema.py,sha256=7sCvtoRXuqe4xMPb0jydfNHx4WteBl2YXxUUj7KYoEI,71013
+datamodel_code_generator/parser/openapi.py,sha256=Rqp2OPzrZYUE5-aG4phuQDDkm8efK7pWTcW1jJR1JtY,26780
+datamodel_code_generator-0.27.0.dist-info/METADATA,sha256=UtpLAOsKT58fgJ6yVcy4vyHD-AlBsF4pTv3QO_-Lqqk,24844
+datamodel_code_generator-0.27.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+datamodel_code_generator-0.27.0.dist-info/entry_points.txt,sha256=cJVcHiEViQMANaoM5C1xR5hzmyCqH6hHHMpV8W00in8,77
+datamodel_code_generator-0.27.0.dist-info/licenses/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
+datamodel_code_generator-0.27.0.dist-info/RECORD,,

{datamodel_code_generator-0.26.4.dist-info → datamodel_code_generator-0.27.0.dist-info}/WHEEL

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

datamodel_code_generator-0.27.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+datamodel-codegen = datamodel_code_generator.__main__:main

datamodel_code_generator-0.26.4.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-datamodel-codegen=datamodel_code_generator.__main__:main
-