datamodel-code-generator 0.26.4__tar.gz → 0.26.5__tar.gz

{datamodel_code_generator-0.26.4 → datamodel_code_generator-0.26.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datamodel-code-generator
-Version: 0.26.4
+Version: 0.26.5
 Summary: Datamodel Code Generator
 Home-page: https://github.com/koxudaxi/datamodel-code-generator
 License: MIT
@@ -480,7 +480,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 +505,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

{datamodel_code_generator-0.26.4 → datamodel_code_generator-0.26.5}/README.md

@@ -435,7 +435,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
@@ -460,7 +460,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

{datamodel_code_generator-0.26.4 → datamodel_code_generator-0.26.5}/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
@@ -366,6 +365,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 +402,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-0.26.4 → datamodel_code_generator-0.26.5}/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-0.26.4 → datamodel_code_generator-0.26.5}/datamodel_code_generator/imports.py

@@ -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-0.26.4 → datamodel_code_generator-0.26.5}/datamodel_code_generator/model/base.py

@@ -423,7 +423,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-0.26.4 → datamodel_code_generator-0.26.5}/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.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-0.26.4 → datamodel_code_generator-0.26.5}/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',

{datamodel_code_generator-0.26.4 → datamodel_code_generator-0.26.5}/datamodel_code_generator/parser/jsonschema.py

@@ -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']
 
 

{datamodel_code_generator-0.26.4 → datamodel_code_generator-0.26.5}/datamodel_code_generator/reference.py

@@ -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()
             ):

{datamodel_code_generator-0.26.4 → datamodel_code_generator-0.26.5}/datamodel_code_generator/types.py

@@ -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

datamodel_code_generator-0.26.5/datamodel_code_generator/version.py

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

{datamodel_code_generator-0.26.4 → datamodel_code_generator-0.26.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "datamodel-code-generator"
-version = "0.26.4"
+version = "0.26.5"
 description = "Datamodel Code Generator"
 authors = ["Koudai Aono <koxudaxi@gmail.com>"]
 readme = "README.md"

datamodel_code_generator-0.26.4/datamodel_code_generator/version.py

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