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

absfuyu/tools/inspector.py

@@ -3,35 +3,193 @@ Absfuyu: Inspector
 ------------------
 Inspector
 
-Version: 5.2.0
-Date updated: 16/03/2025 (dd/mm/yyyy)
+Version: 5.5.0
+Date updated: 23/04/2025 (dd/mm/yyyy)
 """
 
 # Module level
 # ---------------------------------------------------------------------------
 __all__ = ["Inspector", "inspect_all"]
 
+
 # Library
 # ---------------------------------------------------------------------------
 import inspect as _inspect
 import os
+from collections.abc import Callable
+from dataclasses import dataclass
 from functools import partial
 from textwrap import TextWrapper
 from textwrap import shorten as text_shorten
-from typing import Any, Literal, overload
+from typing import Any, Literal, Protocol, get_overloads, overload
 
 from absfuyu.core.baseclass import (
     AutoREPRMixin,
-    MethodNPropertyResult,
-    ShowAllMethodsMixin,
+    BaseDataclass,
+    ClassMembers,
+    ClassMembersResult,
+    GetClassMembersMixin,
 )
 from absfuyu.dxt.listext import ListExt
-from absfuyu.util.text_table import OneColumnTableMaker
+from absfuyu.typings import P, R
+from absfuyu.util.text_table import BoxStyle, OneColumnTableMaker
+
+
+# TODO: rewrite with each class for docs, method, property, attr, param, title
+# Dataclass
+# ---------------------------------------------------------------------------
+@dataclass
+class BaseDCInspect(BaseDataclass):
+    def _make_repr(self) -> str | None:
+        fields = self._get_fields()
+        if 0 < len(fields) < 2:
+            return repr(getattr(self, fields[0]))
+        return None
+
+    def _long_list_terminal_size(
+        self, long_list: list[str], width: int = 80, /
+    ) -> list[str]:
+        ll = ListExt(long_list).wrap_to_column(width, margin=4, transpose=True)
+        return list(ll)
+
+
+@dataclass
+class _TitleSignature:
+    """
+    Inspector:
+    Object's title and signature
+    """
+
+    title: str
+    signature: list[str]
+
+    def make_output(self):
+        pass
+
+
+@dataclass
+class _Docstring(BaseDCInspect):
+    """
+    Inspector:
+    Object's docstring
+    """
+
+    docs: str
+
+    def __repr__(self) -> str:
+        r = self._make_repr()
+        if r is not None:
+            return r
+        return super().__repr__()
+
+    def _get_first_paragraph(self) -> str:
+        # Get docs and get first paragraph
+        doc_lines = []
+        for line in self.docs.splitlines():
+            if len(line) < 1:
+                break
+            doc_lines.append(line.strip())
+        return " ".join(doc_lines)
+
+    def make_output(self) -> list[str]:
+        if len(self._get_first_paragraph()) > 0:
+            return ["Docstring:", self._get_first_paragraph()]
+        return [""]
+
+
+@dataclass
+class _MRO(BaseDCInspect):
+    """
+    Inspector:
+    Object's MRO, bases
+    """
+
+    mro: tuple[type, ...]
+
+    def __repr__(self) -> str:
+        r = self._make_repr()
+        if r is not None:
+            return r
+        return super().__repr__()
+
+    def _make_output(self) -> list[str]:
+        out = [
+            f"- {i:02}. {x.__module__}.{x.__name__}"
+            for i, x in enumerate(self.mro[1:], start=1)
+        ]
+        # ListExt.wrap_to_column
+        return out
+
+    def make_output(self, *, width: int = 80) -> list[str]:
+        out = self._make_output()
+        if len(out) > 0:
+            out_ = self._long_list_terminal_size(out, width)
+            return ["", f"Bases (Len: {len(out)}):", *out_]
+        return [""]
+
+
+@dataclass
+class _Member(BaseDCInspect):
+    """
+    Inspector:
+    Object's member
+    """
+
+    member: ClassMembers
+
+    def __repr__(self) -> str:
+        r = self._make_repr()
+        if r is not None:
+            return r
+        return super().__repr__()
+
+    def make_output(
+        self,
+        *,
+        width: int = 80,
+        obj,
+        include_method: bool = True,
+        include_property: bool = True,
+    ) -> list[str]:
+        mems = self.member.pack().sort()
+        body: list[str] = []
+
+        if include_method:
+            ml = [text_shorten(f"- {x}", width - 4) for x in mems.methods]
+            if len(ml) > 0:
+                head = ["", f"Methods (Len: {len(ml)}):"]
+                head.extend(self._long_list_terminal_size(ml, width))
+                body.extend(head)
+
+        if include_property:
+            pl = [
+                text_shorten(f"- {x} = {getattr(obj, x, None)}", width - 4)
+                for x in mems.properties
+            ]
+            if len(pl) > 0:
+                head = ["", f"Properties (Len: {len(pl)}):"]
+                head.extend(self._long_list_terminal_size(pl, width))
+                body.extend(head)
+
+        if len(body) > 0:
+            return body
+        return [""]
+
+
+class InspectComponents(Protocol):
+    """Supports make_output() -> list[str]"""
+
+    @overload
+    def make_output(self) -> list[str]: ...
+    @overload
+    def make_output(self, *, width: int = ...) -> list[str]: ...
+    @overload
+    def make_output(self, *args, **kwargs) -> list[str]: ...
+    def make_output(self, *args, **kwargs) -> list[str]: ...
 
 
 # Class
 # ---------------------------------------------------------------------------
-# TODO: rewrite with each class for docs, method, property, attr, param, title
 class Inspector(AutoREPRMixin):
     """
     Inspect an object.
@@ -71,7 +229,7 @@ class Inspector(AutoREPRMixin):
         Maximum lines for the output's header (class, signature, repr).
         Must be >= 1, by default ``8``
 
-    style : Literal["normal", "bold", "dashed", "double", "rounded"], optional
+    style : BoxStyle, optional
         Style for the table, by default ``"normal"``
 
 
@@ -99,7 +257,7 @@ class Inspector(AutoREPRMixin):
         include_attribute: bool = True,
         include_private: bool = False,
         max_textwrap_lines: int = 8,
-        style: Literal["normal", "bold", "dashed", "double", "rounded"] = "normal",
+        style: BoxStyle = "normal",
     ) -> None: ...
 
     def __init__(
@@ -116,10 +274,11 @@ class Inspector(AutoREPRMixin):
         include_method: bool = False,
         include_property: bool = False,
         include_attribute: bool = True,
+        include_dunder: bool = False,
         include_private: bool = False,
         include_all: bool = False,
         # Style
-        style: Literal["normal", "bold", "dashed", "double", "rounded"] = "normal",
+        style: BoxStyle = "normal",
     ) -> None:
         """
         Inspect an object.
@@ -159,7 +318,7 @@ class Inspector(AutoREPRMixin):
             Maximum lines for the output's header (class, signature, repr).
             Must be >= 1, by default ``8``
 
-        style : Literal["normal", "bold", "dashed", "double", "rounded"], optional
+        style : BoxStyle | Literal["normal", "bold", "dashed", "double", "rounded", ...], optional
             Style for the table, by default ``"normal"``
 
 
@@ -174,6 +333,7 @@ class Inspector(AutoREPRMixin):
         self.include_property = include_property
         self.include_attribute = include_attribute
         self.include_private = include_private
+        self.include_dunder = include_dunder
         self._style = style
 
         if include_all:
@@ -209,21 +369,20 @@ class Inspector(AutoREPRMixin):
         self._inspect_output = self._make_output()
 
     def __str__(self) -> str:
-        return self.detail_str()
+        return self._inspect_output.make_table()
 
-    # Support
+    # 00. Support
+    # -----------------------------------------------------------
+    # @deprecated
     def _long_list_terminal_size(self, long_list: list) -> list:
         ll = ListExt(long_list).wrap_to_column(
             self._linelength, margin=4, transpose=True
         )
         return list(ll)
 
-    # Signature
+    # 01. Signature
+    # -----------------------------------------------------------
     def _make_title(self) -> str:
-        """
-        Inspector's workflow:
-        01. Make title
-        """
         title_str = (
             str(self.obj)
             if (
@@ -245,6 +404,7 @@ class Inspector(AutoREPRMixin):
             return "def"
         return ""
 
+    # @deprecated
     def get_parameters(self) -> list[str] | None:
         try:
             sig = _inspect.signature(self.obj)
@@ -252,12 +412,27 @@ class Inspector(AutoREPRMixin):
             return None
         return [str(x) for x in sig.parameters.values()]
 
+    def _get_func_signature(self, func: Callable[P, R]) -> list[str]:
+        overloads = list(get_overloads(func))
+        if len(overloads) < 1:
+            return [
+                f"{self._get_signature_prefix()} {func.__name__}{_inspect.signature(func)}"
+            ]
+        return [
+            f"{self._get_signature_prefix()} {x.__name__}{_inspect.signature(x)}"
+            for x in overloads
+        ]
+
+    # @deprecated
     def _make_signature(self) -> list[str]:
-        """
-        Inspector's workflow:
-        02. Make signature
-        """
         try:
+            # if isinstance(self.obj, Callable):
+            if _inspect.isfunction(self.obj):
+                funcs = [
+                    self._text_wrapper.wrap(x)
+                    for x in self._get_func_signature(self.obj)
+                ]
+                return ListExt(funcs).flatten()
             return self._text_wrapper.wrap(
                 f"{self._get_signature_prefix()} {self.obj.__name__}{_inspect.signature(self.obj)}"
             )
@@ -265,15 +440,93 @@ class Inspector(AutoREPRMixin):
         except (ValueError, AttributeError, TypeError):
             return self._text_wrapper.wrap(repr(self.obj))
 
-    # Method and property
-    def _get_method_property(self) -> MethodNPropertyResult:
+    @property
+    def obj_signature(self) -> _TitleSignature:
+        """Object's title and signature"""
+        title: str = self._make_title()
+        sig: list[str] = []
+        try:
+            if _inspect.isfunction(self.obj):
+                sig.extend(self._get_func_signature(self.obj))
+            sig.append(
+                f"{self._get_signature_prefix()} {self.obj.__name__}{_inspect.signature(self.obj)}"
+            )
+        #    not class, func | not type   | is module
+        except (ValueError, AttributeError, TypeError):
+            sig.append(repr(self.obj))
+
+        return _TitleSignature(title=title, signature=sig)
+
+    # 02. Docstring
+    # -----------------------------------------------------------
+    @property
+    def obj_docs(self) -> _Docstring:
+        """Object's docstring"""
+        docs: str | None = _inspect.getdoc(self.obj)
+
+        if docs is None:
+            return _Docstring("")
+        return _Docstring(docs=docs)
+
+    # @deprecated
+    def _get_docs(self) -> str:
+        docs: str | None = _inspect.getdoc(self.obj)
+
+        if docs is None:
+            return ""
+
+        # Get docs and get first paragraph
+        # doc_lines: list[str] = [x.strip() for x in docs.splitlines()]
+        doc_lines = []
+        for line in docs.splitlines():
+            if len(line) < 1:
+                break
+            doc_lines.append(line.strip())
+
+        return text_shorten(" ".join(doc_lines), width=self._linelength - 4, tabsize=4)
+
+    # 03. MRO/Bases
+    # -----------------------------------------------------------
+    @property
+    def obj_mro(self) -> _MRO:
+        """Object's MRO, bases"""
+        if isinstance(self.obj, type):
+            return _MRO(mro=self.obj.__mro__[::-1])
+        return _MRO(mro=type(self.obj).__mro__[::-1])
+
+    @property
+    def obj_bases(self) -> _MRO:
+        """Object's MRO, bases"""
+        return self.obj_mro
+
+    # @deprecated
+    def _get_mro(self) -> tuple[type, ...]:
+        """Get MRO in reverse and subtract <class 'object'>"""
+        if isinstance(self.obj, type):
+            return self.obj.__mro__[::-1][1:]
+        return type(self.obj).__mro__[::-1][1:]
+
+    # @deprecated
+    def _make_mro_data(self) -> list[str]:
+        mro = [
+            f"- {i:02}. {x.__module__}.{x.__name__}"
+            for i, x in enumerate(self._get_mro(), start=1)
+        ]
+        mod_chunk = self._long_list_terminal_size(mro)
+
+        # return [text_shorten(x, self._linelength - 4) for x in mod_chunk]
+        return mod_chunk
+
+    # 04. Class's members
+    # -----------------------------------------------------------
+    def _get_obj_member(self) -> ClassMembersResult:
         # if _inspect.isclass(self.obj) or inspect.ismodule(self.obj):
         if _inspect.isclass(self.obj):
             tmpcls = type(
                 "tmpcls",
                 (
                     self.obj,
-                    ShowAllMethodsMixin,
+                    GetClassMembersMixin,
                 ),
                 {},
             )
@@ -282,46 +535,38 @@ class Inspector(AutoREPRMixin):
                 "tmpcls",
                 (
                     type(self.obj),
-                    ShowAllMethodsMixin,
+                    GetClassMembersMixin,
                 ),
                 {},
             )
-        med_prop = tmpcls._get_methods_and_properties(  # type: ignore
-            include_private_method=self.include_private
+        med_prop = tmpcls._get_members(  # type: ignore
+            dunder=False, private=self.include_private
         )
 
         try:
-            # If self.obj is a subclass of ShowAllMethodsMixin
+            # If self.obj is a subclass of GetClassMembersMixin
             _mro = getattr(
                 self.obj, "__mro__", getattr(type(self.obj), "__mro__", None)
             )
-            if ShowAllMethodsMixin in _mro:  # type: ignore
+            if GetClassMembersMixin in _mro:  # type: ignore
                 return med_prop  # type: ignore
         except AttributeError:  # Not a class
             pass
-        med_prop.__delitem__(ShowAllMethodsMixin.__name__)
+        med_prop.__delitem__(GetClassMembersMixin.__name__)
         return med_prop  # type: ignore
 
-    # Docstring
-    def _get_docs(self) -> str:
-        """
-        Inspector's workflow:
-        03. Get docstring and strip
-        """
-        docs: str | None = _inspect.getdoc(self.obj)
-
-        if docs is None:
-            return ""
-
-        # Get docs and get first paragraph
-        # doc_lines: list[str] = [x.strip() for x in docs.splitlines()]
-        doc_lines = []
-        for line in docs.splitlines():
-            if len(line) < 1:
-                break
-            doc_lines.append(line.strip())
+    @property
+    def obj_member(self) -> _Member:
+        """Object's members"""
+        try:
+            mem = self._get_obj_member()
+            return _Member(mem.flatten_value())
+        except (TypeError, AttributeError):
+            return _Member(ClassMembers())
 
-        return text_shorten(" ".join(doc_lines), width=self._linelength - 4, tabsize=4)
+    # @deprecated
+    def _get_method_property(self) -> ClassMembersResult:
+        return self._get_obj_member()
 
     # Attribute
     @staticmethod
@@ -385,24 +630,9 @@ class Inspector(AutoREPRMixin):
             text_shorten(f"- {x[0]} = {x[1]}", self._linelength - 4) for x in attr_list
         ]
 
-    # Get MRO
-    def _get_mro(self) -> tuple[type, ...]:
-        """Get MRO in reverse and subtract <class 'object'>"""
-        if isinstance(self.obj, type):
-            return self.obj.__mro__[::-1][1:]
-        return type(self.obj).__mro__[::-1][1:]
-
-    def _make_mro_data(self) -> list[str]:
-        mro = [
-            f"- {i:02}. {x.__module__}.{x.__name__}"
-            for i, x in enumerate(self._get_mro(), start=1)
-        ]
-        mod_chunk = self._long_list_terminal_size(mro)
-
-        # return [text_shorten(x, self._linelength - 4) for x in mod_chunk]
-        return mod_chunk
-
     # Output
+    # -----------------------------------------------------------
+    # @deprecated
     def _make_output(self) -> OneColumnTableMaker:
         table = OneColumnTableMaker(self._linelength, style=self._style)
         body: list[str] = []
@@ -468,8 +698,55 @@ class Inspector(AutoREPRMixin):
 
         return table
 
-    def detail_str(self) -> str:
-        return self._inspect_output.make_table()
+    def _make_output_2(self) -> OneColumnTableMaker:
+        # Prep
+        # components: list[InspectComponents] = [
+        #     self.obj_signature,
+        #     self.obj_docs,
+        #     self.obj_mro,
+        #     self.obj_member,
+        # ]
+        table = OneColumnTableMaker(self._linelength, style=self._style)
+        body: list[str] = []
+
+        # Signature
+        title = self.obj_signature.title
+        table.add_title(title)
+        if table._title == "":  # Title too long
+            _title = [title]
+            _title.extend(self.obj_signature.signature)
+            table.add_paragraph(_title)
+        else:
+            table.add_paragraph(self.obj_signature.signature)
+
+        # Docstring
+        if self.include_docs:
+            body.extend(self.obj_docs.make_output())
+
+        # Class bases
+        if self.include_mro:
+            body.extend(self.obj_mro.make_output(width=self._linelength))
+
+        # Method & Property
+        body.extend(
+            self.obj_member.make_output(
+                width=self._linelength,
+                obj=self.obj,
+                include_method=self.include_method,
+                include_property=self.include_property,
+            )
+        )
+
+        # Attribute
+        attrs = self._get_attributes()
+        if len(attrs) > 0 and self.include_attribute:
+            body.extend(["", f"Attributes (Len: {len(attrs)}):"])
+            body.extend(self._handle_attributes_for_output(attr_list=attrs))
+
+        # Add to table
+        table.add_paragraph(body)
+
+        return table
 
 
 # Partial

absfuyu/tools/keygen.py

@@ -5,8 +5,8 @@ Mod7 product key generator (90's)
 
 This is for educational and informative purposes only.
 
-Version: 5.2.0
-Date updated: 10/03/2025 (dd/mm/yyyy)
+Version: 5.5.0
+Date updated: 23/04/2025 (dd/mm/yyyy)
 """
 
 # Module level

absfuyu/tools/obfuscator.py

@@ -3,8 +3,8 @@ Absfuyu: Obfuscator
 -------------------
 Obfuscate code
 
-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 level
@@ -22,7 +22,7 @@ from collections import deque
 from string import Template
 from typing import ClassVar
 
-from absfuyu.core.baseclass import BaseClass, ShowAllMethodsMixin
+from absfuyu.core.baseclass import BaseClass, GetClassMembersMixin
 from absfuyu.core.docstring import versionadded
 from absfuyu.dxt import Text
 from absfuyu.logger import logger
@@ -110,7 +110,7 @@ class StrShifter(BaseClass):
         return self._use_convert_table(self._make_convert_table())
 
 
-class Obfuscator(ShowAllMethodsMixin):
+class Obfuscator(GetClassMembersMixin):
     """
     Obfuscate code
 

absfuyu/tools/passwordlib.py

@@ -3,8 +3,8 @@ Absfuyu: Passwordlib
 --------------------
 Password library
 
-Version: 5.2.0
-Date updated: 15/03/2025 (dd/mm/yyyy)
+Version: 5.5.0
+Date updated: 23/04/2025 (dd/mm/yyyy)
 """
 
 # Module level

absfuyu/tools/shutdownizer.py

@@ -3,8 +3,8 @@ Absfuyu: Shutdownizer
 ---------------------
 This shutdowns
 
-Version: 5.2.0
-Date updated: 10/03/2025 (dd/mm/yyyy)
+Version: 5.5.0
+Date updated: 23/04/2025 (dd/mm/yyyy)
 """
 
 # Module level

absfuyu/tools/web.py

@@ -3,8 +3,8 @@ Absfuyu: Web
 ------------
 Web, ``request``, ``BeautifulSoup`` stuff
 
-Version: 5.2.0
-Date updated: 10/03/2025 (dd/mm/yyyy)
+Version: 5.5.0
+Date updated: 23/04/2025 (dd/mm/yyyy)
 """
 
 # Library

absfuyu/typings.py

@@ -3,8 +3,8 @@ Absfuyu: Core
 -------------
 Pre-defined typing
 
-Version: 5.2.0
-Date updated: 14/03/2025 (dd/mm/yyyy)
+Version: 5.5.0
+Date updated: 23/04/2025 (dd/mm/yyyy)
 """
 
 # Module Package
@@ -14,6 +14,8 @@ __all__ = [
     "T",
     "T_co",
     "T_contra",
+    "KT",
+    "VT",
     "P",
     "R",
     "_CALLABLE",
@@ -48,6 +50,9 @@ T_co = TypeVar("T_co", covariant=True)  # Type covariant
 # with a more general type without causing errors
 T_contra = TypeVar("T_contra", contravariant=True)  # Type contravariant
 
+KT = TypeVar("KT")
+VT = TypeVar("VT")
+
 # Callable
 P = ParamSpec("P")  # Parameter type
 R = TypeVar("R")  # Return type - Can be anything