absfuyu 5.0.0__py3-none-any.whl → 6.1.2__py3-none-any.whl

absfuyu/extra/da/dadf_base.py

@@ -0,0 +1,186 @@
+"""
+Absfuyu: Data Analysis
+----------------------
+Data Analyst DataFrame - Base/Core
+
+Version: 6.1.1
+Date updated: 30/12/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,181 @@
+"""
+Absfuyu: Data Analysis
+----------------------
+DF Function
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = [
+    "equalize_df",
+    "compare_2_list",
+    "rename_with_dict",
+    "merge_data_files",
+]
+
+
+# Library
+# ---------------------------------------------------------------------------
+from collections.abc import Mapping
+from itertools import chain
+from pathlib import Path
+from typing import Literal, cast
+
+import numpy as np
+import pandas as pd
+
+from absfuyu.core.docstring import versionadded
+from absfuyu.core.dummy_func import tqdm
+
+
+# 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
+
+
+@versionadded("6.0.0")
+def merge_data_files(
+    work_dir: Path | str,
+    file_type: Literal[".csv", ".xls", ".xlsx"] = ".xlsx",
+    output_file: Path | str | None = None,
+    *,
+    tqdm_enabled: bool = True,
+) -> None:
+    """
+    Merge all data-sheet-like (.csv, .xls, .xlsx) in a folder/directory.
+    Also remove duplicate rows
+
+    Parameters
+    ----------
+    work_dir : Path | str
+        Files in which folder/directory
+
+    file_type : Literal[".csv", ".xls", ".xlsx"], optional
+        File format, by default ``".xlsx"``
+
+    output_file : Path | str | None, optional
+        | Output file location, by default ``None``
+        | File will be export in ``.xlsx`` format
+        | Default export name is ``data_merged.xlsx``
+
+    tqdm_enabled : bool, optional
+        Use ``tqdm`` package to show progress bar (if available), by default ``True``
+    """
+
+    default_name = "data_merged.xlsx"
+    paths = [x for x in Path(work_dir).glob(f"**/*{file_type}") if x.name != default_name]
+    output_path = Path(output_file) if output_file is not None else Path(work_dir).joinpath(default_name)
+
+    dfs = []
+    if tqdm_enabled:
+        for x in tqdm(paths, desc="Merging files", unit_scale=True):
+            dfs.append(pd.read_excel(x))
+    else:
+        for x in paths:
+            dfs.append(pd.read_excel(x))
+
+    df = cast(pd.DataFrame, pd.concat(dfs, axis=0, join="inner")).drop_duplicates().reset_index()
+    df.drop(columns=["index"], inplace=True)
+
+    df.to_excel(output_path, index=False)
+
+
+@versionadded("6.0.0")
+def export_dfs_to_excel(
+    path: str,
+    dfs: Mapping[str, pd.DataFrame],
+    *,
+    index: bool = False,
+) -> None:
+    """
+    Export multiple DataFrames into one Excel file.
+
+    Parameters
+    ----------
+    path : str
+        Output Excel file path.
+
+    dfs : Mapping[str, DataFrame]
+        Sheet name -> DataFrame mapping.
+
+    index : bool, default False
+        Whether to include DataFrame index, by default ``False``
+    """
+    with pd.ExcelWriter(path, engine="openpyxl") as writer:
+        for name, df in dfs.items():
+            name = name[:31]  # Excel sheet name length limit
+            df.to_excel(writer, sheet_name=name, index=index)

absfuyu/extra/da/mplt.py

@@ -0,0 +1,219 @@
+"""
+Absfuyu: Data Analysis
+----------------------
+Matplotlib Helper
+
+Version: 6.1.1
+Date updated: 30/12/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

absfuyu/extra/ggapi/__init__.py

@@ -0,0 +1,8 @@
+"""
+Absfuyu: Google related
+-----------------------
+Google API
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""