absfuyu 5.3.0__py3-none-any.whl → 5.5.0__py3-none-any.whl

absfuyu/core/baseclass.py

@@ -3,8 +3,8 @@ Absfuyu: Core
 -------------
 Bases for other features
 
-Version: 5.2.0
-Date updated: 11/03/2025 (dd/mm/yyyy)
+Version: 5.5.0
+Date updated: 23/04/2025 (dd/mm/yyyy)
 """
 
 # Module Package
@@ -13,20 +13,22 @@ __all__ = [
     # Color
     "CLITextColor",
     # Support
-    "MethodNPropertyList",
-    "MethodNPropertyResult",
+    "ClassMembers",
+    "ClassMembersResult",
     # Mixins
-    "ShowAllMethodsMixin",
+    "GetClassMembersMixin",
     "AutoREPRMixin",
     # Class
     "BaseClass",
+    "BaseDataclass",
     # Metaclass
     "PositiveInitArgsMeta",
 ]
 
 # Library
 # ---------------------------------------------------------------------------
-from typing import ClassVar, Literal, NamedTuple, Self
+from dataclasses import dataclass, field
+from typing import Any, ClassVar, Literal, Self
 
 
 # Color
@@ -46,68 +48,145 @@ class CLITextColor:
     RESET = "\x1b[39m"
 
 
-# Mixins
+# Dataclass
+# ---------------------------------------------------------------------------
+# @versionadded("5.5.0")
+@dataclass
+class BaseDataclass:
+    """
+    Base dataclass.
+
+    Contains util methods:
+    - Get fields
+    """
+
+    @classmethod
+    def _get_fields(cls) -> tuple[str, ...]:
+        """
+        Get dataclass's fields.
+
+        Returns
+        -------
+        tuple[str, ...]
+            Dataclass's fields.
+        """
+        _fields = getattr(cls, "__dataclass_fields__", ())
+        return tuple(_fields)
+
+
+# Support
 # ---------------------------------------------------------------------------
-# @versionadded("5.1.0")
-class MethodNPropertyList(NamedTuple):
+# @versionadded("5.5.0")
+@dataclass
+class ClassMembers(BaseDataclass):
     """
-    Contains lists of methods, classmethods, staticmethods, and properties of a class.
+    Contains lists of methods, classmethods, staticmethods,
+    properties, and attributes of a class.
 
     Parameters
     ----------
-    methods : list[str]
+    methods : list[str], optional
         List contains method names of a class.
+        By default inits an empty list.
 
-    classmethods : list[str]
+    classmethods : list[str], optional
         List contains classmethod names of a class.
+        By default inits an empty list.
 
-    staticmethods : list[str]
+    staticmethods : list[str], optional
         List contains staticmethod names of a class.
+        By default inits an empty list.
 
-    properties : list[str]
+    properties : list[str], optional
         List contains property names of a class.
+        By default inits an empty list.
+
+    attributes : list[str], optional
+        List contains attributes of a class instance.
+        By default inits an empty list.
+
+    classattributes : list[str], optional
+        List contains attributes of a class.
+        By default inits an empty list.
+
+
+    Available formats
+    -----------------
+    Alternative format to use with: ``format(<obj>, <format_spec>)``
+    - ``s``/``short`` (This hides attributes with empty value)
     """
 
-    methods: list[str]
-    classmethods: list[str]
-    staticmethods: list[str]
-    properties: list[str]
+    methods: list[str] = field(default_factory=list)
+    classmethods: list[str] = field(default_factory=list)
+    staticmethods: list[str] = field(default_factory=list)
+    properties: list[str] = field(default_factory=list)
+    attributes: list[str] = field(default_factory=list)
+    classattributes: list[str] = field(default_factory=list)
 
-    def __repr__(self) -> str:
+    def __format__(self, format_spec: str) -> str:
         """
-        Only shows list with items in repr
+        Available format:
+        - ``s``/``short`` (This hides attributes with empty value)
+
+        Parameters
+        ----------
+        format_spec : str
+            Format spec
 
-        *This overwrites ``NamedTuple.__repr__()``*
+        Returns
+        -------
+        str
+            Alternative text representation of this class.
         """
-        # return super().__repr__()
+
+        fmt = format_spec.lower().strip()
         cls_name = self.__class__.__name__
-        out = []
-        sep = ", "
-        for x in self._fields:
-            if len(getattr(self, x)) > 0:
-                out.append(f"{x}={repr(getattr(self, x))}")
-        return f"{cls_name}({sep.join(out)})"
+
+        if fmt == "short" or fmt == "s":
+            out = []
+            sep = ", "
+            for x in self._get_fields():
+                if len(getattr(self, x)) > 0:
+                    out.append(f"{x}={repr(getattr(self, x))}")
+            return f"{cls_name}({sep.join(out)})"
+
+        return self.__repr__()
 
     def is_empty(self) -> bool:
         """
-        Checks if all lists (methods, classmethods, staticmethods, properties) are empty.
+        Checks if all fields are empty.
+
+
+        Example:
+        --------
+        >>> ClassMembers().is_empty()
+        True
+
+        >>> ClassMembers(["a"]).is_empty()
+        False
         """
-        # for x in self:
-        #     if len(x) > 0:
-        #         return False
-        # return True
-        return all(len(getattr(self, x)) == 0 for x in self._fields)
+
+        # return all(len(getattr(self, x)) == 0 for x in self._get_fields())
+        for x in self._get_fields():
+            if len(getattr(self, x)) > 0:
+                return False
+        return True
 
     def pack(
         self,
         include_method: bool = True,
         include_classmethod: bool = True,
-        classmethod_indicator: str = "<classmethod>",
+        classmethod_indicator: str = "<cls>",
         include_staticmethod: bool = True,
-        staticmethod_indicator: str = "<staticmethod>",
+        staticmethod_indicator: str = "<stc>",
+        include_attribute: bool = True,
+        include_classattribute: bool = True,
+        classattribute_indicator: str = "<cls>",
     ) -> Self:
         """
-        Combines methods, classmethods, and staticmethods into one list.
+        Combines the following into one list:
+        - methods, classmethods, and staticmethods
+        - attributes and class attributes
 
         Parameters
         ----------
@@ -120,7 +199,7 @@ class MethodNPropertyList(NamedTuple):
         classmethod_indicator : str, optional
             A string used to mark classmethod in the output. This string is appended
             to the name of each classmethod to visually differentiate it from regular
-            instance methods, by default ``"<classmethod>"``
+            instance methods, by default ``"<cls>"``
 
         include_staticmethod : bool, optional
             Whether to include staticmethods in the output, by default ``True``
@@ -128,21 +207,32 @@ class MethodNPropertyList(NamedTuple):
         staticmethod_indicator : str, optional
             A string used to mark staticmethod in the output. This string is appended
             to the name of each staticmethod to visually differentiate it from regular
-            instance methods, by default ``"<staticmethod>"``
+            instance methods, by default ``"<stc>"``
+
+        include_attribute : bool, optional
+            Whether to include attributes in the output, by default ``True``
+
+        include_classattribute : bool, optional
+            Whether to include class attributes in the output, by default ``True``
+
+        classattribute_indicator : str, optional
+            A string used to mark class attribute in the output. This string is appended
+            to the name of each class attribute to visually differentiate it from regular
+            instance attributes, by default ``"<cls>"``
 
         Returns
         -------
         Self
-            MethodNPropertyList (combined methods lists)
+            ClassMembers (combined methods)
 
 
         Example:
         --------
-        >>> test = MethodNPropertyList(["a"], ["b"], ["c"], ["d"])
-        >>> test.pack()
-        MethodNPropertyList(methods=['a', 'b <classmethod>', 'c <staticmethod>'], properties=['d'])
+        >>> ClassMembers(["a"], ["b"], ["c"], ["d"], ["e"], ["f"]).pack().__format__("short")
+        ClassMembers(methods=['a', 'b <cls>', 'c <stc>'], properties=['d'], attributes=['e', 'f <cls>'])
         """
-        new_methods_list = []
+
+        new_methods_list: list[str] = []
 
         # Method
         if include_method:
@@ -160,7 +250,27 @@ class MethodNPropertyList(NamedTuple):
                 [f"{x} {staticmethod_indicator}".strip() for x in self.staticmethods]
             )
 
-        return self.__class__(new_methods_list, [], [], self.properties)
+        new_attributes_list: list[str] = []
+
+        # Attribute
+        if include_attribute:
+            new_attributes_list.extend(self.attributes)
+
+        # Class attribute
+        if include_classattribute:
+            new_attributes_list.extend(
+                [
+                    f"{x} {classattribute_indicator}".strip()
+                    for x in self.classattributes
+                ]
+            )
+
+        # return self.__class__(new_methods_list, [], [], self.properties, [])
+        return self.__class__(
+            methods=new_methods_list,
+            properties=self.properties,
+            attributes=new_attributes_list,
+        )
 
     def sort(self, reverse: bool = False) -> Self:
         """
@@ -174,45 +284,96 @@ class MethodNPropertyList(NamedTuple):
         Returns
         -------
         Self
-            Sorted.
+            Self with sorted values.
 
 
         Example:
         --------
-        >>> test = MethodNPropertyList(["b", "a"], ["d", "c"], ["f", "e"], ["h", "g"])
-        >>> test.sort()
-        MethodNPropertyList(methods=['a', 'b'], classmethods=['c', 'd'], staticmethods=['e', 'f'], properties=['g', 'h'])
+        >>> ClassMembers(["b", "a"], ["d", "c"], ["f", "e"]).sort().__format__("short")
+        ClassMembers(methods=['a', 'b'], classmethods=['c', 'd'], staticmethods=['e', 'f'])
 
-        >>> test.pack().sort()
-        MethodNPropertyList(methods=['a', 'b', 'c <classmethod>', 'd <classmethod>', 'e <staticmethod>', 'f <staticmethod>'], properties=['g', 'h'])
+        >>> ClassMembers(["b", "a"], ["d", "c"], ["f", "e"]).pack().sort().__format__("short")
+        ClassMembers(methods=['a', 'b', 'c <cls>', 'd <cls>', 'e <stc>', 'f <stc>'])
         """
-        sorted_vals = [
-            sorted(getattr(self, field), reverse=reverse) for field in self._fields
+
+        sorted_vals: list[list[str]] = [
+            sorted(getattr(self, field), reverse=reverse)
+            for field in self._get_fields()
         ]
-        # return self._make(sorted_vals)
+
         return self.__class__(*sorted_vals)
 
 
-# @versionadded("5.1.0")
-class MethodNPropertyResult(dict[str, MethodNPropertyList]):
+# @versionadded("5.5.0")
+class ClassMembersResult(dict[str, ClassMembers]):
     """
-    All methods and properties of a class and its parent classes.
-
-    Sorted in ascending order.
+    All members of a class and its parent classes.
     """
 
     _LINELENGTH: ClassVar[int] = 88
 
+    def __format__(self, format_spec: str) -> str:
+        """
+        Available format:
+        - ``s``/``short`` (This hides attributes with empty value)
+
+        Parameters
+        ----------
+        format_spec : str
+            Format spec
+
+        Returns
+        -------
+        str
+            Alternative text representation of this class.
+        """
+
+        fmt = format_spec.lower().strip()
+
+        if fmt == "short" or fmt == "s":
+            # out = {}
+            # for name, member in self.items():
+            #     out[name] = format(member, fmt)
+            # return repr(out)
+            out = []
+            sep = ", "
+            for idx, (name, member) in enumerate(self.items()):
+                mem = format(member, fmt)
+                base = f"{repr(name)}: {mem}"
+
+                # if idx == 0:
+                #     out.append("{" + base)
+                # elif idx + 1 == len(self.items()):
+                #     out.append(base + "}")
+                # else:
+                #     out.append(base)
+                out.append(
+                    ("{" if idx == 0 else "")
+                    + base
+                    + ("}" if idx + 1 == len(self.items()) else "")
+                )
+
+            return sep.join(out)
+
+        return self.__repr__()
+
     def _merge_value(
         self,
-        value_name: Literal["methods", "classmethods", "staticmethods", "properties"],
+        value_name: Literal[
+            "methods",
+            "classmethods",
+            "staticmethods",
+            "properties",
+            "attributes",
+            "classattributes",
+        ],
     ) -> list[str]:
         """
         Merge all specified values from the dictionary.
 
         Parameters
         ----------
-        value_name : Literal["methods", "classmethods", "staticmethods", "properties"]
+        value_name : Literal["methods", "classmethods", "staticmethods", "properties", "attributes", "classattributes"]
             The type of value to merge.
 
         Returns
@@ -220,35 +381,57 @@ class MethodNPropertyResult(dict[str, MethodNPropertyList]):
         list[str]
             A list of merged values.
         """
+
         merged = []
-        for _, methods_n_properties in self.items():
-            if value_name in methods_n_properties._fields:
-                merged.extend(getattr(methods_n_properties, value_name))
+        for _, member in self.items():
+            if value_name in member._get_fields():
+                merged.extend(getattr(member, value_name))
         return merged
 
-    def flatten_value(self) -> MethodNPropertyList:
+    def flatten_value(self, sort: bool = True) -> ClassMembers:
         """
-        Merge all attributes of ``dict``'s values into one ``MethodNPropertyList``.
+        Merge all attributes of ``dict``'s values into one ``ClassMembers``.
+
+        Parameters
+        ----------
+        sort : bool
+            Sort value in ascending order after flatten, by default ``True``
 
         Returns
         -------
-        MethodNPropertyList
-            Flattened value
+        ClassMembers
+            Flattened value.
 
 
         Example:
         --------
-        >>> test = MethodNPropertyResult(
-        ...     ABC=MethodNPropertyList(["a"], ["b"], ["c"], ["d"]),
-        ...     DEF=MethodNPropertyList(["e"], ["f"], ["g"], ["h"]),
+        >>> test = ClassMembersResult(
+        ...     ABC=ClassMembers(["a"], ["b"], ["c"], ["d"], ["y"], ["x"]),
+        ...     DEF=ClassMembers(["e"], ["f"], ["g"], ["h"], ["w"], ["z"]),
         ... )
         >>> test.flatten_value()
-        MethodNPropertyList(methods=["a", "e"], classmethods=["b", "f"], staticmethods=["c", "g"], properties=["d", "h"])
+        ClassMembers(
+            methods=["a", "e"],
+            classmethods=["b", "f"],
+            staticmethods=["c", "g"],
+            properties=["d", "h"],
+            attributes=["w", "y"],
+            classattributes=["x", "z"],
+        )
         """
-        res = []
-        for x in ["methods", "classmethods", "staticmethods", "properties"]:
+
+        res: list[list[str]] = []
+        # for x in [
+        #     "methods",
+        #     "classmethods",
+        #     "staticmethods",
+        #     "properties",
+        #     "attributes",
+        #     "classattributes",
+        # ]:
+        for x in ClassMembers._get_fields():
             res.append(self._merge_value(x))  # type: ignore
-        return MethodNPropertyList._make(res)
+        return ClassMembers(*res).sort() if sort else ClassMembers(*res)
 
     def pack_value(
         self,
@@ -257,9 +440,12 @@ class MethodNPropertyResult(dict[str, MethodNPropertyList]):
         classmethod_indicator: str = "<classmethod>",
         include_staticmethod: bool = True,
         staticmethod_indicator: str = "<staticmethod>",
+        include_attribute: bool = True,
+        include_classattribute: bool = True,
+        classattribute_indicator: str = "<cls>",
     ) -> Self:
         """
-        Join method, classmethod, staticmethod into one list for each value.
+        Join members into one list for each value.
 
         Parameters
         ----------
@@ -282,42 +468,72 @@ class MethodNPropertyResult(dict[str, MethodNPropertyList]):
             to the name of each staticmethod to visually differentiate it from regular
             instance methods, by default ``"<staticmethod>"``
 
+        include_attribute : bool, optional
+            Whether to include attributes in the output, by default ``True``
+
+        include_classattribute : bool, optional
+            Whether to include class attributes in the output, by default ``True``
+
+        classattribute_indicator : str, optional
+            A string used to mark class attribute in the output. This string is appended
+            to the name of each class attribute to visually differentiate it from regular
+            instance attributes, by default ``"<cls>"``
+
         Returns
         -------
         Self
-            MethodNPropertyResult with packed value.
+            ClassMembersResult with packed value.
 
 
         Example:
         --------
-        >>> test = MethodNPropertyResult(
-        ...     ABC=MethodNPropertyList(["a"], ["b"], ["c"], ["d"]),
-        ...     DEF=MethodNPropertyList(["e"], ["f"], ["g"], ["h"]),
+        >>> test = ClassMembersResult(
+        ...     ABC=ClassMembers(["a"], ["b"], ["c"], ["d"], ["y"], ["x"]),
+        ...     DEF=ClassMembers(["e"], ["f"], ["g"], ["h"], ["w"], ["z"]),
         ... )
         >>> test.pack_value()
         {
-            "ABC": MethodNPropertyList(
-                methods=["a", "b <classmethod>", "c <staticmethod>"], properties=["d"]
+            "ABC": ClassMembers(
+                methods=["a", "b <classmethod>", "c <staticmethod>"],
+                classmethods=[],
+                staticmethods=[],
+                properties=["d"],
+                attributes=["y", "x <cls>"],
+                classattributes=[],
             ),
-            "DEF": MethodNPropertyList(
-                methods=["e", "f <classmethod>", "g <staticmethod>"], properties=["h"]
+            "DEF": ClassMembers(
+                methods=["e", "f <classmethod>", "g <staticmethod>"],
+                classmethods=[],
+                staticmethods=[],
+                properties=["h"],
+                attributes=["w", "z <cls>"],
+                classattributes=[],
             ),
         }
         """
-        for class_name, method_prop_list in self.items():
-            self[class_name] = method_prop_list.pack(
+
+        for class_name, members in self.items():
+            self[class_name] = members.pack(
                 include_method=include_method,
                 include_classmethod=include_classmethod,
                 classmethod_indicator=classmethod_indicator,
                 include_staticmethod=include_staticmethod,
                 staticmethod_indicator=staticmethod_indicator,
+                include_attribute=include_attribute,
+                include_classattribute=include_classattribute,
+                classattribute_indicator=classattribute_indicator,
             )
         return self
 
     def prioritize_value(
         self,
         value_name: Literal[
-            "methods", "classmethods", "staticmethods", "properties"
+            "methods",
+            "classmethods",
+            "staticmethods",
+            "properties",
+            "attributes",
+            "classattributes",
         ] = "methods",
     ) -> dict[str, list[str]]:
         """
@@ -325,7 +541,7 @@ class MethodNPropertyResult(dict[str, MethodNPropertyList]):
 
         Parameters
         ----------
-        value_name : Literal["methods", "classmethods", "staticmethods", "properties"], optional
+        value_name : Literal["methods", "classmethods", "staticmethods", "properties", "attributes", "classattributes"], optional
             The type of value to prioritize, by default ``"methods"``
 
         Returns
@@ -336,9 +552,9 @@ class MethodNPropertyResult(dict[str, MethodNPropertyList]):
 
         Example:
         --------
-        >>> test = MethodNPropertyResult(
-        ...     ABC=MethodNPropertyList(["a"], ["b"], ["c"], ["d"]),
-        ...     DEF=MethodNPropertyList(["e"], ["f"], ["g"], ["h"]),
+        >>> test = ClassMembersResult(
+        ...     ABC=ClassMembers(["a"], ["b"], ["c"], ["d"]),
+        ...     DEF=ClassMembers(["e"], ["f"], ["g"], ["h"]),
         ... )
         >>> test.prioritize_value("methods")
         {'ABC': ['a'], 'DEF': ['e']}
@@ -349,23 +565,26 @@ class MethodNPropertyResult(dict[str, MethodNPropertyList]):
         >>> test.prioritize_value("properties")
         {'ABC': ['d'], 'DEF': ['h']}
         """
-        result = {}
-        for k, v in self.items():
-            result[k] = getattr(v, value_name, v.methods)
+
+        result: dict[str, list[str]] = {}
+        for name, member in self.items():
+            result[name] = getattr(member, value_name, member.methods)
         return result
 
     def print_output(
         self,
-        where_to_print: Literal["methods", "properties"] = "methods",
+        where_to_print: Literal["methods", "properties", "attributes"] = "methods",
         print_in_one_column: bool = False,
     ) -> None:
         """
         Beautifully print the result.
 
+        *This method is deprecated.*
+
         Parameters
         ----------
-        where_to_print : Literal["methods", "properties"], optional
-            Whether to print ``self.methods`` or ``self.properties``, by default ``"methods"``
+        where_to_print : Literal["methods", "properties", "attributes"], optional
+            Whether to print ``methods`` or ``properties``, by default ``"methods"``
 
         print_in_one_column : bool, optional
             Whether to print in one column, by default ``False``
@@ -374,12 +593,8 @@ class MethodNPropertyResult(dict[str, MethodNPropertyList]):
         print_func = print  # Can be extended with function parameter
 
         # Loop through each class base
-        for order, (class_base, methods_n_properties) in enumerate(
-            self.items(), start=1
-        ):
-            methods: list[str] = getattr(
-                methods_n_properties, where_to_print, methods_n_properties.methods
-            )
+        for order, (class_base, member) in enumerate(self.items(), start=1):
+            methods: list[str] = getattr(member, where_to_print, member.methods)
             mlen = len(methods)  # How many methods in that class
             if mlen == 0:
                 continue
@@ -412,7 +627,9 @@ class MethodNPropertyResult(dict[str, MethodNPropertyList]):
             print_func("".ljust(self._LINELENGTH, "-"))
 
 
-class ShowAllMethodsMixin:
+# Mixins
+# ---------------------------------------------------------------------------
+class GetClassMembersMixin:
     """
     Show all methods of the class and its parent class minus ``object`` class
 
@@ -421,66 +638,91 @@ class ShowAllMethodsMixin:
 
     Example:
     --------
-    >>> class TestClass(ShowAllMethodsMixin):
+    >>> class TestClass(GetClassMembersMixin):
     ...     def method1(self): ...
-    >>> TestClass._get_methods_and_properties()
+    >>> TestClass._get_members(dunder=False)
     {
-        "ShowAllMethodsMixin": MethodNPropertyList(
-            classmethods=[
-                "_get_methods_and_properties",
-                "show_all_methods",
-                "show_all_properties",
-            ]
-        ),
-        "TestClass": MethodNPropertyList(
-            methods=["method1"]
+        'GetClassMembersMixin': ClassMembers(
+            methods=[],
+            classmethods=['_get_members', ..., 'show_all_methods', 'show_all_properties'],
+            staticmethods=[],
+            properties=[],
+            attributes=[],
+            classattributes=[]
         ),
+        'TestClass': ClassMembers(
+            methods=['method1'],
+            classmethods=[],
+            staticmethods=[],
+            properties=[],
+            attributes=[],
+            classattributes=[]
+        )
     }
     """
 
-    # @versionadded("5.1.0")
+    # @versionadded("5.5.0")
     @classmethod
-    def _get_methods_and_properties(
+    def _get_members(
         cls,
-        skip_private_attribute: bool = True,
-        include_private_method: bool = False,
-    ) -> MethodNPropertyResult:
+        dunder: bool = True,
+        underscore: bool = True,
+        private: bool = True,
+    ) -> ClassMembersResult:
         """
-        Class method to get all methods and properties of the class and its parent classes
+        Class method to get all methods, properties, and attributes
+        of the class and its parent classes.
 
         Parameters
         ----------
-        skip_private_attribute : bool, optional
-            Whether to include attribute with ``__`` (dunder) in the output, by default ``True``
+        dunder : bool, optional
+            Whether to include attribute with ``__`` (dunder)
+            in the output, by default ``True``
 
-        include_private_method : bool, optional
-            Whether to include private method in the output, by default ``False``
+        underscore : bool, optional
+            Whether to include attribute starts with ``_``
+            in the output (will also skip dunder), by default ``True``
+
+        private : bool, optional
+            Whether to include private attribute
+            (``_<__class__.__name__>__<attribute>``)
+            in the output, by default ``True``
 
         Returns
         -------
-        MethodNPropertyResult
-            A dictionary where keys are class names and values are tuples of method names and properties.
+        ClassMembersResult
+            A dictionary where keys are class names
+            and values are tuples of method names and properties.
         """
 
         # MRO in reverse order
         classes = cls.__mro__[::-1]
-        result = {}
+        result: dict[str, ClassMembers] = {}
 
         # For each class base in classes
         for base in classes:
-            methods = []
-            classmethods = []
-            staticmethods = []
-            properties = []
+            methods: list[str] = []
+            classmethods: list[str] = []
+            staticmethods: list[str] = []
+            properties: list[str] = []
+            classattributes: list[str] = []
 
             # Dict items of base
             for name, attr in base.__dict__.items():
+                # Skip dunder
+                if name.startswith("__") and not dunder:
+                    continue
+
                 # Skip private attribute
-                if name.startswith("__") and skip_private_attribute:
+                if base.__name__ in name and not private:
                     continue
 
-                # Skip private Callable
-                if base.__name__ in name and not include_private_method:
+                # Skip underscore
+                if (
+                    name.startswith("_")
+                    and not underscore
+                    and base.__name__ not in name
+                ):
                     continue
 
                 # Methods
@@ -489,22 +731,132 @@ class ShowAllMethodsMixin:
                         staticmethods.append(name)
                     else:
                         methods.append(name)
-                if isinstance(attr, classmethod):
+                elif isinstance(attr, classmethod):
                     classmethods.append(name)
 
                 # Property
-                if isinstance(attr, property):
+                elif isinstance(attr, property):
                     properties.append(name)
 
+                # Class attribute
+                else:
+                    classattributes.append(name)
+
                 # Save to result
-                result[base.__name__] = MethodNPropertyList(
-                    methods=sorted(methods),
-                    classmethods=sorted(classmethods),
-                    staticmethods=sorted(staticmethods),
-                    properties=sorted(properties),
-                )
+                result[base.__name__] = ClassMembers(
+                    methods=methods,
+                    classmethods=classmethods,
+                    staticmethods=staticmethods,
+                    properties=properties,
+                    classattributes=classattributes,
+                ).sort()
+
+        return ClassMembersResult(result)
+
+    # @versionadded("5.5.0")
+    def _get_attributes(
+        self,
+        underscore: bool = True,
+        private: bool = True,
+    ) -> list[str]:
+        """
+        Get all attributes of the class instance.
+
+        Parameters
+        ----------
+        underscore : bool, optional
+            Whether to include attribute starts with ``_``
+            in the output, by default ``True``
+
+        private : bool, optional
+            Whether to include private attribute
+            (``_<__class__.__name__>__<attribute>``)
+            in the output, by default ``True``
+
+        Returns
+        -------
+        list[str]
+            A list contains attributes.
+        """
+
+        # Default output
+        out: list[str] = []
+
+        # Get attributes
+        cls_dict: dict[str, Any] | None = getattr(self, "__dict__", None)
+        cls_slots: tuple[str, ...] | None = getattr(self, "__slots__", None)
+        cls_name: str = self.__class__.__name__
+
+        def _is_valid(item_name: str) -> bool:
+            if not item_name.startswith("_"):
+                return True
+            if cls_name in item_name and private:
+                return True
+            if underscore and cls_name not in item_name:
+                return True
+            return False
+
+        # Check if __dict__ exist and len(__dict__) > 0
+        if cls_dict is not None and len(cls_dict) > 0:
+            # out = [x for x in self.__dict__ if _is_valid(x)]
+            out.extend(list(cls_dict))
 
-        return MethodNPropertyResult(result)
+        # Check if __slots__ exist and len(__slots__) > 0
+        if cls_slots is not None and len(cls_slots) > 0:
+            # Convert __<attribute> to _<self.__class__.__name__>__<attribute>
+            _slot = [f"_{cls_name}{x}" if x.startswith("__") else x for x in cls_slots]
+            out.extend(_slot)
+
+        return [x for x in out if _is_valid(x)]
+
+    # @versionadded("5.5.0")
+    def get_members(
+        self,
+        dunder: bool = False,
+        underscore: bool = True,
+        private: bool = True,
+    ) -> ClassMembersResult:
+        """
+        Get all members of a class instance.
+
+        Parameters
+        ----------
+        dunder : bool, optional
+            Whether to include attribute with ``__`` (dunder)
+            in the output, by default ``False``
+
+        underscore : bool, optional
+            Whether to include attribute starts with ``_``
+            in the output (will also skip dunder), by default ``True``
+
+        private : bool, optional
+            Whether to include private attribute
+            (``_<__class__.__name__>__<attribute>``)
+            in the output, by default ``True``
+
+        Returns
+        -------
+        ClassMembersResult
+            All member of a class instance.
+        """
+        mems = self._get_members(dunder=dunder, underscore=underscore, private=private)
+        attrs = self._get_attributes(underscore=underscore, private=private)
+        mems[self.__class__.__name__].attributes = attrs
+        return mems
+
+    # @remove("6.0.0")
+    # @deprecated("5.5.0")
+    # @versionadded("5.1.0")
+    @classmethod
+    def _get_methods_and_properties(
+        cls,
+        skip_private_attribute: bool = True,
+        include_private_method: bool = False,
+    ) -> ClassMembersResult:
+        """Wrapper of ``cls._get_members``, deprecated"""
+        return cls._get_members(
+            dunder=skip_private_attribute, private=include_private_method
+        )
 
     @classmethod
     def show_all_methods(
@@ -550,8 +902,8 @@ class ShowAllMethodsMixin:
             A dictionary where keys are class names and values are lists of method names.
         """
 
-        result = cls._get_methods_and_properties(
-            include_private_method=include_private_method
+        result = cls._get_members(
+            dunder=False, private=include_private_method
         ).pack_value(
             include_classmethod=include_classmethod,
             classmethod_indicator=classmethod_indicator,
@@ -582,13 +934,12 @@ class ShowAllMethodsMixin:
         """
 
         # result = cls.get_methods_and_properties().prioritize_value("properties")
-        result = MethodNPropertyResult(
+        result = ClassMembersResult(
             {
-                cls.__name__: MethodNPropertyList(
-                    [],
-                    [],
-                    [],
-                    cls._get_methods_and_properties().flatten_value().properties,
+                cls.__name__: ClassMembers(
+                    properties=cls._get_members(dunder=False)
+                    .flatten_value()
+                    .properties,
                 )
             }
         )
@@ -599,6 +950,13 @@ class ShowAllMethodsMixin:
         return result.prioritize_value("properties")
 
 
+# Temp name for backward compability
+# Will be removed at version 6.0.0
+MethodNPropertyList = ClassMembers
+MethodNPropertyResult = ClassMembersResult
+ShowAllMethodsMixin = GetClassMembersMixin
+
+
 class AutoREPRMixin:
     """
     Generate ``repr()`` output as ``<class(param1=any, param2=any, ...)>``
@@ -658,7 +1016,7 @@ class AutoREPRMixin:
 
 # Class
 # ---------------------------------------------------------------------------
-class BaseClass(ShowAllMethodsMixin, AutoREPRMixin):
+class BaseClass(GetClassMembersMixin, AutoREPRMixin):
     """Base class"""
 
     def __str__(self) -> str: