@@ -1,28 +1,25 @@
 # License: BSD 3-Clause
 from __future__ import annotations
 
-import re
 import webbrowser
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING
 
 import xmltodict
 
+import openml
 import openml._api_calls
+from openml.utils import ReprMixin
 
 from .utils import _get_rest_api_type_alias, _tag_openml_base
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable, Sequence
+    from collections.abc import Sequence
 
 
-class OpenMLBase(ABC):
+class OpenMLBase(ReprMixin, ABC):
     """Base object for functionality that is shared across entities."""
 
-    def __repr__(self) -> str:
-        body_fields = self._get_repr_body_fields()
-        return self._apply_repr_template(body_fields)
-
     @property
     @abstractmethod
     def id(self) -> int | None:
@@ -62,34 +59,6 @@ def _get_repr_body_fields(self) -> Sequence[tuple[str, str | int | list[str] | N
         """
         # Should be implemented in the base class.
 
-    def _apply_repr_template(
-        self,
-        body_fields: Iterable[tuple[str, str | int | list[str] | None]],
-    ) -> str:
-        """Generates the header and formats the body for string representation of the object.
-
-        Parameters
-        ----------
-        body_fields: List[Tuple[str, str]]
-           A list of (name, value) pairs to display in the body of the __repr__.
-        """
-        # We add spaces between capitals, e.g. ClassificationTask -> Classification Task
-        name_with_spaces = re.sub(
-            r"(\w)([A-Z])",
-            r"\1 \2",
-            self.__class__.__name__[len("OpenML") :],
-        )
-        header_text = f"OpenML {name_with_spaces}"
-        header = f"{header_text}\n{'=' * len(header_text)}\n"
-
-        _body_fields: list[tuple[str, str | int | list[str]]] = [
-            (k, "None" if v is None else v) for k, v in body_fields
-        ]
-        longest_field_name_length = max(len(name) for name, _ in _body_fields)
-        field_line_format = f"{{:.<{longest_field_name_length}}}: {{}}"
-        body = "\n".join(field_line_format.format(name, value) for name, value in _body_fields)
-        return header + body
-
     @abstractmethod
     def _to_dict(self) -> dict[str, dict]:
         """Creates a dictionary representation of self.
 
@@ -8,8 +8,10 @@
 
     from IPython.lib import pretty
 
+from openml.utils import ReprMixin
 
-class OpenMLDataFeature:  # noqa: PLW1641, RUF100
+
+class OpenMLDataFeature(ReprMixin):
     """
     Data Feature (a.k.a. Attribute) object.
 
@@ -75,11 +77,29 @@ def __init__(  # noqa: PLR0913,PLR0917
         self.number_missing_values = number_missing_values
         self.ontologies = ontologies
 
-    def __repr__(self) -> str:
-        return f"[{self.index} - {self.name} ({self.data_type})]"
+    def _get_repr_body_fields(self) -> Sequence[tuple[str, str | int | list[str] | None]]:
+        """Collect all information to display in the __repr__ body."""
+        fields: dict[str, int | str | None] = {
+            "Index": self.index,
+            "Name": self.name,
+            "Data Type": self.data_type,
+        }
+        return list(fields.items())
 
     def __eq__(self, other: Any) -> bool:
         return isinstance(other, OpenMLDataFeature) and self.__dict__ == other.__dict__
 
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.index,
+                self.name,
+                self.data_type,
+                tuple(self.nominal_values) if self.nominal_values is not None else None,
+                self.number_missing_values,
+                tuple(self.ontologies) if self.ontologies is not None else None,
+            )
+        )
+
     def _repr_pretty_(self, pp: pretty.PrettyPrinter, cycle: bool) -> None:  # noqa: ARG002
         pp.text(str(self))
@@ -2,13 +2,17 @@
 from __future__ import annotations
 
 from dataclasses import asdict, dataclass
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import openml.flows
+from openml.utils import ReprMixin
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
 
-@dataclass
-class OpenMLSetup:
+
+@dataclass(repr=False)
+class OpenMLSetup(ReprMixin):
     """Setup object (a.k.a. Configuration).
 
     Parameters
@@ -44,31 +48,22 @@ def _to_dict(self) -> dict[str, Any]:
             else None,
         }
 
-    def __repr__(self) -> str:
-        header = "OpenML Setup"
-        header = f"{header}\n{'=' * len(header)}\n"
-
-        fields = {
+    def _get_repr_body_fields(self) -> Sequence[tuple[str, str | int | list[str] | None]]:
+        """Collect all information to display in the __repr__ body."""
+        fields: dict[str, int | str | None] = {
             "Setup ID": self.setup_id,
             "Flow ID": self.flow_id,
             "Flow URL": openml.flows.OpenMLFlow.url_for_id(self.flow_id),
-            "# of Parameters": (
-                len(self.parameters) if self.parameters is not None else float("nan")
-            ),
+            "# of Parameters": (len(self.parameters) if self.parameters is not None else "nan"),
         }
 
         # determines the order in which the information will be printed
         order = ["Setup ID", "Flow ID", "Flow URL", "# of Parameters"]
-        _fields = [(key, fields[key]) for key in order if key in fields]
-
-        longest_field_name_length = max(len(name) for name, _ in _fields)
-        field_line_format = f"{{:.<{longest_field_name_length}}}: {{}}"
-        body = "\n".join(field_line_format.format(name, value) for name, value in _fields)
-        return header + body
+        return [(key, fields[key]) for key in order if key in fields]
 
 
-@dataclass
-class OpenMLParameter:
+@dataclass(repr=False)
+class OpenMLParameter(ReprMixin):
     """Parameter object (used in setup).
 
     Parameters
@@ -112,11 +107,9 @@ def _to_dict(self) -> dict[str, Any]:
         result["id"] = result.pop("input_id")
         return result
 
-    def __repr__(self) -> str:
-        header = "OpenML Parameter"
-        header = f"{header}\n{'=' * len(header)}\n"
-
-        fields = {
+    def _get_repr_body_fields(self) -> Sequence[tuple[str, str | int | list[str] | None]]:
+        """Collect all information to display in the __repr__ body."""
+        fields: dict[str, int | str | None] = {
             "ID": self.id,
             "Flow ID": self.flow_id,
             # "Flow Name": self.flow_name,
@@ -145,9 +138,4 @@ def __repr__(self) -> str:
             parameter_default,
             parameter_value,
         ]
-        _fields = [(key, fields[key]) for key in order if key in fields]
-
-        longest_field_name_length = max(len(name) for name, _ in _fields)
-        field_line_format = f"{{:.<{longest_field_name_length}}}: {{}}"
-        body = "\n".join(field_line_format.format(name, value) for name, value in _fields)
-        return header + body
+        return [(key, fields[key]) for key in order if key in fields]
@@ -9,7 +9,10 @@
 import arff  # type: ignore
 import numpy as np
 
+from openml.utils import ReprMixin
+
 if TYPE_CHECKING:
+    from collections.abc import Sequence
     from pathlib import Path
 
 
@@ -20,7 +23,7 @@ class Split(NamedTuple):
     test: np.ndarray
 
 
-class OpenMLSplit:  # noqa: PLW1641, RUF100
+class OpenMLSplit(ReprMixin):
     """OpenML Split object.
 
     This class manages train-test splits for a dataset across multiple
@@ -65,6 +68,22 @@ def __init__(
         self.folds = len(self.split[0])
         self.samples = len(self.split[0][0])
 
+    def _get_repr_body_fields(self) -> Sequence[tuple[str, str | int | list[str] | None]]:
+        """Collect all information to display in the __repr__ body."""
+        fields: dict[str, int | str | None] = {
+            "Name": self.name,
+            "Description": (
+                self.description if len(self.description) <= 80 else self.description[:77] + "..."
+            ),
+            "Repeats": self.repeats,
+            "Folds": self.folds,
+            "Samples": self.samples,
+        }
+
+        order = ["Name", "Description", "Repeats", "Folds", "Samples"]
+
+        return [(key, fields[key]) for key in order if key in fields]
+
     def __eq__(self, other: Any) -> bool:
         if (
             (not isinstance(self, type(other)))
@@ -92,6 +111,8 @@ def __eq__(self, other: Any) -> bool:
                 return False
         return True
 
+    __hash__ = None  # type: ignore
+
     @classmethod
     def _from_arff_file(cls, filename: Path) -> OpenMLSplit:  # noqa: C901, PLR0912
         repetitions = None