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

absfuyu/extra/da/df_func.py

@@ -3,22 +3,33 @@ Absfuyu: Data Analysis
 ----------------------
 DF Function
 
-Version: 5.6.1
-Date updated: 12/09/2025 (dd/mm/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 """
 
 # Module level
 # ---------------------------------------------------------------------------
-__all__ = ["equalize_df", "compare_2_list", "rename_with_dict"]
+__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
 # ---------------------------------------------------------------------------
@@ -73,8 +84,7 @@ def compare_2_list(*arr) -> pd.DataFrame:
 
     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"].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
     )
@@ -95,3 +105,77 @@ def rename_with_dict(df: pd.DataFrame, col: str, rename_dict: dict) -> pd.DataFr
     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

@@ -3,8 +3,8 @@ Absfuyu: Data Analysis
 ----------------------
 Matplotlib Helper
 
-Version: 5.6.1
-Date updated: 12/09/2025 (dd/mm/yyyy)
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
 """
 
 # Module level

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)
+"""

absfuyu/extra/ggapi/gdrive.py

@@ -0,0 +1,223 @@
+"""
+Absfuyu: Google related
+-----------------------
+Google Drive downloader
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["GoogleDriveFile", "GoogleDriveClient"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+import io
+import mimetypes
+from dataclasses import dataclass
+from pathlib import Path
+from typing import ClassVar, cast
+
+from absfuyu.core.baseclass import BaseClass
+
+try:
+    import requests
+    from google.oauth2 import service_account
+    from googleapiclient.discovery import Resource, build
+    from googleapiclient.http import MediaIoBaseDownload
+except ImportError:
+    from subprocess import run
+
+    from absfuyu.config import ABSFUYU_CONFIG
+
+    if ABSFUYU_CONFIG._get_setting("auto-install-extra").value:  # type: ignore
+        cmd = "python -m pip install -U absfuyu[ggapi]".split()
+        run(cmd)
+    else:
+        raise SystemExit("This feature is in absfuyu[ggapi] package")  # noqa: B904
+
+
+# Class
+# ---------------------------------------------------------------------------
+@dataclass(slots=True)
+class DriveFileMeta:
+    id: str
+    name: str
+    mime_type: str
+
+
+class GoogleDriveClient(BaseClass):
+    SCOPES: ClassVar = [
+        "https://www.googleapis.com/auth/drive",
+        "https://www.googleapis.com/auth/spreadsheets",
+    ]
+
+    EXPORT_MIME_MAP: ClassVar = {
+        "application/vnd.google-apps.spreadsheet": (
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            ".xlsx",
+        ),
+        "application/vnd.google-apps.document": (
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+            ".docx",
+        ),
+        "application/vnd.google-apps.presentation": (
+            "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+            ".pptx",
+        ),
+    }
+
+    def __init__(self, service_account_data: str | Path | dict[str, str]) -> None:
+        """
+        Google drive instance
+
+        Parameters
+        ----------
+        service_account_data : str | Path | dict[str, str]
+            Path to ``service_account.json`` file or .json loaded data
+        """
+        if isinstance(service_account_data, str):
+            self.credentials = service_account.Credentials.from_service_account_file(
+                service_account_data,
+                scopes=self.SCOPES,
+            )
+        elif isinstance(service_account_data, Path):
+            self.credentials = service_account.Credentials.from_service_account_file(
+                str(service_account_data.resolve()),
+                scopes=self.SCOPES,
+            )
+        else:
+            self.credentials = service_account.Credentials.from_service_account_info(
+                service_account_data,
+                scopes=self.SCOPES,
+            )
+
+        self.drive = cast(Resource, build("drive", "v3", credentials=self.credentials))
+        self.sheets = cast(Resource, build("sheets", "v4", credentials=self.credentials))
+
+    # Metadata
+    # -----------------------------
+    def get_metadata(self, file_id: str) -> DriveFileMeta:
+        data = self.drive.files().get(fileId=file_id, fields="id,name,mimeType").execute()
+        return DriveFileMeta(
+            id=data["id"],
+            name=data["name"],
+            mime_type=data["mimeType"],
+        )
+
+    # Download / Export
+    # -----------------------------
+    def download_bytes(self, file_id: str) -> bytes:
+        request = self.drive.files().get_media(fileId=file_id)
+        return self._download(request)
+
+    def export_bytes(self, file_id: str, mime_type: str) -> bytes:
+        request = self.drive.files().export_media(
+            fileId=file_id,
+            mimeType=mime_type,
+        )
+        return self._download(request)
+
+    def _download(self, request) -> bytes:
+        buf = io.BytesIO()
+        downloader = MediaIoBaseDownload(buf, request)
+        done = False
+        while not done:
+            _, done = downloader.next_chunk()
+        buf.seek(0)
+        return buf.read()
+
+
+class GoogleDriveFile:
+    """
+    Google drive file to download
+
+
+    Example:
+    --------
+    >>> client = GoogleDriveClient("service_account.json")
+    >>> gfile = GoogleDriveFile(file_id=<id>, client=client)
+    >>> gfile.download(<dir>)
+    """
+
+    PUBLIC_URL = "https://drive.google.com/uc?export=download"
+
+    def __init__(
+        self,
+        file_id: str,
+        *,
+        client: GoogleDriveClient | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self.file_id = file_id
+        self.client = client
+        self.timeout = timeout
+        self.session = requests.Session()
+
+    # Public API
+    # -----------------------------
+    def download(self, directory: str | Path = ".") -> Path:
+        """
+        Download file with auto-detected name and extension.
+        Returns saved file path.
+        """
+        directory = Path(directory)
+        directory.mkdir(parents=True, exist_ok=True)
+
+        if self.client:
+            return self._download_private(directory)
+
+        return self._download_public(directory)
+
+    # Private (Service Account)
+    # -----------------------------
+    def _download_private(self, directory: Path) -> Path:
+        meta = self.client.get_metadata(self.file_id)
+
+        # Google Docs -> export
+        if meta.mime_type in self.client.EXPORT_MIME_MAP:
+            export_mime, ext = self.client.EXPORT_MIME_MAP[meta.mime_type]
+            data = self.client.export_bytes(self.file_id, export_mime)
+            filename = meta.name + ext
+        else:
+            data = self.client.download_bytes(self.file_id)
+            ext = mimetypes.guess_extension(meta.mime_type) or ""
+            filename = meta.name if Path(meta.name).suffix else meta.name + ext
+
+        path = directory / filename
+        path.write_bytes(data)
+        return path
+
+    # Public (no auth)
+    # -----------------------------
+    def _download_public(self, directory: Path) -> Path:
+        response = self.session.get(
+            self.PUBLIC_URL,
+            params={"id": self.file_id},
+            timeout=self.timeout,
+        )
+
+        # confirmation token
+        for k, v in response.cookies.items():
+            if k.startswith("download_warning"):
+                response = self.session.get(
+                    self.PUBLIC_URL,
+                    params={"id": self.file_id, "confirm": v},
+                    timeout=self.timeout,
+                )
+                break
+
+        response.raise_for_status()
+
+        # filename from header (if present)
+        cd = response.headers.get("content-disposition", "")
+        filename = "downloaded_file"
+
+        if "filename=" in cd:
+            filename = cd.split("filename=")[-1].strip('"')
+
+        path = directory / filename
+        path.write_bytes(response.content)
+        return path

absfuyu/extra/ggapi/glicense.py

@@ -0,0 +1,148 @@
+"""
+Absfuyu: Google related
+-----------------------
+Google Online license from sheet
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["GGSheetOnlineLicenseSystem"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+from dataclasses import dataclass
+from datetime import datetime
+from functools import cached_property
+from pathlib import Path
+from typing import Any, Self, cast
+
+from absfuyu.core.baseclass import BaseClass
+from absfuyu.extra.ggapi.gsheet import GoogleSheet
+from absfuyu.tools.sw import HWIDgen, get_system_info
+
+# Var
+# ---------------------------------------------------------------------------
+type GoogleSheetClient = GoogleSheet
+
+
+@dataclass(frozen=True)
+class LicenseEntry:
+    id: int
+    hwid: str
+    name: str
+    os: str
+    date: int | datetime
+    active: bool
+
+    def to_row(self) -> list:
+        return [self.id, self.hwid, self.name, self.os, self.date, self.active]
+
+
+# Class
+# ---------------------------------------------------------------------------
+class GGSheetOnlineLicenseSystem(BaseClass):
+    def __init__(self, google_client: GoogleSheetClient, sheet_id: str, sheet_name: str = "Sheet1") -> None:
+        """
+        Google sheet online license system instance
+
+        Parameters
+        ----------
+        google_client : GoogleSheetClient
+            Google sheet client
+
+        sheet_id : str
+            Sheet ID
+
+        sheet_name : str, optional
+            Sheet name, by default ``"Sheet1"``
+        """
+        self.client = google_client
+        self._sheet_id = sheet_id
+        self._sheet_name = sheet_name
+
+        # Variable
+        self._df: list[LicenseEntry] | None = None
+        try:
+            self._load()
+        except Exception:
+            pass
+
+    # Property
+    @cached_property
+    def hwid(self) -> str:
+        return HWIDgen.generate()
+
+    # Support
+    def _load(self) -> None:
+        df = cast(list[list[Any]], self.client.read_sheet(spreadsheet_id=self._sheet_id, sheet_name=self._sheet_name))
+        data = [LicenseEntry(*x) for x in df]
+        self._df = data
+
+    def _gather_system_info(self) -> list[str]:
+        self._sysif = get_system_info()
+        return [self.hwid, self._sysif.system_name, self._sysif.os_type]
+
+    def _make_device_entry(self) -> list:
+        df = self._df
+        row = [int(df[-1].id) + 1]
+        row.extend(self._gather_system_info())
+        row.extend([datetime.now().strftime("%d/%m/%Y"), False])
+        return row
+
+    def _get_device_online(self):
+        """Get ID of device in sheet, create entry if None"""
+        df = self._df
+
+        for x in df:
+            if x.hwid == self.hwid:
+                return x.id
+
+        has_updated = False  # safe guard
+        if not has_updated:
+            new_entry = self._make_device_entry()
+            self.client.append_rows(self._sheet_id, self._sheet_name, [new_entry])
+            has_updated = True
+        self._load()
+        return new_entry[0]
+
+    # Main
+    def license_check(self) -> None:
+        """Check if activated in sheet"""
+        df = self._df
+        id = self._get_device_online()
+
+        try:
+            for x in df:
+                if x.id == id:
+                    active_status = x.active
+            if not active_status:
+                raise SystemExit("Not activated")
+            return None
+        except Exception:
+            raise SystemExit("Not activated")
+
+    # Classmethod
+    @classmethod
+    def from_service_account(
+        cls, service_account_data: str | Path | dict[str, str], sheet_id: str, sheet_name: str = "Sheet1"
+    ) -> Self:
+        """
+        Google sheet online license system instance
+
+        Parameters
+        ----------
+        service_account_data : str | Path | dict[str, str]
+            Path to ``service_account.json`` file or .json loaded data
+
+        sheet_id : str
+            Sheet ID
+
+        sheet_name : str, optional
+            Sheet name, by default ``"Sheet1"``
+        """
+        client = GoogleSheet(service_account_data)
+        return cls(client, sheet_id, sheet_name)

absfuyu/extra/ggapi/glicense_df.py

@@ -0,0 +1,186 @@
+"""
+Absfuyu: Google related
+-----------------------
+Google Online license from sheet (DataFrame version)
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["GGSheetOnlineLicenseSystemDF"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+from datetime import datetime
+from enum import StrEnum
+from pathlib import Path
+from typing import Self, override
+
+import pandas as pd
+
+from absfuyu.extra.ggapi.glicense import GGSheetOnlineLicenseSystem
+from absfuyu.extra.ggapi.gsheet import GoogleSheet
+
+# Var
+# ---------------------------------------------------------------------------
+AVAILABLE_COLUMNS = ["stt", "hwid", "pc_name", "os", "date", "active"]
+
+
+class DF_COL(StrEnum):
+    TT = "stt"
+    HWID = "hwid"
+    NAME = "pc_name"
+    OS = "OS"
+    DATE = "date"
+    ACTIVE = "active"
+
+
+# Class
+# ---------------------------------------------------------------------------
+class GoogleSheetDF(GoogleSheet):
+    # Sheets — READ (NO DOWNLOAD)
+    # ------------------------------------------------------------------
+    def read_sheet_as_dataframe(
+        self,
+        spreadsheet_id: str,
+        sheet_name: str = "Sheet1",
+        header: bool = True,
+    ) -> pd.DataFrame:
+        """
+        Read Google Sheet directly into DataFrame.
+        """
+        result = (
+            self.sheets.spreadsheets()
+            .values()
+            .get(
+                spreadsheetId=spreadsheet_id,
+                range=sheet_name,
+                valueRenderOption="UNFORMATTED_VALUE",
+            )
+            .execute()
+        )
+
+        values = result.get("values", [])
+        if not values:
+            return pd.DataFrame()
+
+        if header:
+            return pd.DataFrame(values[1:], columns=values[0])
+
+        return pd.DataFrame(values)
+
+    # Sheets — APPEND
+    # ------------------------------------------------------------------
+    def append_dataframe(
+        self,
+        spreadsheet_id: str,
+        range_: str,
+        df: pd.DataFrame,
+    ) -> None:
+        self.append_rows(
+            spreadsheet_id,
+            range_,
+            df.astype(object).where(pd.notnull(df), "").values.tolist(),
+        )
+
+
+type GoogleSheetClient = GoogleSheetDF
+
+
+class GGSheetOnlineLicenseSystemDF(GGSheetOnlineLicenseSystem):
+    def __init__(self, google_client: GoogleSheetClient, sheet_id: str, sheet_name: str = "Sheet1") -> None:
+        """
+        Google sheet online license system instance
+
+        Parameters
+        ----------
+        google_client : GoogleSheetClient
+            Google sheet client
+
+        sheet_id : str
+            Sheet ID
+
+        sheet_name : str, optional
+            Sheet name, by default ``"Sheet1"``
+        """
+        self.client = google_client
+        self._sheet_id = sheet_id
+        self._sheet_name = sheet_name
+
+        # Variable
+        self._df: pd.DataFrame | None = None
+        try:
+            self._load()
+        except Exception:
+            pass
+
+    # Support
+    @override
+    def _load(self) -> None:
+        df = self.client.read_sheet_as_dataframe(spreadsheet_id=self._sheet_id, sheet_name=self._sheet_name)
+        self._df = df
+
+    @override
+    def _make_device_entry(self) -> list:
+        df = self._df
+        row = [int(df[DF_COL.TT].max()) + 1]
+        row.extend(self._gather_system_info())
+        row.extend([datetime.now().strftime("%d/%m/%Y"), False])
+        return row
+
+    @override
+    def _get_device_online(self):
+        """Get ID of device in sheet, create entry if None"""
+        df = self._df
+        id = df[df[DF_COL.HWID] == self.hwid][DF_COL.TT]
+
+        has_updated = False  # safe guard
+        if id is None or id.empty:
+            if not has_updated:
+                new_entry = self._make_device_entry()
+                self.client.append_rows(self._sheet_id, self._sheet_name, [new_entry])
+                has_updated = True
+            self._load()
+            return new_entry[0]
+
+        return id.to_list()[0]
+
+    # Main
+    @override
+    def license_check(self) -> None:
+        """Check if activated in sheet"""
+        df = self._df
+        id = self._get_device_online()
+
+        try:
+            active_status = df[df[DF_COL.TT] == id][DF_COL.ACTIVE].to_list()[0]
+            if not active_status:
+                raise SystemExit("Not activated")
+            return None
+        except Exception:
+            raise SystemExit("Not activated")
+
+    # Classmethod
+    @classmethod
+    def from_service_account(
+        cls, service_account_data: str | Path | dict[str, str], sheet_id: str, sheet_name: str = "Sheet1"
+    ) -> Self:
+        """
+        Google sheet online license system instance
+
+        Parameters
+        ----------
+        service_account_data : str | Path | dict[str, str]
+            Path to ``service_account.json`` file or .json loaded data
+
+        sheet_id : str
+            Sheet ID
+
+        sheet_name : str, optional
+            Sheet name, by default ``"Sheet1"``
+        """
+        client = GoogleSheetDF(service_account_data)
+        return cls(client, sheet_id, sheet_name)