datamodel-code-generator 0.25.5__py3-none-any.whl → 0.25.7__py3-none-any.whl

datamodel_code_generator/__init__.py

@@ -299,6 +299,8 @@ def generate(
     custom_file_header_path: Optional[Path] = None,
     custom_formatters: Optional[List[str]] = None,
     custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
+    use_pendulum: bool = False,
+    http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
 ) -> None:
     remote_text_cache: DefaultPutDict[str, str] = DefaultPutDict()
     if isinstance(input_, str):
@@ -308,7 +310,9 @@ def generate(
 
         input_text = remote_text_cache.get_or_put(
             input_.geturl(),
-            default_factory=lambda url: get_body(url, http_headers, http_ignore_tls),
+            default_factory=lambda url: get_body(
+                url, http_headers, http_ignore_tls, http_query_parameters
+            ),
         )
     else:
         input_text = None
@@ -455,6 +459,8 @@ def generate(
         known_third_party=data_model_types.known_third_party,
         custom_formatters=custom_formatters,
         custom_formatters_kwargs=custom_formatters_kwargs,
+        use_pendulum=use_pendulum,
+        http_query_parameters=http_query_parameters,
         **kwargs,
     )
 

datamodel_code_generator/__main__.py

@@ -197,6 +197,23 @@ class Config(BaseModel):
             return [validate_each_item(each_item) for each_item in value]
         return value  # pragma: no cover
 
+    @field_validator('http_query_parameters', mode='before')
+    def validate_http_query_parameters(
+        cls, value: Any
+    ) -> Optional[List[Tuple[str, str]]]:
+        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
+                    return field_name, field_value.lstrip()
+                except ValueError:
+                    raise Error(f'Invalid http query parameter: {each_item!r}')
+            return each_item  # pragma: no cover
+
+        if isinstance(value, list):
+            return [validate_each_item(each_item) for each_item in value]
+        return value  # pragma: no cover
+
     @model_validator(mode='before')
     def validate_additional_imports(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         if values.get('additional_imports') is not None:
@@ -293,6 +310,8 @@ class Config(BaseModel):
     custom_file_header_path: Optional[Path] = None
     custom_formatters: Optional[List[str]] = None
     custom_formatters_kwargs: Optional[TextIOBase] = None
+    use_pendulum: bool = False
+    http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None
 
     def merge_args(self, args: Namespace) -> None:
         set_args = {
@@ -487,6 +506,8 @@ def main(args: Optional[Sequence[str]] = None) -> Exit:
             custom_file_header_path=config.custom_file_header_path,
             custom_formatters=config.custom_formatters,
             custom_formatters_kwargs=custom_formatters_kwargs,
+            use_pendulum=config.use_pendulum,
+            http_query_parameters=config.http_query_parameters,
         )
         return Exit.OK
     except InvalidClassNameError as e:

datamodel_code_generator/arguments.py

@@ -57,6 +57,12 @@ base_options.add_argument(
     metavar='HTTP_HEADER',
     help='Set headers in HTTP requests to the remote host. (example: "Authorization: Basic dXNlcjpwYXNz")',
 )
+base_options.add_argument(
+    '--http-query-parameters',
+    nargs='+',
+    metavar='HTTP_QUERY_PARAMETERS',
+    help='Set query parameters in HTTP requests to the remote host. (example: "ref=branch")',
+)
 base_options.add_argument(
     '--http-ignore-tls',
     help="Disable verification of the remote host's TLS certificate",
@@ -166,6 +172,12 @@ model_options.add_argument(
     action='store_true',
     default=None,
 )
+model_options.add_argument(
+    '--use-pendulum',
+    help='use pendulum instead of datetime',
+    action='store_true',
+    default=False,
+)
 
 # ======================================================================================
 # Typing options for generated models

datamodel_code_generator/http.py

@@ -14,9 +14,14 @@ def get_body(
     url: str,
     headers: Optional[Sequence[Tuple[str, str]]] = None,
     ignore_tls: bool = False,
+    query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
 ) -> str:
     return httpx.get(
-        url, headers=headers, verify=not ignore_tls, follow_redirects=True
+        url,
+        headers=headers,
+        verify=not ignore_tls,
+        follow_redirects=True,
+        params=query_parameters,
     ).text
 
 

datamodel_code_generator/imports.py

@@ -119,3 +119,6 @@ IMPORT_DATETIME = Import.from_full_path('datetime.datetime')
 IMPORT_PATH = Import.from_full_path('pathlib.Path')
 IMPORT_TIME = Import.from_full_path('datetime.time')
 IMPORT_UUID = Import.from_full_path('uuid.UUID')
+IMPORT_PENDULUM_DATE = Import.from_full_path('pendulum.Date')
+IMPORT_PENDULUM_DATETIME = Import.from_full_path('pendulum.DateTime')
+IMPORT_PENDULUM_TIME = Import.from_full_path('pendulum.Time')

datamodel_code_generator/model/msgspec.py

@@ -33,7 +33,7 @@ from datamodel_code_generator.types import chain_as_tuple, get_optional_type
 
 
 def _has_field_assignment(field: DataModelFieldBase) -> bool:
-    return bool(field.field) or not (
+    return not (
         field.required
         or (field.represented_default == 'None' and field.strip_default_none)
     )
@@ -48,7 +48,9 @@ def import_extender(cls: Type[DataModelFieldBaseT]) -> Type[DataModelFieldBaseT]
     @wraps(original_imports.fget)  # type: ignore
     def new_imports(self: DataModelFieldBaseT) -> Tuple[Import, ...]:
         extra_imports = []
-        if self.field:
+        field = self.field
+        # TODO: Improve field detection
+        if field and field.startswith('field('):
             extra_imports.append(IMPORT_MSGSPEC_FIELD)
         if self.field and 'lambda: convert' in self.field:
             extra_imports.append(IMPORT_MSGSPEC_CONVERT)
@@ -126,6 +128,7 @@ class DataModelField(DataModelFieldBase):
         'min_length',
         'max_length',
         'pattern',
+        'examples',
         # 'unique_items', # not supported by msgspec
     }
     _PARSE_METHOD = 'convert'
@@ -176,6 +179,8 @@ class DataModelField(DataModelFieldBase):
 
         if self.default != UNDEFINED and self.default is not None:
             data['default'] = self.default
+        elif not self.required:
+            data['default'] = None
 
         if self.required:
             data = {

datamodel_code_generator/model/pydantic/types.py

@@ -10,6 +10,9 @@ from datamodel_code_generator.imports import (
     IMPORT_DATETIME,
     IMPORT_DECIMAL,
     IMPORT_PATH,
+    IMPORT_PENDULUM_DATE,
+    IMPORT_PENDULUM_DATETIME,
+    IMPORT_PENDULUM_TIME,
     IMPORT_TIME,
     IMPORT_UUID,
 )
@@ -53,11 +56,12 @@ def type_map_factory(
     data_type: Type[DataType],
     strict_types: Sequence[StrictTypes],
     pattern_key: str,
+    use_pendulum: bool,
 ) -> Dict[Types, DataType]:
     data_type_int = data_type(type='int')
     data_type_float = data_type(type='float')
     data_type_str = data_type(type='str')
-    return {
+    result = {
         Types.integer: data_type_int,
         Types.int32: data_type_int,
         Types.int64: data_type_int,
@@ -100,6 +104,12 @@ def type_map_factory(
         Types.array: data_type.from_import(IMPORT_ANY, is_list=True),
         Types.any: data_type.from_import(IMPORT_ANY),
     }
+    if use_pendulum:
+        result[Types.date] = data_type.from_import(IMPORT_PENDULUM_DATE)
+        result[Types.date_time] = data_type.from_import(IMPORT_PENDULUM_DATETIME)
+        result[Types.time] = data_type.from_import(IMPORT_PENDULUM_TIME)
+
+    return result
 
 
 def strict_type_map_factory(data_type: Type[DataType]) -> Dict[StrictTypes, DataType]:
@@ -147,6 +157,7 @@ class DataTypeManager(_DataTypeManager):
         strict_types: Optional[Sequence[StrictTypes]] = None,
         use_non_positive_negative_number_constrained_types: bool = False,
         use_union_operator: bool = False,
+        use_pendulum: bool = False,
     ):
         super().__init__(
             python_version,
@@ -155,6 +166,7 @@ class DataTypeManager(_DataTypeManager):
             strict_types,
             use_non_positive_negative_number_constrained_types,
             use_union_operator,
+            use_pendulum,
         )
 
         self.type_map: Dict[Types, DataType] = self.type_map_factory(
@@ -185,7 +197,7 @@ class DataTypeManager(_DataTypeManager):
         strict_types: Sequence[StrictTypes],
         pattern_key: str,
     ) -> Dict[Types, DataType]:
-        return type_map_factory(data_type, strict_types, pattern_key)
+        return type_map_factory(data_type, strict_types, pattern_key, self.use_pendulum)
 
     def transform_kwargs(
         self, kwargs: Dict[str, Any], filter_: Set[str]

datamodel_code_generator/model/pydantic_v2/__init__.py

@@ -18,9 +18,11 @@ class ConfigDict(_BaseModel):
     title: Optional[str] = None
     populate_by_name: Optional[bool] = None
     allow_extra_fields: Optional[bool] = None
+    from_attributes: Optional[bool] = None
     frozen: Optional[bool] = None
     arbitrary_types_allowed: Optional[bool] = None
     protected_namespaces: Optional[Tuple[str, ...]] = None
+    regex_engine: Optional[str] = None
 
 
 __all__ = [

datamodel_code_generator/model/pydantic_v2/base_model.py

@@ -1,3 +1,4 @@
+import re
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
@@ -218,6 +219,16 @@ class BaseModel(BaseModelBase):
                 config_parameters['arbitrary_types_allowed'] = True
                 break
 
+        for field in self.fields:
+            # Check if a regex pattern uses lookarounds.
+            # Depending on the generation configuration, the pattern may end up in two different places.
+            pattern = (
+                isinstance(field.constraints, Constraints) and field.constraints.pattern
+            ) or (field.data_type.kwargs or {}).get('pattern')
+            if pattern and re.search(r'\(\?<?[=!]', pattern):
+                config_parameters['regex_engine'] = '"python-re"'
+                break
+
         if isinstance(self.extra_template_data.get('config'), dict):
             for key, value in self.extra_template_data['config'].items():
                 config_parameters[key] = value

datamodel_code_generator/model/template/msgspec.jinja2

@@ -18,12 +18,14 @@ class {{ class_name }}:
     {%- if not field.annotated and field.field %}
     {{ field.name }}: {{ field.type_hint }} = {{ field.field }}
     {%- else %}
-    {%- if field.annotated %}
+    {%- if field.annotated and not field.field %}
     {{ field.name }}: {{ field.annotated }}
+    {%- elif field.annotated and field.field %}
+    {{ field.name }}: {{ field.annotated }} = {{ field.field }}
     {%- else %}
     {{ field.name }}: {{ field.type_hint }}
     {%- endif %}
-    {%- if not field.required or field.data_type.is_optional or field.nullable
+    {%- if not field.field and (not field.required or field.data_type.is_optional or field.nullable)
             %} = {{ field.represented_default }}
     {%- endif -%}
     {%- endif %}

datamodel_code_generator/model/template/pydantic_v2/RootModel.jinja2

@@ -10,7 +10,7 @@
 {{ decorator }}
 {% endfor -%}
 
-class {{ class_name }}({{ base_class }}[{{get_type_hint(fields)}}]):{% if comment is defined %}  # {{ comment }}{% endif %}
+class {{ class_name }}({{ base_class }}{%- if fields -%}[{{get_type_hint(fields)}}]{%- endif -%}):{% if comment is defined %}  # {{ comment }}{% endif %}
 {%- if description %}
     """
     {{ description | indent(4) }}

datamodel_code_generator/model/types.py

@@ -58,6 +58,7 @@ class DataTypeManager(_DataTypeManager):
         strict_types: Optional[Sequence[StrictTypes]] = None,
         use_non_positive_negative_number_constrained_types: bool = False,
         use_union_operator: bool = False,
+        use_pendulum: bool = False,
     ):
         super().__init__(
             python_version,
@@ -66,6 +67,7 @@ class DataTypeManager(_DataTypeManager):
             strict_types,
             use_non_positive_negative_number_constrained_types,
             use_union_operator,
+            use_pendulum,
         )
 
         self.type_map: Dict[Types, DataType] = type_map_factory(

datamodel_code_generator/parser/base.py

@@ -390,6 +390,8 @@ class Parser(ABC):
         known_third_party: Optional[List[str]] = None,
         custom_formatters: Optional[List[str]] = None,
         custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
+        use_pendulum: bool = False,
+        http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
     ) -> None:
         self.data_type_manager: DataTypeManager = data_type_manager_type(
             python_version=target_python_version,
@@ -397,6 +399,7 @@ class Parser(ABC):
             use_generic_container_types=use_generic_container_types,
             strict_types=strict_types,
             use_union_operator=use_union_operator,
+            use_pendulum=use_pendulum,
         )
         self.data_model_type: Type[DataModel] = data_model_type
         self.data_model_root_type: Type[DataModel] = data_model_root_type
@@ -490,6 +493,9 @@ class Parser(ABC):
         self.class_name: Optional[str] = class_name
         self.wrap_string_literal: Optional[bool] = wrap_string_literal
         self.http_headers: Optional[Sequence[Tuple[str, str]]] = http_headers
+        self.http_query_parameters: Optional[Sequence[Tuple[str, str]]] = (
+            http_query_parameters
+        )
         self.http_ignore_tls: bool = http_ignore_tls
         self.use_annotated: bool = use_annotated
         if self.use_annotated and not self.field_constraints:  # pragma: no cover
@@ -547,7 +553,7 @@ class Parser(ABC):
         return self.remote_text_cache.get_or_put(
             url,
             default_factory=lambda url_: get_body(
-                url, self.http_headers, self.http_ignore_tls
+                url, self.http_headers, self.http_ignore_tls, self.http_query_parameters
             ),
         )
 
@@ -671,7 +677,8 @@ class Parser(ABC):
         for model in models:
             scoped_model_resolver.add(model.path, model.class_name)
         for model in models:
-            imports.append(model.imports)
+            before_import = model.imports
+            imports.append(before_import)
             for data_type in model.all_data_types:
                 # To change from/import
 
@@ -681,13 +688,19 @@ class Parser(ABC):
                     continue
 
                 if isinstance(data_type, BaseClassDataType):
-                    from_ = ''.join(relative(model.module_name, data_type.full_name))
+                    left, right = relative(model.module_name, data_type.full_name)
+                    from_ = (
+                        ''.join([left, right])
+                        if left.endswith('.')
+                        else '.'.join([left, right])
+                    )
                     import_ = data_type.reference.short_name
                     full_path = from_, import_
                 else:
                     from_, import_ = full_path = relative(
                         model.module_name, data_type.full_name
                     )
+                    import_ = import_.replace('-', '_')
 
                 alias = scoped_model_resolver.add(full_path, import_).name
 
@@ -695,7 +708,7 @@ class Parser(ABC):
                 if from_ and import_ and alias != name:
                     data_type.alias = (
                         alias
-                        if from_ == '.' and data_type.full_name == import_
+                        if data_type.reference.short_name == import_
                         else f'{alias}.{name}'
                     )
 
@@ -709,6 +722,9 @@ class Parser(ABC):
                         reference_path=data_type.reference.path,
                     ),
                 )
+            after_import = model.imports
+            if before_import != after_import:
+                imports.append(after_import)
 
     @classmethod
     def __extract_inherited_enum(cls, models: List[DataModel]) -> None:
@@ -763,8 +779,18 @@ class Parser(ABC):
                                 discriminator_model.path.split('#/')[-1]
                                 != path.split('#/')[-1]
                             ):
-                                # TODO: support external reference
-                                continue
+                                if (
+                                    path.startswith('#/')
+                                    or discriminator_model.path[:-1]
+                                    != path.split('/')[-1]
+                                ):
+                                    t_path = path[str(path).find('/') + 1 :]
+                                    t_disc = discriminator_model.path[
+                                        : str(discriminator_model.path).find('#')
+                                    ].lstrip('../')
+                                    t_disc_2 = '/'.join(t_disc.split('/')[1:])
+                                    if t_path != t_disc and t_path != t_disc_2:
+                                        continue
                             type_names.append(name)
                     else:
                         type_names = [discriminator_model.path.split('/')[-1]]
@@ -891,6 +917,7 @@ class Parser(ABC):
                             name=model.name,
                             path=model.reference.path + '/reuse',
                         ),
+                        custom_template_dir=model._custom_template_dir,
                     )
                     if cached_model_reference.path in require_update_action_models:
                         require_update_action_models.append(inherited_model.path)
@@ -1234,6 +1261,7 @@ class Parser(ABC):
                     init = True
                 else:
                     module = (*module[:-1], f'{module[-1]}.py')
+                    module = tuple(part.replace('-', '_') for part in module)
             else:
                 module = ('__init__.py',)
 

datamodel_code_generator/parser/graphql.py

@@ -156,6 +156,8 @@ class GraphQLParser(Parser):
         known_third_party: Optional[List[str]] = None,
         custom_formatters: Optional[List[str]] = None,
         custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
+        use_pendulum: bool = False,
+        http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
     ) -> None:
         super().__init__(
             source=source,
@@ -221,6 +223,8 @@ class GraphQLParser(Parser):
             known_third_party=known_third_party,
             custom_formatters=custom_formatters,
             custom_formatters_kwargs=custom_formatters_kwargs,
+            use_pendulum=use_pendulum,
+            http_query_parameters=http_query_parameters,
         )
 
         self.data_model_scalar_type = data_model_scalar_type

datamodel_code_generator/parser/jsonschema.py

@@ -438,6 +438,8 @@ class JsonSchemaParser(Parser):
         known_third_party: Optional[List[str]] = None,
         custom_formatters: Optional[List[str]] = None,
         custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
+        use_pendulum: bool = False,
+        http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
     ) -> None:
         super().__init__(
             source=source,
@@ -503,6 +505,8 @@ class JsonSchemaParser(Parser):
             known_third_party=known_third_party,
             custom_formatters=custom_formatters,
             custom_formatters_kwargs=custom_formatters_kwargs,
+            use_pendulum=use_pendulum,
+            http_query_parameters=http_query_parameters,
         )
 
         self.remote_object_cache: DefaultPutDict[str, Dict[str, Any]] = DefaultPutDict()
@@ -1307,6 +1311,10 @@ class JsonSchemaParser(Parser):
             data_type = self.data_type_manager.get_data_type_from_full_path(
                 obj.custom_type_path, is_custom_type=True
             )
+        elif obj.is_array:
+            data_type = self.parse_array_fields(
+                name, obj, get_special_path('array', path)
+            ).data_type
         elif obj.anyOf or obj.oneOf:
             reference = self.model_resolver.add(
                 path, name, loaded=True, class_name=True

datamodel_code_generator/parser/openapi.py

@@ -220,6 +220,8 @@ class OpenAPIParser(JsonSchemaParser):
         known_third_party: Optional[List[str]] = None,
         custom_formatters: Optional[List[str]] = None,
         custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
+        use_pendulum: bool = False,
+        http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
     ):
         super().__init__(
             source=source,
@@ -285,6 +287,8 @@ class OpenAPIParser(JsonSchemaParser):
             known_third_party=known_third_party,
             custom_formatters=custom_formatters,
             custom_formatters_kwargs=custom_formatters_kwargs,
+            use_pendulum=use_pendulum,
+            http_query_parameters=http_query_parameters,
         )
         self.open_api_scopes: List[OpenAPIScope] = openapi_scopes or [
             OpenAPIScope.Schemas

datamodel_code_generator/types.py

@@ -578,6 +578,7 @@ class DataTypeManager(ABC):
         strict_types: Optional[Sequence[StrictTypes]] = None,
         use_non_positive_negative_number_constrained_types: bool = False,
         use_union_operator: bool = False,
+        use_pendulum: bool = False,
     ) -> None:
         self.python_version = python_version
         self.use_standard_collections: bool = use_standard_collections
@@ -587,6 +588,7 @@ class DataTypeManager(ABC):
             use_non_positive_negative_number_constrained_types
         )
         self.use_union_operator: bool = use_union_operator
+        self.use_pendulum: bool = use_pendulum
 
         if (
             use_generic_container_types and python_version == PythonVersion.PY_36

datamodel_code_generator/version.py

@@ -1 +1 @@
-version: str = '0.25.5'
+version: str = '0.25.7'

{datamodel_code_generator-0.25.5.dist-info → datamodel_code_generator-0.25.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datamodel-code-generator
-Version: 0.25.5
+Version: 0.25.7
 Summary: Datamodel Code Generator
 Home-page: https://github.com/koxudaxi/datamodel-code-generator
 License: MIT
@@ -376,6 +376,9 @@ Options:
                         (example: "Authorization: Basic dXNlcjpwYXNz")
   --http-ignore-tls     Disable verification of the remote host's TLS
                         certificate
+  --http-query-parameters QUERY_PARAMETER [QUERY_PARAMETER ...]
+                        Set query parameters in HTTP requests to the remote host.
+                        (example: "ref=branch")
   --input INPUT         Input file/directory (default: stdin)
   --input-file-type {auto,openapi,graphql,jsonschema,json,yaml,dict,csv}
                         Input file type (default: auto)
@@ -447,6 +450,9 @@ Field customization:
                         Fields that have default values.
   --use-field-description
                         Use schema description to populate field docstring
+  --use-pendulum
+                        Use pendulum instead of `datetime` for `date`, 
+                        `datetime`, and `time` data types
 
 Model customization:
   --allow-extra-fields  Allow to pass extra fields, if this flag is not

{datamodel_code_generator-0.25.5.dist-info → datamodel_code_generator-0.25.7.dist-info}/RECORD

@@ -1,23 +1,23 @@
-datamodel_code_generator/__init__.py,sha256=T2FKUpXjyLwcssL2AHYBeIQyCk2_5kvXRJdqLvMD5q0,17707
-datamodel_code_generator/__main__.py,sha256=yoBk5FUlSXTv46EkmD1fRCacddXInKZU9iKZAb3-ECk,18480
-datamodel_code_generator/arguments.py,sha256=N5dOWb_cR5orktDK1FeGy7txVN566mxRlGkvyGeTVaY,14594
+datamodel_code_generator/__init__.py,sha256=zqe2mCNMAgFm9BGJHz8yTAVYVdK30Gt_pOnN7CjKvx4,17951
+datamodel_code_generator/__main__.py,sha256=klyeTja8UY57kcMvWXSp6aEOtNAOCX_biB0sqsCLFfE,19483
+datamodel_code_generator/arguments.py,sha256=kjTIK3mqF7fU5hJ0ZA-3axudgKjpkypLGsc4HikHqFQ,14941
 datamodel_code_generator/format.py,sha256=yTSOf3-jUO4X5NOljAjm-4xYC_uBJV3-RLXUYIvw-yw,8595
-datamodel_code_generator/http.py,sha256=WYScR7rqz8GjgdVPPhFp4PJzgON5DPpO1vmHQLDxYxE,590
-datamodel_code_generator/imports.py,sha256=0PoAG59qI1wujrzcsySFNQRh-po0bRjt7tPI8KDjHg4,5335
+datamodel_code_generator/http.py,sha256=CwLVnXO4_W_fWKJsHnJp6Q_3GuF3qjCjeAe48Ihawrs,714
+datamodel_code_generator/imports.py,sha256=zswV5jMxWwr1-UO0beiyHT9ykhTYGnMTLtTQ6YVougQ,5529
 datamodel_code_generator/model/__init__.py,sha256=A0CqnL87-lY_Te-n-99ya5v7h6l4jE6hOPP_itvcWOc,3091
 datamodel_code_generator/model/base.py,sha256=M1T8L7how4nW0aqGuunzc1LyWVSJ3OuFvRnx1Ig13hA,14019
 datamodel_code_generator/model/dataclass.py,sha256=9meJNWb-XPYYO8kDMSLhSfO6fulGWV7r3_XIM5kA71M,3965
 datamodel_code_generator/model/enum.py,sha256=Giehhtij2DZs2LssSJnG_CIIHsSA7Mkz471GU-Cb5kI,3338
 datamodel_code_generator/model/imports.py,sha256=9-0bd-DvZRjZkWMsmw-gykL8fzTd6M-vQEqS7Rm_ty4,725
-datamodel_code_generator/model/msgspec.py,sha256=_568E91e07NX-A1bOeITOqr3h1Cr9ykecoSYeIZ5PwI,8934
+datamodel_code_generator/model/msgspec.py,sha256=J4U8aroVzBdMkv8CfuOf9mV3X7k83lom-CW4ATpbCfk,9093
 datamodel_code_generator/model/pydantic/__init__.py,sha256=AYMjDCtnV4vweYqe1asTRCYdOo8IGLBhd8pEdxyY8ok,1372
 datamodel_code_generator/model/pydantic/base_model.py,sha256=Y2GSlcLBvQh8hrlwGE3rGLTsQLKxERBts0so5BcUP6Y,11970
 datamodel_code_generator/model/pydantic/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=tvPOPXO04qcPiP0vhf70OHK2Mw2uWGlN8SYiD7jaGKg,12577
-datamodel_code_generator/model/pydantic_v2/__init__.py,sha256=ahhh9sRT9d032dG5gf14M4Q-8MC3P2rQ5Ngo7v_uB6A,865
-datamodel_code_generator/model/pydantic_v2/base_model.py,sha256=ed4wP_DkrsafPh5Clt1wccel9svggJ8MXKy8w1jCQDs,7596
+datamodel_code_generator/model/pydantic/types.py,sha256=GDh1KRforpUIj58TSLSqrbKRnXi8O1qfHT8NaoUYvME,13034
+datamodel_code_generator/model/pydantic_v2/__init__.py,sha256=6IcvuP18MzTf3b6edPz6q1sIxzjuvmXbceQfPgkz25Q,947
+datamodel_code_generator/model/pydantic_v2/base_model.py,sha256=SURD7qLZkQaJOcFqmhcuNOCTb49WWcHPpo0RsjjD0SQ,8129
 datamodel_code_generator/model/pydantic_v2/imports.py,sha256=Q6XC6iE5v4LJvQ2DOXDGFtR-FnGPsaZ56KiiTiF2bIE,191
 datamodel_code_generator/model/pydantic_v2/root_model.py,sha256=ZlaNHfC8PuLJ1--OYm9AXbL1A95z1F421VoraP3mo70,951
 datamodel_code_generator/model/pydantic_v2/types.py,sha256=6KAJXO_SGs5bc8GQScCpowgqjaSmrn9W9iewpWIHack,1440
@@ -30,30 +30,30 @@ datamodel_code_generator/model/template/TypedDictClass.jinja2,sha256=URwp5__WyR8
 datamodel_code_generator/model/template/TypedDictFunction.jinja2,sha256=KjSij5_w4ow4a12SR3orYOndmXGkIvJBBUN735bQ6G0,321
 datamodel_code_generator/model/template/Union.jinja2,sha256=sq7o--2ESUSfIL4kCfgnr5ZXPFa_VeioqbATTY-N-5I,258
 datamodel_code_generator/model/template/dataclass.jinja2,sha256=U-zwO9xoClVcNmNCDBnvZQo0_xcRWsPYh2QfsNMyUsQ,816
-datamodel_code_generator/model/template/msgspec.jinja2,sha256=iDkKjMSN_xk065prQP-rElVosSyiYYeKxV6UEH7IFdA,916
+datamodel_code_generator/model/template/msgspec.jinja2,sha256=DVYCuXV5VpOx-8xiDsaqKwBzDuGAmMuD3dgWCM6-o4o,1070
 datamodel_code_generator/model/template/pydantic/BaseModel.jinja2,sha256=sYZa-47YAXqZrd5cYKVnPrsbDvLkHEJOUd7M0nAosP8,1084
 datamodel_code_generator/model/template/pydantic/BaseModel_root.jinja2,sha256=WDdTXYNTrkIw-B4OvPVxOaETTknLs0zdNuq_iDQ2Bcw,1000
 datamodel_code_generator/model/template/pydantic/Config.jinja2,sha256=Ik028qdqQhDfEP207TCbwVv2b5Do1-nRNDPKzBHKzwM,135
 datamodel_code_generator/model/template/pydantic/dataclass.jinja2,sha256=hM4OZTVhtOokqlPNSdh5drhBXfQLPvbyO88jipSPr5Y,629
 datamodel_code_generator/model/template/pydantic_v2/BaseModel.jinja2,sha256=6Swz3U3vYFGnTFY85SGTmsNUflcJI61oxdz2CgPKaDk,1091
 datamodel_code_generator/model/template/pydantic_v2/ConfigDict.jinja2,sha256=xHvBYrh__32O1xRCSl6_u5zbyYIjB8a5k8fZiTo0spY,149
-datamodel_code_generator/model/template/pydantic_v2/RootModel.jinja2,sha256=jAuFry_aUvY5II3czG2ZZrhEfcPKiULWifDdDDAz1us,1193
+datamodel_code_generator/model/template/pydantic_v2/RootModel.jinja2,sha256=XQBlML7Hm5hN6_AExENNvVc_yxNWijcIfTTbbmegCpE,1223
 datamodel_code_generator/model/template/root.jinja2,sha256=3OTtibxLcGA-FMdR0QDCJUJQgf_kRW0OafeCTPFSFFo,162
 datamodel_code_generator/model/typed_dict.py,sha256=pzUaKLaVDF5rfxAaR1m4FqnhR00eE6AIP30oGTj67fY,4717
-datamodel_code_generator/model/types.py,sha256=GmKGPrpbJRgcsfRv9Khpo26e8DgMrPBnmLw6cpdjdiE,2891
+datamodel_code_generator/model/types.py,sha256=Ti3cEtRQpBYgC4Y5ocAn6Ol-ZbnKG_P7C0nHBX9KtV8,2953
 datamodel_code_generator/model/union.py,sha256=loaVWQi-UHkV4gLfF2JhxLcgZRMsejaoJzGvjTlp_bo,1716
 datamodel_code_generator/parser/__init__.py,sha256=zHbw6RPlJC0SAQjb-XyVlyZhcOu5PfYgPidy6jlUM8M,793
-datamodel_code_generator/parser/base.py,sha256=9Qp1TUYRKzpjYNuELPqaRB_2w-3e7dcVB56GYAzXe14,52868
-datamodel_code_generator/parser/graphql.py,sha256=PuHN3WlCMA0dHuYp0xMmKWHrlhJYryV_LP3831y46YQ,20387
-datamodel_code_generator/parser/jsonschema.py,sha256=ccjDf266lWQzeJr0Mn6-NmnJKIIaFJo15z5bygzJe5Y,69292
-datamodel_code_generator/parser/openapi.py,sha256=Iderij7OytmLchS7EJ6FjCz7rATFp0VlmRz__2uCGvQ,25416
+datamodel_code_generator/parser/base.py,sha256=y9lNLVYWu9SdBrLYgl2wGA-X9-0axtEp6E-1H-gUemQ,54375
+datamodel_code_generator/parser/graphql.py,sha256=n1AEOoJRbmK4Oq3_4M3VgvMaC12e3zBXFMXVrO-d2kI,20594
+datamodel_code_generator/parser/jsonschema.py,sha256=8bEBPFPwqQ4Qbxzjtfzh6E_KYBzH9zCHisg0IJOo2Bk,69658
+datamodel_code_generator/parser/openapi.py,sha256=bGLWGbFysBq4CtM-piuHero_EKW_T0-CS8miEj3Trqw,25623
 datamodel_code_generator/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datamodel_code_generator/reference.py,sha256=EoalUNUP5us31bfMrHDa1iiKqxL8gHrpZKY_IxgZrOg,26347
-datamodel_code_generator/types.py,sha256=NcbLfgrx7nhu6UX1fW-uPOhZnJv1vI5uefe_bYtE_rE,19569
+datamodel_code_generator/types.py,sha256=xPFX0NkgPz5CEz_yqKkZa7wPFr08P0e7X4Ooheoo2Uo,19652
 datamodel_code_generator/util.py,sha256=Lrjj20mmma4Glpfs42sCoGpt1cncalgUGyNZZviqWdU,3692
-datamodel_code_generator/version.py,sha256=50th3mtCHhxAHTTiNr6-p9dr4WfCx_PVJcY39lYUlvc,24
-datamodel_code_generator-0.25.5.dist-info/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
-datamodel_code_generator-0.25.5.dist-info/METADATA,sha256=i-e_XWpioMc7kc0LRle0OiEUysIHEdPNUWWS5uvOoVo,22998
-datamodel_code_generator-0.25.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-datamodel_code_generator-0.25.5.dist-info/entry_points.txt,sha256=bykbUWqOCiKfxJPGe8jpNqTqD1NG7uyRmozdnwzu7rk,76
-datamodel_code_generator-0.25.5.dist-info/RECORD,,
+datamodel_code_generator/version.py,sha256=ELV7HbvS0xRPP1KDziJGhzraG0NcEhduFjGDK9G43kM,24
+datamodel_code_generator-0.25.7.dist-info/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
+datamodel_code_generator-0.25.7.dist-info/METADATA,sha256=uR6VdHb6Kr1oLn7xxwZPzX6lk_kDEI3Zwo6xT2E4Puw,23339
+datamodel_code_generator-0.25.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+datamodel_code_generator-0.25.7.dist-info/entry_points.txt,sha256=bykbUWqOCiKfxJPGe8jpNqTqD1NG7uyRmozdnwzu7rk,76
+datamodel_code_generator-0.25.7.dist-info/RECORD,,