add dataclass arguments (#2437)

* Feature/dataclass arguments (#1)

Added dataclass_arguments and tests

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* fix ci (#2)

Co-authored-by: Khaled Radmal <khaled>

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* fix ci (#3)

Co-authored-by: Khaled Radmal <khaled>

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* fix ci

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* fix ci

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* updated readme (#4)

Co-authored-by: Khaled Radmal <khaled>

* Fix/ci failed (#5)

* fix ci

* added # noqa: UP045

---------

Co-authored-by: Khaled Radmal <khaled>

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* default encoding: utf-8

* Update docs/index.md

Co-authored-by: Antonio Spadaro <ilovelinux@users.noreply.github.com>

* Tests for jsonschema

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Import Types from jsonschema parser in test_param.py

* Refactor data type assignment in test_param.py to use built-in str type

* Refactor dataclass argument handling in _create_data_model and add generated dataclass definitions for Star Wars entities

* Refactor dataclass argument handling in _create_data_model for improved readability

* Add tests for Pydantic model handling in GraphQL and JSON Schema code generation

* Add test for GraphQL code generation with frozen and keyword-only dataclass

* Refactor dataclass argument handling to simplify merging of existing arguments

* Remove .venv/ from .gitignore to allow virtual environment tracking

* Enhance dataclass_arguments handling in data model creation for improved flexibility and compatibility

* feat: update dataclass_arguments type to DataclassArguments for improved type safety

* refactor: simplify frozen_dataclasses tests with parameterization

* feat: update JSON parsing to use DataclassArguments for improved validation

* fix: cast result to DataclassArguments for type safety in argument parsing

* test: add parameterized tests for _create_data_model in GraphQLParser

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Khaled Radmal <khaled>
Co-authored-by: Bernát Gábor <gaborjbernat@gmail.com>
Co-authored-by: Antonio Spadaro <ilovelinux@users.noreply.github.com>
Co-authored-by: Koudai Aono <koxudaxi@gmail.com>

Author: 5 people

README.md

@@ -450,6 +450,10 @@ Model customization:
   --collapse-root-models
                         Models generated with a root-type field will be merged into the
                         models using that root-type model
+  --dataclass-arguments DATACLASS_ARGUMENTS
+                        Custom dataclass arguments as a JSON dictionary, e.g. ''{"frozen":
+                        true, "kw_only": true}''. Overrides --frozen-dataclasses and similar
+                        flags.
   --disable-appending-item-suffix
                         Disable appending `Item` suffix to model name in an array
   --disable-timestamp   Disable timestamp on file headers

docs/index.md

@@ -442,6 +442,10 @@ Model customization:
   --collapse-root-models
                         Models generated with a root-type field will be merged into the
                         models using that root-type model
+  --dataclass-arguments DATACLASS_ARGUMENTS
+                        Custom dataclass arguments as a JSON dictionary, e.g. ''{"frozen":
+                        true, "kw_only": true}''. Overrides --frozen-dataclasses and similar
+                        flags.
   --disable-appending-item-suffix
                         Disable appending `Item` suffix to model name in an array
   --disable-timestamp   Disable timestamp on file headers

src/datamodel_code_generator/__init__.py

@@ -28,7 +28,7 @@
 
 import yaml
 import yaml.parser
-from typing_extensions import TypeAlias, TypeAliasType
+from typing_extensions import TypeAlias, TypeAliasType, TypedDict
 
 import datamodel_code_generator.pydantic_patch  # noqa: F401
 from datamodel_code_generator.format import (
@@ -56,6 +56,22 @@
 
 T = TypeVar("T")
 
+
+class DataclassArguments(TypedDict, total=False):
+    """Arguments for @dataclass decorator."""
+
+    init: bool
+    repr: bool
+    eq: bool
+    order: bool
+    unsafe_hash: bool
+    frozen: bool
+    match_args: bool
+    kw_only: bool
+    slots: bool
+    weakref_slot: bool
+
+
 if not TYPE_CHECKING:
     YamlScalar: TypeAlias = Union[str, int, float, bool, None]
     if PYDANTIC_V2:
@@ -340,6 +356,7 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
     no_alias: bool = False,
     formatters: list[Formatter] = DEFAULT_FORMATTERS,
     parent_scoped_naming: bool = False,
+    dataclass_arguments: DataclassArguments | None = None,
     disable_future_imports: bool = False,
     type_mappings: list[str] | None = None,
 ) -> None:
@@ -361,6 +378,13 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
     else:
         input_text = None
 
+    if dataclass_arguments is None:
+        dataclass_arguments = {}
+        if frozen_dataclasses:
+            dataclass_arguments["frozen"] = True
+        if keyword_only:
+            dataclass_arguments["kw_only"] = True
+
     if isinstance(input_, Path) and not input_.is_absolute():
         input_ = input_.expanduser().resolve()
     if input_file_type == InputFileType.Auto:
@@ -562,6 +586,7 @@ def get_header_and_first_line(csv_file: IO[str]) -> dict[str, Any]:
         formatters=formatters,
         encoding=encoding,
         parent_scoped_naming=parent_scoped_naming,
+        dataclass_arguments=dataclass_arguments,
         type_mappings=type_mappings,
         **kwargs,
     )

src/datamodel_code_generator/__main__.py

@@ -19,6 +19,7 @@
 from typing_extensions import TypeAlias
 
 from datamodel_code_generator import (
+    DataclassArguments,
     DataModelType,
     Error,
     InputFileType,
@@ -402,6 +403,7 @@ def validate_root(cls, values: dict[str, Any]) -> dict[str, Any]:  # noqa: N805
     output_datetime_class: Optional[DatetimeClassType] = None  # noqa: UP045
     keyword_only: bool = False
     frozen_dataclasses: bool = False
+    dataclass_arguments: Optional[DataclassArguments] = None  # noqa: UP045
     no_alias: bool = False
     formatters: list[Formatter] = DEFAULT_FORMATTERS
     parent_scoped_naming: bool = False
@@ -660,6 +662,7 @@ def main(args: Sequence[str] | None = None) -> Exit:  # noqa: PLR0911, PLR0912,
             no_alias=config.no_alias,
             formatters=config.formatters,
             parent_scoped_naming=config.parent_scoped_naming,
+            dataclass_arguments=config.dataclass_arguments,
             disable_future_imports=config.disable_future_imports,
             type_mappings=config.type_mappings,
         )

src/datamodel_code_generator/arguments.py

@@ -7,13 +7,14 @@
 
 from __future__ import annotations
 
+import json
 import locale
-from argparse import ArgumentParser, BooleanOptionalAction, HelpFormatter, Namespace
+from argparse import ArgumentParser, ArgumentTypeError, BooleanOptionalAction, HelpFormatter, Namespace
 from operator import attrgetter
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
-from datamodel_code_generator import DataModelType, InputFileType, OpenAPIScope
+from datamodel_code_generator import DataclassArguments, DataModelType, InputFileType, OpenAPIScope
 from datamodel_code_generator.format import DatetimeClassType, Formatter, PythonVersion
 from datamodel_code_generator.model.pydantic_v2 import UnionMode
 from datamodel_code_generator.parser import LiteralType
@@ -28,6 +29,28 @@
 namespace = Namespace(no_color=False)
 
 
+def _dataclass_arguments(value: str) -> DataclassArguments:
+    """Parse JSON string and validate it as DataclassArguments."""
+    try:
+        result = json.loads(value)
+    except json.JSONDecodeError as e:
+        msg = f"Invalid JSON: {e}"
+        raise ArgumentTypeError(msg) from e
+    if not isinstance(result, dict):
+        msg = f"Expected a JSON dictionary, got {type(result).__name__}"
+        raise ArgumentTypeError(msg)
+    valid_keys = set(DataclassArguments.__annotations__.keys())
+    invalid_keys = set(result.keys()) - valid_keys
+    if invalid_keys:
+        msg = f"Invalid keys: {invalid_keys}. Valid keys are: {valid_keys}"
+        raise ArgumentTypeError(msg)
+    for key, val in result.items():
+        if not isinstance(val, bool):
+            msg = f"Expected bool for '{key}', got {type(val).__name__}"
+            raise ArgumentTypeError(msg)
+    return cast("DataclassArguments", result)
+
+
 class SortingHelpFormatter(HelpFormatter):
     """Help formatter that sorts arguments and adds color to section headers."""
 
@@ -179,6 +202,16 @@ def start_section(self, heading: str | None) -> None:
     action="store_true",
     default=None,
 )
+model_options.add_argument(
+    "--dataclass-arguments",
+    type=_dataclass_arguments,
+    default=None,
+    help=(
+        "Custom dataclass arguments as a JSON dictionary, "
+        'e.g. \'{"frozen": true, "kw_only": true}\'. '
+        "Overrides --frozen-dataclasses and similar flags."
+    ),
+)
 model_options.add_argument(
     "--reuse-model",
     help="Reuse models on the field when a module has the model with the same content",

src/datamodel_code_generator/model/base.py

@@ -39,6 +39,8 @@
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
+    from datamodel_code_generator import DataclassArguments
+
 TEMPLATE_DIR: Path = Path(__file__).parents[0] / "template"
 
 ALL_MODEL: str = "#all#"
@@ -357,10 +359,12 @@ def __init__(  # noqa: PLR0913
         keyword_only: bool = False,
         frozen: bool = False,
         treat_dot_as_module: bool = False,
+        dataclass_arguments: DataclassArguments | None = None,
     ) -> None:
         """Initialize a data model with fields, base classes, and configuration."""
         self.keyword_only = keyword_only
         self.frozen = frozen
+        self.dataclass_arguments: DataclassArguments = dataclass_arguments if dataclass_arguments is not None else {}
         if not self.TEMPLATE_FILE_PATH:
             msg = "TEMPLATE_FILE_PATH is undefined"
             raise Exception(msg)  # noqa: TRY002
@@ -538,8 +542,7 @@ def render(self, *, class_name: str | None = None) -> str:
             base_class=self.base_class,
             methods=self.methods,
             description=self.description,
-            keyword_only=self.keyword_only,
-            frozen=self.frozen,
+            dataclass_arguments=self.dataclass_arguments,
             **self.extra_template_data,
         )
 

src/datamodel_code_generator/model/dataclass.py

@@ -7,7 +7,7 @@
 
 from typing import TYPE_CHECKING, Any, ClassVar, Optional
 
-from datamodel_code_generator import DatetimeClassType, PythonVersion, PythonVersionMin
+from datamodel_code_generator import DataclassArguments, DatetimeClassType, PythonVersion, PythonVersionMin
 from datamodel_code_generator.imports import (
     IMPORT_DATE,
     IMPORT_DATETIME,
@@ -61,6 +61,7 @@ def __init__(  # noqa: PLR0913
         keyword_only: bool = False,
         frozen: bool = False,
         treat_dot_as_module: bool = False,
+        dataclass_arguments: DataclassArguments | None = None,
     ) -> None:
         """Initialize dataclass with fields sorted by field assignment requirement."""
         super().__init__(
@@ -80,6 +81,14 @@ def __init__(  # noqa: PLR0913
             frozen=frozen,
             treat_dot_as_module=treat_dot_as_module,
         )
+        if dataclass_arguments is not None:
+            self.dataclass_arguments = dataclass_arguments
+        else:
+            self.dataclass_arguments = {}
+            if frozen:
+                self.dataclass_arguments["frozen"] = True
+            if keyword_only:
+                self.dataclass_arguments["kw_only"] = True
 
 
 class DataModelField(DataModelFieldBase):

src/datamodel_code_generator/model/template/dataclass.jinja2

@@ -1,13 +1,16 @@
 {% for decorator in decorators -%}
 {{ decorator }}
 {% endfor -%}
+{%- set args = [] %}
+{%- for k, v in (dataclass_arguments or {}).items() %}
+    {%- if v is not none and v is not false %}
+        {%- set _ = args.append(k ~ '=' ~ (v|pprint)) %}
+    {%- endif %}
+{%- endfor %}
+{%- if args %}
+@dataclass({{ args | join(', ') }})
+{%- else %}
 @dataclass
-{%- if keyword_only or frozen -%}
-(
-{%- if keyword_only -%}kw_only=True{%- endif -%}
-{%- if keyword_only and frozen -%}, {% endif -%}
-{%- if frozen -%}frozen=True{%- endif -%}
-)
 {%- endif %}
 {%- if base_class %}
 class {{ class_name }}({{ base_class }}):

src/datamodel_code_generator/parser/base.py

@@ -55,6 +55,8 @@
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator, Mapping, Sequence
 
+    from datamodel_code_generator import DataclassArguments
+
 
 @runtime_checkable
 class HashableComparable(Hashable, Protocol):
@@ -429,6 +431,7 @@ def __init__(  # noqa: PLR0913, PLR0915
         no_alias: bool = False,
         formatters: list[Formatter] = DEFAULT_FORMATTERS,
         parent_scoped_naming: bool = False,
+        dataclass_arguments: DataclassArguments | None = None,
         type_mappings: list[str] | None = None,
     ) -> None:
         """Initialize the Parser with configuration options."""
@@ -487,6 +490,7 @@ def __init__(  # noqa: PLR0913, PLR0915
         self.use_title_as_name: bool = use_title_as_name
         self.use_operation_id_as_name: bool = use_operation_id_as_name
         self.use_unique_items_as_set: bool = use_unique_items_as_set
+        self.dataclass_arguments = dataclass_arguments
 
         if base_path:
             self.base_path = base_path

src/datamodel_code_generator/parser/graphql.py

@@ -15,6 +15,7 @@
 from urllib.parse import ParseResult
 
 from datamodel_code_generator import (
+    DataclassArguments,
     DefaultPutDict,
     LiteralType,
     PythonVersion,
@@ -173,6 +174,7 @@ def __init__(  # noqa: PLR0913
         no_alias: bool = False,
         formatters: list[Formatter] = DEFAULT_FORMATTERS,
         parent_scoped_naming: bool = False,
+        dataclass_arguments: DataclassArguments | None = None,
         type_mappings: list[str] | None = None,
     ) -> None:
         """Initialize the GraphQL parser with configuration options."""
@@ -255,6 +257,7 @@ def __init__(  # noqa: PLR0913
             no_alias=no_alias,
             formatters=formatters,
             parent_scoped_naming=parent_scoped_naming,
+            dataclass_arguments=dataclass_arguments,
             type_mappings=type_mappings,
         )
 
@@ -310,10 +313,26 @@ def _resolve_types(self, paths: list[str], schema: graphql.GraphQLSchema) -> Non
                 self.support_graphql_types[resolved_type].append(type_)
 
     def _create_data_model(self, model_type: type[DataModel] | None = None, **kwargs: Any) -> DataModel:
-        """Create data model instance with conditional frozen parameter for DataClass."""
+        """Create data model instance with dataclass_arguments support for DataClass."""
         data_model_class = model_type or self.data_model_type
         if issubclass(data_model_class, DataClass):
-            kwargs["frozen"] = self.frozen_dataclasses
+            # Use dataclass_arguments from kwargs, or fall back to self.dataclass_arguments
+            # If both are None, construct from legacy frozen_dataclasses/keyword_only flags
+            dataclass_arguments = kwargs.pop("dataclass_arguments", None)
+            if dataclass_arguments is None:
+                dataclass_arguments = self.dataclass_arguments
+            if dataclass_arguments is None:
+                # Construct from legacy flags for library API compatibility
+                dataclass_arguments = {}
+                if self.frozen_dataclasses:
+                    dataclass_arguments["frozen"] = True
+                if self.keyword_only:
+                    dataclass_arguments["kw_only"] = True
+            kwargs["dataclass_arguments"] = dataclass_arguments
+            kwargs.pop("frozen", None)
+            kwargs.pop("keyword_only", None)
+        else:
+            kwargs.pop("dataclass_arguments", None)
         return data_model_class(**kwargs)
 
     def _typename_field(self, name: str) -> DataModelFieldBase:
@@ -505,6 +524,7 @@ def parse_object_like(
             description=obj.description,
             keyword_only=self.keyword_only,
             treat_dot_as_module=self.treat_dot_as_module,
+            dataclass_arguments=self.dataclass_arguments,
         )
         self.results.append(data_model_type)