absfuyu 4.2.0__py3-none-any.whl → 5.0.1__py3-none-any.whl

absfuyu/extra/beautiful.py

@@ -0,0 +1,252 @@
+"""
+Absfuyu: Beautiful
+------------------
+A decorator that makes output more beautiful
+
+Version: 5.0.0
+Date updated: 22/02/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = [
+    "BeautifulOutput",
+    "print",
+]
+
+
+# Library
+# ---------------------------------------------------------------------------
+import time
+import tracemalloc
+from collections.abc import Callable
+from functools import wraps
+from typing import Any, Literal, NamedTuple, ParamSpec, TypeVar
+
+BEAUTIFUL_MODE = False
+
+try:
+    from rich.align import Align
+    from rich.console import Console, Group
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich.text import Text
+except ImportError:
+    from subprocess import run
+
+    from absfuyu.config import ABSFUYU_CONFIG
+
+    if ABSFUYU_CONFIG._get_setting("auto-install-extra").value:
+        cmd = "python -m pip install -U absfuyu[beautiful]".split()
+        run(cmd)
+    else:
+        raise SystemExit("This feature is in absfuyu[beautiful] package")  # noqa: B904
+else:
+    BEAUTIFUL_MODE = True
+
+# Setup
+# ---------------------------------------------------------------------------
+# rich's console.print wrapper
+console = Console(color_system="auto", tab_size=4)
+print = console.print
+
+
+# Type
+# ---------------------------------------------------------------------------
+P = ParamSpec("P")  # Parameter type
+R = TypeVar("R")  # Return type - Can be anything
+T = TypeVar("T", bound=type)  # Type type - Can be any subtype of `type`
+
+
+# Class
+# ---------------------------------------------------------------------------
+class PerformanceOutput(NamedTuple):
+    runtime: float
+    current_memory: int
+    peak_memory: int
+
+    def to_text(self) -> str:
+        """
+        Beautify the result and ready to print
+        """
+        out = (
+            f"Memory usage:      {self.current_memory / 10**6:,.6f} MB\n"
+            f"Peak memory usage: {self.peak_memory / 10**6:,.6f} MB\n"
+            f"Time elapsed:      {self.runtime:,.6f} s"
+        )
+        return out
+
+
+# TODO: header and footer layout to 1,2,3 instead of true false
+class BeautifulOutput:
+    """A decorator that makes output more beautiful"""
+
+    def __init__(
+        self,
+        layout: Literal[1, 2, 3, 4, 5, 6] = 1,
+        include_header: bool = True,
+        include_footer: bool = True,
+        alternate_footer: bool = False,
+    ) -> None:
+        """
+        Show function's signature and measure memory usage
+
+        Parameters
+        ----------
+        layout : Literal[1, 2, 3, 4, 5, 6], optional
+            Layout to show, by default ``1``
+
+        include_header : bool, optional
+            Include header with function's signature, by default ``True``
+
+        include_footer : bool, optional
+            Include footer, by default ``True``
+
+        alternate_footer : bool, optional
+            Alternative style of footer, by default ``False``
+
+
+        Usage
+        -----
+        Use this as a decorator (``@BeautifulOutput(<parameters>)``)
+        """
+        self.layout = layout
+        self.include_header = include_header
+        self.include_footer = include_footer
+        self.alternate_footer = alternate_footer
+
+        # Data
+        self._obj_name = ""
+        self._signature = ""
+        self._result: Any | None = None
+        self._performance: PerformanceOutput | None = None
+
+        # Setting
+        self._header_footer_style = "white on blue"
+        self._alignment = "center"
+
+    def __call__(self, obj: Callable[P, R]) -> Callable[P, Group]:
+        # Class wrapper
+        if isinstance(obj, type):
+            raise NotImplementedError("Classes are not supported")
+
+        # Function wrapper
+        @wraps(obj)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> Group:
+            """
+            Wrapper function that executes the original function.
+            """
+            # Get all parameters inputed
+            args_repr = [repr(a) for a in args]
+            kwargs_repr = [f"{k}={repr(v)}" for k, v in kwargs.items()]
+            self._signature = ", ".join(args_repr + kwargs_repr)
+            self._obj_name = obj.__name__
+
+            # Performance check
+            tracemalloc.start()  # Start memory measure
+            start_time = time.perf_counter()  # Start time measure
+
+            self._result = obj(*args, **kwargs)  # Function run
+
+            finish_time = time.perf_counter()  # Get finished time
+            _cur, _peak = tracemalloc.get_traced_memory()  # Get memory stats
+            tracemalloc.stop()  # End memory measure
+
+            self._performance = PerformanceOutput(
+                runtime=finish_time - start_time, current_memory=_cur, peak_memory=_peak
+            )
+
+            return self._get_layout(layout=self.layout)
+
+        return wrapper
+
+    # Signature
+    def _func_signature(self) -> str:
+        """Function's signature"""
+        return f"{self._obj_name}({self._signature})"
+
+    # Layout
+    def _make_header(self) -> Table:
+        header_table = Table.grid(expand=True)
+        header_table.add_row(
+            Panel(
+                Align(f"[b]{self._func_signature()}", align=self._alignment),
+                style=self._header_footer_style,
+            )
+        )
+        return header_table
+
+    def _make_line(self) -> Table:
+        line = Table.grid(expand=True)
+        line.add_row(Text("", style=self._header_footer_style))
+        return line
+
+    def _make_footer(self) -> Table:
+        if self.alternate_footer:
+            return self._make_line()
+
+        footer_table = Table.grid(expand=True)
+        footer_table.add_row(
+            Panel(
+                Align("[b]BeautifulOutput by absfuyu", align=self._alignment),
+                style=self._header_footer_style,
+            )
+        )
+        return footer_table
+
+    def _make_result_panel(self) -> Panel:
+        result_txt = Text(
+            str(self._result),
+            overflow="fold",
+            no_wrap=False,
+            tab_size=2,
+        )
+        result_panel = Panel(
+            Align(result_txt, align=self._alignment),
+            title="[bold]Result[/]",
+            border_style="green",
+            highlight=True,
+        )
+        return result_panel
+
+    def _make_performance_panel(self) -> Panel:
+        if self._performance is not None:
+            performance_panel = Panel(
+                Align(self._performance.to_text(), align=self._alignment),
+                title="[bold]Performance[/]",
+                border_style="red",
+                highlight=True,
+                # height=result_panel.height,
+            )
+            return performance_panel
+        else:
+            return Panel("None", title="[bold]Performance[/]")
+
+    def _make_output(self) -> Table:
+        out_table = Table.grid(expand=True)
+        out_table.add_column(ratio=3)  # result
+        out_table.add_column(ratio=2)  # performance
+
+        out_table.add_row(
+            self._make_result_panel(),
+            self._make_performance_panel(),
+        )
+        return out_table
+
+    def _get_layout(self, layout: int) -> Group:
+        header = self._make_header() if self.include_header else Text()
+        footer = self._make_footer() if self.include_footer else Text()
+        layouts = {
+            1: Group(header, self._make_output(), footer),
+            2: Group(header, self._make_result_panel(), self._make_performance_panel()),
+            3: Group(header, self._make_result_panel(), footer),
+            4: Group(self._make_result_panel(), self._make_performance_panel()),
+            5: Group(self._make_output()),
+            6: Group(
+                header,
+                self._make_result_panel(),
+                self._make_performance_panel(),
+                footer,
+            ),
+        }
+        return layouts.get(layout, layouts[1])

absfuyu/{extensions → extra}/data_analysis.py

@@ -3,12 +3,12 @@ Absfuyu: Data Analysis [W.I.P]
 ------------------------------
 Extension for ``pd.DataFrame``
 
-Version: 2.2.0
-Date updated: 29/11/2024 (dd/mm/yyyy)
+Version: 5.0.0
+Date updated: 25/02/2025 (dd/mm/yyyy)
 """
 
 # Module level
-###########################################################################
+# ---------------------------------------------------------------------------
 __all__ = [
     # Function
     "compare_2_list",
@@ -24,60 +24,40 @@ __all__ = [
 
 
 # Library
-###########################################################################
+# ---------------------------------------------------------------------------
 import random
 import string
 from collections import deque
 from datetime import datetime
 from itertools import chain, product
-from typing import Any, Literal, NamedTuple, Self
+from typing import Any, ClassVar, Literal, NamedTuple, Self
 
-# import matplotlib.pyplot as plt
-# from scipy import stats
-# from dateutil.relativedelta import relativedelta
-import numpy as np
-import pandas as pd
-from deprecated import deprecated
-from deprecated.sphinx import deprecated as sphinx_deprecated
-from deprecated.sphinx import versionadded
+DA_MODE = False
 
-from absfuyu.logger import logger
-from absfuyu.util import set_min, set_min_max
+try:
+    import numpy as np
+    import pandas as pd
+except ImportError:
+    from subprocess import run
 
+    from absfuyu.config import ABSFUYU_CONFIG
 
-# Function
-###########################################################################
-@deprecated(reason="Not needed", version="3.1.0")
-@sphinx_deprecated(reason="Not needed", version="3.1.0")
-def summary(data: list | np.ndarray):  # del this
-    """
-    Quick summary of data
+    if ABSFUYU_CONFIG._get_setting("auto-install-extra").value:
+        cmd = "python -m pip install -U absfuyu[full]".split()
+        run(cmd)
+    else:
+        raise SystemExit("This feature is in absfuyu[full] package")  # noqa: B904
+else:
+    DA_MODE = True
 
-    :param data: np.ndarray | list
-    """
 
-    if not isinstance(data, np.ndarray):
-        data = np.array(data)
-
-    output = {
-        "Observations": len(data),
-        "Mean": np.mean(data),
-        "Median": np.median(data),
-        # "Mode": stats.mode(data)[0][0],
-        "Standard deviation": np.std(data),
-        "Variance": np.var(data),
-        "Max": max(data),
-        "Min": min(data),
-        "Percentiles": {
-            "1st Quartile": np.quantile(data, 0.25),
-            "2nd Quartile": np.quantile(data, 0.50),
-            "3rd Quartile": np.quantile(data, 0.75),
-            # "IQR": stats.iqr(data),
-        },
-    }
-    return output
+from absfuyu.core import ShowAllMethodsMixin, versionadded  # noqa: E402
+from absfuyu.logger import logger  # noqa: E402
+from absfuyu.util import set_min, set_min_max  # noqa: E402
 
 
+# Function
+# ---------------------------------------------------------------------------
 def equalize_df(data: dict[str, list], fillna=np.nan) -> dict[str, list]:
     """
     Make all list in dict have equal length to make pd.DataFrame
@@ -94,9 +74,6 @@ def equalize_df(data: dict[str, list], fillna=np.nan) -> dict[str, list]:
     return data
 
 
-## Update 05/10
-
-
 def compare_2_list(*arr) -> pd.DataFrame:
     """
     Compare 2 lists then create DataFrame
@@ -147,12 +124,6 @@ def rename_with_dict(df: pd.DataFrame, col: str, rename_dict: dict) -> pd.DataFr
     :param col: Column name
     :param rename_dict: Rename dictionary
     """
-    # Ver 1.0.1
-    # name = f"{col}_filtered"
-    # df[name] = df[col]
-    # for k, v in rename_dict.items():
-    #     df[name] = df[name].str.replace(k, v)
-    # return df
 
     name = f"{col}_filtered"
     df[name] = df[col]
@@ -162,7 +133,7 @@ def rename_with_dict(df: pd.DataFrame, col: str, rename_dict: dict) -> pd.DataFr
 
 
 # Class
-###########################################################################
+# ---------------------------------------------------------------------------
 class CityData(NamedTuple):
     """
     Parameters
@@ -182,7 +153,7 @@ class CityData(NamedTuple):
     area: str
 
     @staticmethod
-    def _sample_city_data(size: int = 100) -> list["CityData"]:
+    def _sample_city_data(size: int = 100) -> list:
         """
         Generate sample city data (testing purpose)
         """
@@ -354,7 +325,7 @@ class MatplotlibFormatString:
     Format string format: `[marker][line][color]` or `[color][marker][line]`
     """
 
-    MARKER_LIST = {
+    MARKER_LIST: ClassVar[dict[str, str]] = {
         ".": "point marker",
         ",": "pixel marker",
         "o": "circle marker",
@@ -381,13 +352,13 @@ class MatplotlibFormatString:
         "|": "vline marker",
         "_": "hline marker",
     }
-    LINE_STYLE_LIST = {
+    LINE_STYLE_LIST: ClassVar[dict[str, str]] = {
         "-": "solid line style",
         "--": "dashed line style",
         "-.": "dash-dot line style",
         ":": "dotted line style",
     }
-    COLOR_LIST = {
+    COLOR_LIST: ClassVar[dict[str, str]] = {
         "b": "blue",
         "g": "green",
         "r": "red",
@@ -401,12 +372,12 @@ class MatplotlibFormatString:
     LineStyle = _DictToAtrr(LINE_STYLE_LIST, key_as_atrribute=False)
     Color = _DictToAtrr(COLOR_LIST, key_as_atrribute=False)
 
-    @staticmethod
-    def all_format_string() -> list[PLTFormatString]:
+    @classmethod
+    def all_format_string(cls) -> list[PLTFormatString]:
         fmt_str = [
-            __class__.MARKER_LIST,  # type: ignore
-            __class__.LINE_STYLE_LIST,  # type: ignore
-            __class__.COLOR_LIST,  # type: ignore
+            cls.MARKER_LIST,
+            cls.LINE_STYLE_LIST,
+            cls.COLOR_LIST,
         ]
         return [PLTFormatString._make(x) for x in list(product(*fmt_str))]
 
@@ -420,8 +391,8 @@ class MatplotlibFormatString:
 
 
 # Class - DA
-###########################################################################
-class DataAnalystDataFrame(pd.DataFrame):
+# ---------------------------------------------------------------------------
+class DataAnalystDataFrame(ShowAllMethodsMixin, pd.DataFrame):
     """
     Data Analyst ``pd.DataFrame``
     """
@@ -843,13 +814,15 @@ class DataAnalystDataFrame(pd.DataFrame):
     # ================================================================
     # Total observation
     @property
-    @versionadded(version="3.2.0")
+    @versionadded("3.2.0")
     def total_observation(self) -> int:
-        """Returns total observation of the DataFrame"""
+        """
+        Returns total observation of the DataFrame
+        """
         return self.shape[0] * self.shape[1]  # type: ignore
 
     # Quick info
-    @versionadded(version="3.2.0")
+    @versionadded("3.2.0")
     def qinfo(self) -> str:
         """
         Show quick infomation about DataFrame
@@ -867,7 +840,7 @@ class DataAnalystDataFrame(pd.DataFrame):
         return info
 
     # Quick describe
-    @versionadded(version="3.2.0")
+    @versionadded("3.2.0")
     def qdescribe(self) -> pd.DataFrame:
         """
         Quick ``describe()`` that exclude ``object`` and ``datetime`` dtype
@@ -916,7 +889,7 @@ class DataAnalystDataFrame(pd.DataFrame):
         return out
 
     # Show distribution
-    @versionadded(version="3.2.0")
+    @versionadded("3.2.0")
     def show_distribution(
         self,
         column_name: str,
@@ -964,6 +937,8 @@ class DataAnalystDataFrame(pd.DataFrame):
         6          800     10        10.0
         7          100      9         9.0
         8          500      4         4.0
+
+
         """
         out = self[column_name].value_counts(dropna=dropna).to_frame().reset_index()
         if show_percentage:
@@ -977,12 +952,12 @@ class DataAnalystDataFrame(pd.DataFrame):
         return out
 
     # Help
-    @staticmethod
-    def dadf_help() -> list[str]:
+    @classmethod
+    def dadf_help(cls) -> list[str]:
         """
         Show all available method of DataAnalystDataFrame
         """
-        list_of_method = list(set(dir(__class__)) - set(dir(pd.DataFrame)))  # type: ignore
+        list_of_method = list(set(dir(cls)) - set(dir(pd.DataFrame)))
         return sorted(list_of_method)
 
     # Sample DataFrame
@@ -1066,7 +1041,7 @@ class DADF(DataAnalystDataFrame):
 class DADF_WIP(DADF):
     """W.I.P"""
 
-    @versionadded(version="4.0.0")
+    @versionadded("4.0.0")
     def subtract_df(self, other: Self | pd.DataFrame) -> Self:
         """
         Subtract DF to find the different rows
@@ -1079,7 +1054,7 @@ class DADF_WIP(DADF):
         )
         return self.__class__(out)
 
-    @versionadded(version="4.0.0")
+    @versionadded("4.0.0")
     def merge_left(
         self,
         other: Self | pd.DataFrame,
@@ -1092,7 +1067,7 @@ class DADF_WIP(DADF):
         :param columns: Columns to take from df2
         """
 
-        if columns:
+        if columns is not None:
             current_col = [on]
             current_col.extend(columns)
             col = other.columns.to_list()
@@ -1101,9 +1076,3 @@ class DADF_WIP(DADF):
 
         out = self.merge(other, how="left", on=on)
         return self.__class__(out)
-
-
-# Run
-###########################################################################
-if __name__ == "__main__":
-    logger.setLevel(10)