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

absfuyu/extra/da/dadf_base.py

@@ -0,0 +1,186 @@
+"""
+Absfuyu: Data Analysis
+----------------------
+Data Analyst DataFrame - Base/Core
+
+Version: 5.2.0
+Date updated: 10/03/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["DataAnalystDataFrameBase", "SplittedDF", "CityData"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+import random
+from collections import deque
+from typing import ClassVar, Literal, NamedTuple
+
+import pandas as pd
+
+
+# Class
+# ---------------------------------------------------------------------------
+class DataAnalystDataFrameBase(pd.DataFrame):
+    """
+    Data Analyst ``pd.DataFrame`` - Base
+
+    Set class variable ``_DADF_INCLUDE`` to ``False`` to exclude from ``DADF_METHODS``
+    """
+
+    # Custom attribute
+    _DADF_INCLUDE: ClassVar[bool] = True  # Include in DADF_METHODS
+    DADF_METHODS: ClassVar[dict[str, list[str]]] = {}
+
+    def __init_subclass__(cls, *args, **kwargs) -> None:
+        """
+        This create a dictionary with:
+        - key   (str)      : Subclass
+        - value (list[str]): List of available methods
+        """
+        super().__init_subclass__(*args, **kwargs)
+
+        if cls._DADF_INCLUDE and not any(
+            [x.endswith(cls.__name__) for x in cls.DADF_METHODS.keys()]
+        ):
+            # if not any([x.endswith(cls.__name__) for x in cls.DADF_METHODS.keys()]):
+            methods_list: list[str] = [
+                k for k, v in cls.__dict__.items() if callable(v)
+            ]
+            if len(methods_list) > 0:
+                name = f"{cls.__module__}.{cls.__name__}"
+                cls.DADF_METHODS.update({name: sorted(methods_list)})
+
+
+class SplittedDF(NamedTuple):
+    """
+    DataFrame splitted into contains
+    missing values only and vice versa
+
+    Parameters
+    ----------
+    df : DataFrame
+        DataFrame without missing values
+
+    df_na : DataFrame
+        DataFrame with missing values only
+    """
+
+    df: pd.DataFrame
+    df_na: pd.DataFrame
+
+    @staticmethod
+    def concat_df(
+        df_list: list[pd.DataFrame], join: Literal["inner", "outer"] = "inner"
+    ) -> pd.DataFrame:
+        """
+        Concat the list of DataFrame (static method)
+
+        Parameters
+        ----------
+        df_list : list[DataFrame]
+            A sequence of DataFrame
+
+        join : str
+            Join type
+            (Default: ``"inner"``)
+
+        Returns
+        -------
+        DataFrame
+            Joined DataFrame
+        """
+        df: pd.DataFrame = pd.concat(df_list, axis=0, join=join).reset_index()
+        df.drop(columns=["index"], inplace=True)
+        return df
+
+    def concat(self, join: Literal["inner", "outer"] = "inner") -> pd.DataFrame:
+        """
+        Concat the splitted DataFrame
+
+        Parameters
+        ----------
+        join : str
+            Join type
+            (Default: ``"inner"``)
+
+        Returns
+        -------
+        DataFrame
+            Joined DataFrame
+        """
+        return self.concat_df(self, join=join)  # type: ignore
+
+    @staticmethod
+    def divide_dataframe(df: pd.DataFrame, by_column: str) -> list[pd.DataFrame]:
+        """
+        Divide DataFrame into a list of DataFrame
+
+        Parameters
+        ----------
+        df : DataFrame
+            DataFrame
+
+        by_column : str
+            By which column
+
+        Returns
+        -------
+        list[DataFrame]
+            Splitted DataFrame
+        """
+        divided = [x for _, x in df.groupby(by_column)]
+        return divided
+
+
+class CityData(NamedTuple):
+    """
+    Parameters
+    ----------
+    city : str
+        City name
+
+    region : str
+        Region of the city
+
+    area : str
+        Area of the region
+    """
+
+    city: str
+    region: str
+    area: str
+
+    @staticmethod
+    def _sample_city_data(size: int = 100):
+        """
+        Generate sample city data (testing purpose)
+        """
+        sample_range = 10 ** len(str(size))
+
+        # Serial list
+        serials: list[str] = []
+        while len(serials) != size:  # Unique serial
+            serial = random.randint(0, sample_range - 1)
+            serial = str(serial).rjust(len(str(size)), "0")  # type: ignore
+            if serial not in serials:  # type: ignore
+                serials.append(serial)  # type: ignore
+
+        ss2 = deque(serials[: int(len(serials) / 2)])  # Cut half for region
+        ss2.rotate(random.randrange(1, 5))
+        [ss2.extend(ss2) for _ in range(2)]  # type: ignore # Extend back
+
+        ss3 = deque(serials[: int(len(serials) / 4)])  # Cut forth for area
+        ss3.rotate(random.randrange(1, 5))
+        [ss3.extend(ss3) for _ in range(4)]  # type: ignore # Extend back
+
+        serials = ["city_" + x for x in serials]
+        ss2 = ["region_" + x for x in ss2]  # type: ignore
+        ss3 = ["area_" + x for x in ss3]  # type: ignore
+
+        ss = list(zip(serials, ss2, ss3))  # Zip back
+        out = list(map(CityData._make, ss))
+
+        return out

absfuyu/extra/da/df_func.py

@@ -0,0 +1,97 @@
+"""
+Absfuyu: Data Analysis
+----------------------
+DF Function
+
+Version: 5.2.0
+Date updated: 10/03/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["equalize_df", "compare_2_list", "rename_with_dict"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+from itertools import chain
+
+import numpy as np
+import pandas as pd
+
+
+# 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
+
+    :param data: `dict` data that ready for `pd.DataFrame`
+    :param fillna: Fill N/A value (Default: `np.nan`)
+    """
+    max_len = max(map(len, data.values()))
+    for _, v in data.items():
+        if len(v) < max_len:
+            missings = max_len - len(v)
+            for _ in range(missings):
+                v.append(fillna)
+    return data
+
+
+def compare_2_list(*arr) -> pd.DataFrame:
+    """
+    Compare 2 lists then create DataFrame
+    to see which items are missing
+
+    Parameters
+    ----------
+    arr : list
+        List
+
+    Returns
+    -------
+    DataFrame
+        Compare result
+    """
+    # Setup
+    col_name = "list"
+    arr = [sorted(x) for x in arr]  # type: ignore # map(sorted, arr)
+
+    # Total array
+    tarr = sorted(list(set(chain.from_iterable(arr))))
+    # max_len = len(tarr)
+
+    # Temp dataset
+    temp_dict = {"base": tarr}
+    for idx, x in enumerate(arr):
+        name = f"{col_name}{idx}"
+
+        # convert list
+        temp = [item if item in x else np.nan for item in tarr]
+
+        temp_dict.setdefault(name, temp)
+
+    df = pd.DataFrame(temp_dict)
+    df["Compare"] = np.where(
+        df[f"{col_name}0"].apply(lambda x: str(x).lower())
+        == df[f"{col_name}1"].apply(lambda x: str(x).lower()),
+        df[f"{col_name}0"],  # Value when True
+        np.nan,  # Value when False
+    )
+    return df
+
+
+def rename_with_dict(df: pd.DataFrame, col: str, rename_dict: dict) -> pd.DataFrame:
+    """
+    Version: 2.0.0
+
+    :param df: DataFrame
+    :param col: Column name
+    :param rename_dict: Rename dictionary
+    """
+
+    name = f"{col}_filtered"
+    df[name] = df[col]
+    rename_val = list(rename_dict.keys())
+    df[name] = df[name].apply(lambda x: "Other" if x in rename_val else x)
+    return df

absfuyu/extra/da/mplt.py

@@ -0,0 +1,219 @@
+"""
+Absfuyu: Data Analysis
+----------------------
+Matplotlib Helper
+
+Version: 5.2.0
+Date updated: 10/03/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["MatplotlibFormatString", "_PLTFormatString"]
+
+# Library
+# ---------------------------------------------------------------------------
+import random
+from collections.abc import Sequence
+from itertools import product
+from typing import ClassVar, Self
+
+from absfuyu.core.baseclass import AutoREPRMixin, BaseClass
+
+
+# Class
+# ---------------------------------------------------------------------------
+class _PLTFormatString(AutoREPRMixin):
+    """
+    Matplotlib format string
+
+    Available format:
+    - ``<marker><line><color>``
+    - ``<color><marker><line>``
+    """
+
+    __slots__ = (
+        "marker",
+        "line_style",
+        "color",
+        "_marker_fullname",
+        "_line_style_fullname",
+        "_color_fullname",
+    )
+
+    def __init__(
+        self,
+        marker: str,
+        line_style: str,
+        color: str,
+        *,
+        marker_fullname: str | None = None,
+        line_style_fullname: str | None = None,
+        color_fullname: str | None = None,
+    ) -> None:
+        """
+        Matplotlib format string
+
+        Parameters
+        ----------
+        marker : str
+            Maker
+
+        line_style : str
+            Line style
+
+        color : str
+            Color
+
+        marker_fullname : str | None, optional
+            Maker fullname, by default ``None``
+
+        line_style_fullname : str | None, optional
+            Line style fullname, by default ``None``
+
+        color_fullname : str | None, optional
+            Color fullname, by default ``None``
+        """
+
+        self.marker = marker
+        self.line_style = line_style
+        self.color = color
+
+        self._marker_fullname = marker_fullname
+        self._line_style_fullname = line_style_fullname
+        self._color_fullname = color_fullname
+
+    def __str__(self) -> str:
+        return self.fstr
+
+    def __format__(self, format_spec: str) -> str:
+        if format_spec.lower() == "full":
+            if (
+                self._marker_fullname is None
+                or self._line_style_fullname is None
+                or self._color_fullname is None
+            ):
+                return self.__str__()
+            clsname = self.__class__.__name__
+            return (
+                f"{clsname}(marker={repr(self._marker_fullname)}"
+                f", line_style={repr(self._line_style_fullname)}"
+                f", color={repr(self._color_fullname)})"
+            )
+        return super().__format__(format_spec)
+
+    @property
+    def fstr(self) -> str:
+        """Format string"""
+        return f"{self.marker}{self.line_style}{self.color}"
+
+    @property
+    def alternate(self) -> str:
+        """Alternative version of format string"""
+        return f"{self.color}{self.marker}{self.line_style}"
+
+    @classmethod
+    def _make(cls, iterable: Sequence[str]) -> Self:
+        if len(iterable) not in (3, 6):
+            raise ValueError("iterable must have a length of 3 or 6")
+        try:  # Len 6
+            return cls(
+                marker=iterable[0],
+                line_style=iterable[1],
+                color=iterable[2],
+                marker_fullname=iterable[3],
+                line_style_fullname=iterable[4],
+                color_fullname=iterable[5],
+            )
+        except IndexError:  # Len 3
+            return cls(iterable[0], iterable[1], iterable[2])
+
+
+class MatplotlibFormatString(BaseClass):
+    """
+    Matplotlib format string
+
+    Available format:
+    - ``<marker><line><color>``
+    - ``<color><marker><line>``
+    """
+
+    MARKER_DATA: ClassVar[dict[str, str]] = {
+        ".": "point marker",
+        ",": "pixel marker",
+        "o": "circle marker",
+        "v": "triangle_down marker",
+        "^": "triangle_up marker",
+        "<": "triangle_left marker",
+        ">": "triangle_right marker",
+        "1": "tri_down marker",
+        "2": "tri_up marker",
+        "3": "tri_left marker",
+        "4": "tri_right marker",
+        "8": "octagon marker",
+        "s": "square marker",
+        "p": "pentagon marker",
+        "P": "plus (filled) marker",
+        "*": "star marker",
+        "h": "hexagon1 marker",
+        "H": "hexagon2 marker",
+        "+": "plus marker",
+        "x": "x marker",
+        "X": "x (filled) marker",
+        "D": "diamond marker",
+        "d": "thin_diamond marker",
+        "|": "vline marker",
+        "_": "hline marker",
+    }
+    LINE_STYLE_DATA: ClassVar[dict[str, str]] = {
+        "-": "solid line style",
+        "--": "dashed line style",
+        "-.": "dash-dot line style",
+        ":": "dotted line style",
+    }
+    COLOR_DATA: ClassVar[dict[str, str]] = {
+        "b": "blue",
+        "g": "green",
+        "r": "red",
+        "c": "cyan",
+        "m": "magenta",
+        "y": "yellow",
+        "k": "black",
+        "w": "white",
+    }
+
+    @classmethod
+    def all_format_string(cls) -> list[_PLTFormatString]:
+        # This return full list without full name
+        # return [
+        #     _PLTFormatString._make(x)
+        #     for x in product(cls.MARKER_DATA, cls.LINE_STYLE_DATA, cls.COLOR_DATA)
+        # ]
+
+        # This return full list with full name
+        def convert(
+            x: tuple[tuple[str, str], tuple[str, str], tuple[str, str]],
+        ) -> tuple[str, str, str, str, str, str]:
+            return (x[0][0], x[1][0], x[2][0], x[0][1], x[1][1], x[2][1])
+
+        return [
+            _PLTFormatString._make(convert(x))
+            for x in product(
+                cls.MARKER_DATA.items(),
+                cls.LINE_STYLE_DATA.items(),
+                cls.COLOR_DATA.items(),
+            )
+        ]
+
+    @classmethod
+    def get_random(cls) -> _PLTFormatString:
+        """
+        Get a random format string
+
+        Returns
+        -------
+        str
+            Random format string
+        """
+        random_fmtstr = random.choice(cls.all_format_string())
+        return random_fmtstr