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

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,8 +411,9 @@ 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:
         self.keyword_only = keyword_only
         self.data_type_manager: DataTypeManager = data_type_manager_type(
@@ -512,6 +514,7 @@ class Parser(ABC):
             special_field_name_prefix=special_field_name_prefix,
             remove_special_field_name_prefix=remove_special_field_name_prefix,
             capitalise_enum_members=capitalise_enum_members,
+            no_alias=no_alias,
         )
         self.class_name: Optional[str] = class_name
         self.wrap_string_literal: Optional[bool] = wrap_string_literal
@@ -665,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
@@ -846,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
@@ -866,10 +878,8 @@ class Parser(ABC):
                         ) != property_name:
                             continue
                         literals = discriminator_field.data_type.literals
-                        if (
-                            len(literals) == 1 and literals[0] == type_names[0]
-                            if type_names
-                            else None
+                        if len(literals) == 1 and literals[0] == (
+                            type_names[0] if type_names else None
                         ):
                             has_one_literal = True
                             if isinstance(
@@ -882,7 +892,8 @@ class Parser(ABC):
                                     'tag', discriminator_field.represented_default
                                 )
                                 discriminator_field.extras['is_classvar'] = True
-                            continue
+                            # Found the discriminator field, no need to keep looking
+                            break
                         for (
                             field_data_type
                         ) in discriminator_field.data_type.all_data_types:
@@ -1036,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
@@ -1059,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
@@ -1071,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
@@ -1356,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

@@ -160,6 +160,7 @@ class GraphQLParser(Parser):
         default_field_extras: Optional[Dict[str, Any]] = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
+        no_alias: bool = False,
     ) -> None:
         super().__init__(
             source=source,
@@ -232,6 +233,7 @@ class GraphQLParser(Parser):
             default_field_extras=default_field_extras,
             target_datetime_class=target_datetime_class,
             keyword_only=keyword_only,
+            no_alias=no_alias,
         )
 
         self.data_model_scalar_type = data_model_scalar_type
@@ -371,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(
@@ -397,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
@@ -454,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
 ) | {
@@ -448,6 +448,7 @@ class JsonSchemaParser(Parser):
         default_field_extras: Optional[Dict[str, Any]] = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
+        no_alias: bool = False,
     ) -> None:
         super().__init__(
             source=source,
@@ -520,13 +521,14 @@ class JsonSchemaParser(Parser):
             default_field_extras=default_field_extras,
             target_datetime_class=target_datetime_class,
             keyword_only=keyword_only,
+            no_alias=no_alias,
         )
 
         self.remote_object_cache: DefaultPutDict[str, Dict[str, Any]] = DefaultPutDict()
         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,
@@ -618,6 +620,7 @@ class JsonSchemaParser(Parser):
             use_default_kwarg=self.use_default_kwarg,
             original_name=original_field_name,
             has_default=field.has_default,
+            type_has_null=field.type_has_null,
         )
 
     def get_data_type(self, obj: JsonSchemaObject) -> DataType:
@@ -1715,6 +1718,9 @@ class JsonSchemaParser(Parser):
     def parse_raw(self) -> None:
         for source, path_parts in self._get_context_source_path_parts():
             self.raw_obj = load_yaml(source.text)
+            if self.raw_obj is None:  # pragma: no cover
+                warn(f'{source.path} is empty. Skipping this file')
+                continue
             if self.custom_class_name_generator:
                 obj_name = self.raw_obj.get('title', 'Model')
             else:
@@ -1792,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

@@ -228,6 +228,7 @@ class OpenAPIParser(JsonSchemaParser):
         default_field_extras: Optional[Dict[str, Any]] = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
+        no_alias: bool = False,
     ):
         super().__init__(
             source=source,
@@ -300,6 +301,7 @@ class OpenAPIParser(JsonSchemaParser):
             default_field_extras=default_field_extras,
             target_datetime_class=target_datetime_class,
             keyword_only=keyword_only,
+            no_alias=no_alias,
         )
         self.open_api_scopes: List[OpenAPIScope] = openapi_scopes or [
             OpenAPIScope.Schemas
@@ -314,8 +316,10 @@ class OpenAPIParser(JsonSchemaParser):
         return get_model_by_path(ref_body, ref_path.split('/')[1:])
 
     def get_data_type(self, obj: JsonSchemaObject) -> DataType:
-        # OpenAPI doesn't allow `null` in `type` field and list of types
+        # OpenAPI 3.0 doesn't allow `null` in the `type` field and list of types
         # https://swagger.io/docs/specification/data-models/data-types/#null
+        # OpenAPI 3.1 does allow `null` in the `type` field and is equivalent to
+        # a `nullable` flag on the property itself
         if obj.nullable and self.strict_nullable and isinstance(obj.type, str):
             obj.type = [obj.type, 'null']
 
@@ -363,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])
 
@@ -396,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
                     )
 
@@ -504,6 +510,9 @@ class OpenAPIParser(JsonSchemaParser):
                         has_default=object_schema.has_default
                         if object_schema
                         else False,
+                        type_has_null=object_schema.type_has_null
+                        if object_schema
+                        else None,
                     )
                 )
 
@@ -513,6 +522,7 @@ class OpenAPIParser(JsonSchemaParser):
                     fields=fields,
                     reference=reference,
                     custom_base_class=self.base_class,
+                    custom_template_dir=self.custom_template_dir,
                     keyword_only=self.keyword_only,
                 )
             )
@@ -596,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()
@@ -198,6 +198,7 @@ class FieldNameResolver:
         special_field_name_prefix: Optional[str] = None,
         remove_special_field_name_prefix: bool = False,
         capitalise_enum_members: bool = False,
+        no_alias: bool = False,
     ):
         self.aliases: Mapping[str, str] = {} if aliases is None else {**aliases}
         self.empty_field_name: str = empty_field_name or '_'
@@ -208,6 +209,7 @@ class FieldNameResolver:
         )
         self.remove_special_field_name_prefix: bool = remove_special_field_name_prefix
         self.capitalise_enum_members: bool = capitalise_enum_members
+        self.no_alias = no_alias
 
     @classmethod
     def _validate_field_name(cls, field_name: str) -> bool:
@@ -274,7 +276,10 @@ class FieldNameResolver:
         if field_name in self.aliases:
             return self.aliases[field_name], field_name
         valid_name = self.get_valid_name(field_name, excludes=excludes)
-        return valid_name, None if field_name == valid_name else field_name
+        return (
+            valid_name,
+            None if self.no_alias or field_name == valid_name else field_name,
+        )
 
 
 class PydanticFieldNameResolver(FieldNameResolver):
@@ -354,6 +359,7 @@ class ModelResolver:
         special_field_name_prefix: Optional[str] = None,
         remove_special_field_name_prefix: bool = False,
         capitalise_enum_members: bool = False,
+        no_alias: bool = False,
     ) -> None:
         self.references: Dict[str, Reference] = {}
         self._current_root: Sequence[str] = []
@@ -383,6 +389,7 @@ class ModelResolver:
                 capitalise_enum_members=capitalise_enum_members
                 if k == ModelType.ENUM
                 else False,
+                no_alias=no_alias,
             )
             for k, v in merged_field_name_resolver_classes.items()
         }
@@ -466,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
@@ -491,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()
             ):
@@ -566,11 +573,13 @@ class ModelResolver:
         split_ref = ref.rsplit('/', 1)
         if len(split_ref) == 1:
             original_name = Path(
-                split_ref[0][:-1] if self.is_external_root_ref(path) else split_ref[0]
+                split_ref[0].rstrip('#')
+                if self.is_external_root_ref(path)
+                else split_ref[0]
             ).stem
         else:
             original_name = (
-                Path(split_ref[1][:-1]).stem
+                Path(split_ref[1].rstrip('#')).stem
                 if self.is_external_root_ref(path)
                 else split_ref[1]
             )
@@ -741,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.3'
+version: str = '0.0.0'