Extract helper methods and reduce code duplication across parsers (#2637)

* Refactor DataModel methods to reduce duplication and improve clarity

* Refactor schema parsing methods to reduce duplication and improve readability

* Refactor data type handling to reduce duplication and improve clarity

* Refactor data type replacement logic to improve clarity and reduce duplication

* Refactor data type replacement logic to improve clarity and reduce duplication

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

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

* Refactor methods to reduce duplication and improve clarity

* Refactor get_dedup_key method to include use_default parameter for improved deduplication logic

* Refactor condition checks and remove redundant comments for improved clarity

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: koxudaxi

src/datamodel_code_generator/model/base.py

@@ -181,6 +181,23 @@ def process_const(self) -> None:
         self.required = False
         self.nullable = False
 
+    def _process_const_as_literal(self) -> None:
+        """Process const values by converting to literal type. Used by subclasses."""
+        if "const" not in self.extras:
+            return
+        const = self.extras["const"]
+        self.const = True
+        self.nullable = False
+        self.replace_data_type(self.data_type.__class__(literals=[const]), clear_old_parent=False)
+        if not self.default:
+            self.default = const
+
+    def self_reference(self) -> bool:
+        """Check if field references its parent model."""
+        if self.parent is None or not self.parent.reference:  # pragma: no cover
+            return False
+        return self.parent.reference.path in {d.reference.path for d in self.data_type.all_data_types if d.reference}
+
     @property
     def type_hint(self) -> str:  # noqa: PLR0911
         """Get the type hint string for this field, including nullability."""
@@ -299,6 +316,20 @@ def copy_deep(self) -> Self:
             copied.data_type.data_types = [dt.copy() for dt in self.data_type.data_types]
         return copied
 
+    def replace_data_type(self, new_data_type: DataType, *, clear_old_parent: bool = True) -> None:
+        """Replace data_type and update parent relationships.
+
+        Args:
+            new_data_type: The new DataType to set.
+            clear_old_parent: If True, clear the old data_type's parent reference.
+                Set to False when the old data_type may be referenced elsewhere.
+        """
+        if self.data_type.parent is self and clear_old_parent:
+            self.data_type.swap_with(new_data_type)
+        else:
+            self.data_type = new_data_type
+            new_data_type.parent = self
+
 
 @lru_cache
 def get_template(template_file_path: Path) -> Template:
@@ -369,7 +400,7 @@ class BaseClassDataType(DataType):
 UNDEFINED: Any = object()
 
 
-class DataModel(TemplateBase, Nullable, ABC):
+class DataModel(TemplateBase, Nullable, ABC):  # noqa: PLR0904
     """Abstract base class for all data model types.
 
     Handles template rendering, import collection, and model relationships.
@@ -483,6 +514,34 @@ def iter_all_fields(self, visited: set[str] | None = None) -> Iterator[DataModel
                 yield from base_class.reference.source.iter_all_fields(visited)
         yield from self.fields
 
+    def get_dedup_key(self, class_name: str | None = None, *, use_default: bool = True) -> tuple[Any, ...]:
+        """Generate hashable key for model deduplication."""
+        from datamodel_code_generator.parser.base import to_hashable  # noqa: PLC0415
+
+        render_class_name = class_name if class_name is not None or not use_default else "M"
+        return tuple(to_hashable(v) for v in (self.render(class_name=render_class_name), self.imports))
+
+    def create_reuse_model(self, base_ref: Reference) -> Self:
+        """Create inherited model with empty fields pointing to base reference."""
+        return self.__class__(
+            fields=[],
+            base_classes=[base_ref],
+            description=self.description,
+            reference=Reference(
+                name=self.name,
+                path=self.reference.path + "/reuse",
+            ),
+            custom_template_dir=self._custom_template_dir,
+        )
+
+    def replace_children_in_models(self, models: list[DataModel], new_ref: Reference) -> None:
+        """Replace reference children if their parent model is in models list."""
+        from datamodel_code_generator.parser.base import get_most_of_parent  # noqa: PLC0415
+
+        for child in self.reference.children[:]:
+            if isinstance(child, DataType) and get_most_of_parent(child) in models:
+                child.replace_reference(new_ref)
+
     def set_base_class(self) -> None:
         """Set up the base class for this model."""
         base_class = self.custom_base_class or self.BASE_CLASS

src/datamodel_code_generator/model/dataclass.py

@@ -106,15 +106,8 @@ class DataModelField(DataModelFieldBase):
     constraints: Optional[Constraints] = None  # noqa: UP045
 
     def process_const(self) -> None:
-        """Process const field constraint."""
-        if "const" not in self.extras:
-            return
-        self.const = True
-        self.nullable = False
-        const = self.extras["const"]
-        self.data_type = self.data_type.__class__(literals=[const])
-        if not self.default:
-            self.default = const
+        """Process const field constraint using literal type."""
+        self._process_const_as_literal()
 
     @property
     def imports(self) -> tuple[Import, ...]:
@@ -124,12 +117,6 @@ def imports(self) -> tuple[Import, ...]:
             return chain_as_tuple(super().imports, (IMPORT_FIELD,))
         return super().imports
 
-    def self_reference(self) -> bool:  # pragma: no cover
-        """Check if field references its parent dataclass."""
-        return isinstance(self.parent, DataClass) and self.parent.reference.path in {
-            d.reference.path for d in self.data_type.all_data_types if d.reference
-        }
-
     @property
     def field(self) -> str | None:
         """For backwards compatibility."""

src/datamodel_code_generator/model/msgspec.py

@@ -221,12 +221,6 @@ class DataModelField(DataModelFieldBase):
     _COMPARE_EXPRESSIONS: ClassVar[set[str]] = {"gt", "ge", "lt", "le", "multiple_of"}
     constraints: Optional[Constraints] = None  # noqa: UP045
 
-    def self_reference(self) -> bool:  # pragma: no cover
-        """Check if field references its parent Struct."""
-        return isinstance(self.parent, Struct) and self.parent.reference.path in {
-            d.reference.path for d in self.data_type.all_data_types if d.reference
-        }
-
     def process_const(self) -> None:
         """Process const field constraint."""
         if "const" not in self.extras:
@@ -235,7 +229,7 @@ def process_const(self) -> None:
         self.nullable = False
         const = self.extras["const"]
         if self.data_type.type == "str" and isinstance(const, str):  # pragma: no cover # Literal supports only str
-            self.data_type = self.data_type.__class__(literals=[const])
+            self.replace_data_type(self.data_type.__class__(literals=[const]), clear_old_parent=False)
 
     def _get_strict_field_constraint_value(self, constraint: str, value: Any) -> Any:
         """Get constraint value with appropriate numeric type."""

src/datamodel_code_generator/model/pydantic/base_model.py

@@ -102,12 +102,6 @@ def field(self) -> str | None:
             return None
         return result
 
-    def self_reference(self) -> bool:
-        """Check if this field references its parent model."""
-        return isinstance(self.parent, BaseModelBase) and self.parent.reference.path in {
-            d.reference.path for d in self.data_type.all_data_types if d.reference
-        }
-
     def _get_strict_field_constraint_value(self, constraint: str, value: Any) -> Any:
         if value is None or constraint not in self._COMPARE_EXPRESSIONS:
             return value

src/datamodel_code_generator/model/pydantic_v2/base_model.py

@@ -125,15 +125,8 @@ def validate_extras(cls, values: Any) -> dict[str, Any]:  # noqa: N805
         return values
 
     def process_const(self) -> None:
-        """Process const field by converting it to a literal type with default value."""
-        if "const" not in self.extras:
-            return
-        self.const = True
-        self.nullable = False
-        const = self.extras["const"]
-        self.data_type = self.data_type.__class__(literals=[const])
-        if not self.default:
-            self.default = const
+        """Process const field constraint using literal type."""
+        self._process_const_as_literal()
 
     def _process_data_in_str(self, data: dict[str, Any]) -> None:
         if self.const:

src/datamodel_code_generator/model/typed_dict.py

@@ -118,15 +118,8 @@ class DataModelField(DataModelFieldBase):
     DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_NOT_REQUIRED,)
 
     def process_const(self) -> None:
-        """Process const field constraint."""
-        if "const" not in self.extras:
-            return
-        self.const = True
-        self.nullable = False
-        const = self.extras["const"]
-        self.data_type = self.data_type.__class__(literals=[const])
-        if not self.default:
-            self.default = const
+        """Process const field constraint using literal type."""
+        self._process_const_as_literal()
 
     @property
     def key(self) -> str: