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

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)

absfuyu/extra/ggapi/gsheet.py

@@ -0,0 +1,88 @@
+"""
+Absfuyu: Google related
+-----------------------
+Google Sheet
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["GoogleSheet"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+from typing import Any
+
+from absfuyu.extra.ggapi.gdrive import GoogleDriveClient
+
+
+# Class
+# ---------------------------------------------------------------------------
+class GoogleSheet(GoogleDriveClient):
+    # Sheets — READ (NO DOWNLOAD)
+    # ------------------------------------------------------------------
+    def read_sheet(
+        self,
+        spreadsheet_id: str,
+        sheet_name: str = "Sheet1",
+        header: bool = True,
+    ) -> list[list[Any]]:
+        """
+        Read Google Sheet directly.
+        """
+        result = (
+            self.sheets.spreadsheets()
+            .values()
+            .get(
+                spreadsheetId=spreadsheet_id,
+                range=sheet_name,
+                valueRenderOption="UNFORMATTED_VALUE",
+            )
+            .execute()
+        )
+
+        values = result.get("values", [])
+        if values and header:
+            return values[1:]
+
+        return values
+
+    # Sheets — APPEND
+    # ------------------------------------------------------------------
+    def append_rows(
+        self,
+        spreadsheet_id: str,
+        range_: str,
+        rows: list[list],
+    ) -> None:
+        """
+        Append rows to Google Sheet.
+        """
+        self.sheets.spreadsheets().values().append(
+            spreadsheetId=spreadsheet_id,
+            range=range_,
+            valueInputOption="USER_ENTERED",
+            insertDataOption="INSERT_ROWS",
+            body={"values": rows},
+        ).execute()
+
+    # Sheets — UPDATE
+    # ------------------------------------------------------------------
+    def update_range(
+        self,
+        spreadsheet_id: str,
+        range_: str,
+        values: list[list],
+    ) -> None:
+        """
+        Update an existing cell range.
+        """
+        self.sheets.spreadsheets().values().update(
+            spreadsheetId=spreadsheet_id,
+            range=range_,
+            valueInputOption="USER_ENTERED",
+            body={"values": values},
+        ).execute()

absfuyu/extra/img/__init__.py

@@ -0,0 +1,30 @@
+"""
+Absfuyu: Image
+--------------
+Image related
+
+Version: 6.1.1
+Date updated: 30/12/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+# ---------------------------------------------------------------------------
+__all__ = ["ImgConverter"]
+
+
+# Library
+# ---------------------------------------------------------------------------
+try:
+    from PIL import Image
+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[pic]".split()
+        run(cmd)
+    else:
+        raise SystemExit("This feature is in absfuyu[pic] package")  # noqa: B904
+
+from absfuyu.extra.img.converter import ImgConverter