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

absfuyu/logger.py

@@ -14,7 +14,7 @@ Usage:
 """
 
 # Module level
-###########################################################################
+# ---------------------------------------------------------------------------
 __all__ = [
     # logger
     "logger",
@@ -25,7 +25,7 @@ __all__ = [
 
 
 # Library
-###########################################################################
+# ---------------------------------------------------------------------------
 import logging
 import math
 from logging.handlers import RotatingFileHandler as _RFH
@@ -35,7 +35,7 @@ from typing import Any, Optional, Union
 
 
 # Setup
-###########################################################################
+# ---------------------------------------------------------------------------
 class LogLevel:
     """
     ``logging``'s log level wrapper + custom log level
@@ -70,11 +70,12 @@ console_handler.setLevel(LogLevel.TRACE)  # Minimum log level
 console_handler.setFormatter(
     logging.Formatter(_LogFormat.CONSOLE, datefmt="%Y-%m-%d %H:%M:%S")
 )
-logger.addHandler(console_handler)
+# logger.addHandler(console_handler)
+logger.addHandler(logging.NullHandler())
 
 
 # Functions
-###########################################################################
+# ---------------------------------------------------------------------------
 def _compress_list_for_print(iterable: list, max_visible: Optional[int] = 5) -> str:
     """
     Compress the list to be more log-readable
@@ -100,7 +101,7 @@ def _compress_list_for_print(iterable: list, max_visible: Optional[int] = 5) ->
         # temp = [iterable[:cut_idx_1], ["..."], iterable[len(iterable)-cut_idx_2:]]
         # out = list(chain.from_iterable(temp))
         # out = [*iterable[:cut_idx_1], "...", *iterable[len(iterable)-cut_idx_2:]] # Version 2
-        out = f"{str(iterable[:cut_idx_1])[:-1]}, ...,{str(iterable[len(iterable) - cut_idx_2 :])[1:]}"  # Version 3
+        out = f"{str(iterable[:cut_idx_1])[:-1]}, ..., {str(iterable[len(iterable) - cut_idx_2 :])[1:]}"  # Version 3
         # logger.debug(out)
         return f"{out} [Len: {len(iterable)}]"
 
@@ -158,7 +159,7 @@ def compress_for_log(object_: Any, max_visible: Optional[int] = None) -> str:
 
 
 # Class
-###########################################################################
+# ---------------------------------------------------------------------------
 class _CustomLogger:
     """
     Custom logger [W.I.P]
@@ -341,9 +342,3 @@ class _CustomLogger:
         if level_num < logging.DEBUG:
             self._console_handler.setLevel(level_num)
             self.logger.setLevel(level_num)
-
-
-# Run
-###########################################################################
-if __name__ == "__main__":
-    logger.setLevel(LogLevel.DEBUG)

absfuyu/pkg_data/__init__.py

@@ -3,147 +3,185 @@ Absfuyu: Package data
 ---------------------
 Load package data
 
-Version: 2.2.3
+Version: 5.0.0
 Date updated: 14/11/2024 (dd/mm/yyyy)
 """
 
 # Module level
-###########################################################################
-__all__ = ["PkgData"]
+# ---------------------------------------------------------------------------
+__all__ = [
+    "Pickler",
+    "BasicLZMAOperation",
+    "DataLoader",
+    # "DataList",  # Disable due to Sphinx show real path, still importable
+]
 
 
 # Library
-###########################################################################
-import zlib
-from ast import literal_eval
-from importlib.resources import files, read_binary
+# ---------------------------------------------------------------------------
+import lzma
+import pickle
+from enum import Enum
+from importlib.resources import files
 from pathlib import Path
+from typing import Any
 
-from absfuyu.core import DATA_PATH
-from absfuyu.logger import logger
-
-# External Data
-###########################################################################
-_EXTERNAL_DATA = {
-    "chemistry.json": "https://raw.githubusercontent.com/Bowserinator/Periodic-Table-JSON/master/PeriodicTableJSON.json",
-    "countries.json": "https://github.com/dr5hn/countries-states-cities-database/blob/master/countries.json",
-    "tarot.json": "https://raw.githubusercontent.com/dariusk/corpora/master/data/divination/tarot_interpretations.json",
-    "word_list.json": "https://raw.githubusercontent.com/dwyl/english-words/master/words_dictionary.json",
-}
+from absfuyu.core import BaseClass, versionadded
 
 
 # Class
-###########################################################################
-class DataList:
+# ---------------------------------------------------------------------------
+class DataList(Enum):
     CHEMISTRY = files("absfuyu.pkg_data").joinpath("chemistry.pkl")
     TAROT = files("absfuyu.pkg_data").joinpath("tarot.pkl")
+    PASSWORDLIB = files("absfuyu.pkg_data").joinpath("passwordlib_lzma.pkl")
 
 
-class PkgData:
-    """Package data maker/loader"""
+class Pickler(BaseClass):
+    """
+    A utility class for saving and loading data using the pickle format.
 
-    def __init__(self, data_name: str) -> None:
-        self.name = data_name
+    This class provides static methods for serializing Python objects to a file
+    using the ``pickle`` module and deserializing them back from a file.
+    It simplifies the process of saving and loading data to and from pickle files.
+    """
 
-    def __str__(self) -> str:
-        return f"{self.__class__.__name__}({self.name})"
+    @staticmethod
+    def save(location: Path, data: Any) -> None:
+        """
+        Serializes and saves the given data to a file using the pickle format.
 
-    def __repr__(self) -> str:
-        return self.__str__()
+        Parameters
+        ----------
+        location : Path
+            The path to the file where the data will be saved.
 
-    def _make_dat(self, data: str, name: str | Path):
-        """
-        data: string data
-        name: name and location of the data
+        data : Any
+            The Python object to be serialized and saved.
         """
-        compressed_data = zlib.compress(str(data).encode(), zlib.Z_BEST_COMPRESSION)
-        with open(name, "wb") as file:
-            file.write(compressed_data)
+        with open(Path(location), "wb") as file:
+            pickle.dump(data, file)
 
-    def load_dat_data(self, evaluate: bool = False):
+    @staticmethod
+    def load(location: Path):
         """
-        Load ``.dat`` data from package resource
+        Loads and deserializes data from a file that is in pickle format.
 
-        :param evaluate: use ``ast.literal_eval()`` to evaluate string data
-        :type evaluate: bool
-        :returns: Loaded data
-        :rtype: Any
-        """
-        compressed_data = read_binary("absfuyu.pkg_data", self.name)
-        data = zlib.decompress(compressed_data).decode()
-        # return data
-        return literal_eval(data) if evaluate else data
+        Parameters
+        ----------
+        location : Path
+            The path to the pickle file to load.
 
-    def update_data(self, new_data: str):
+        Returns
+        -------
+        Any
+            The deserialized Python object loaded from the file.
         """
-        Update existing data
+        with open(Path(location), "rb") as file:
+            data = pickle.load(file)
+        return data
+
+
+@versionadded("5.0.0")
+class BasicLZMAOperation(BaseClass):
+    """
+    A class for basic LZMA compression and decompression operations,
+    integrated with pickle for saving and loading compressed data.
 
-        :param new_data: Data to be updated
+    This class provides static methods to compress data using LZMA,
+    save the compressed data to a pickle file, load compressed data
+    from a pickle file, and decompress LZMA-compressed data.
+    """
+
+    @staticmethod
+    def save_to_pickle(location: Path, data: bytes) -> None:
         """
-        self._make_dat(data=new_data, name=DATA_PATH.joinpath(self.name))  # type:ignore
-        logger.debug("Data updated")
+        Compresses the given byte data using LZMA and saves the compressed
+        data to a file using pickle serialization.
+
+        Parameters
+        ----------
+        location : Path
+            The path to the file where the compressed data will be saved.
 
+        data : bytes
+            The byte data to be compressed and saved.
 
-class _ManagePkgData:
-    """Manage this package data"""
 
-    def __init__(self, pkg_data_loc: str | Path) -> None:
+        Example:
+        --------
+        >>> data = b"This is some example data to compress."
+        >>> BasicLZMAOperation.save_to_pickle(Path("compressed_data.pkl"), data)
         """
-        pkg_data_loc: Package data location
+        compressed_data = lzma.compress(data)
+        Pickler.save(location=location, data=compressed_data)
+
+    @staticmethod
+    def load(data: Any) -> bytes:
         """
-        self.data_loc = Path(pkg_data_loc)
+        Decompresses LZMA-compressed data.
 
-    def __str__(self) -> str:
-        return f"{self.__class__.__name__}({self.data_loc.name})"
+        Parameters
+        ----------
+        data : Any
+            The LZMA-compressed data to be decompressed.
 
-    def __repr__(self) -> str:
-        return self.__str__()
+        Returns
+        -------
+        bytes
+            The decompressed data.
+        """
+        return lzma.decompress(data)
 
-    def get_data_list(self, *, pattern: str = "*") -> list[Path]:
-        """Get a list of data available"""
-        excludes = [
-            x for x in self.data_loc.glob("*.[pP][yY]")
-        ]  # exclude python scripts
-        return [
-            x for x in self.data_loc.glob(pattern) if x not in excludes and x.is_file()
-        ]
+    @staticmethod
+    def load_from_pickle(location: Path) -> bytes:
+        """
+        Loads LZMA-compressed data from a pickle file, decompresses it.
 
-    @property
-    def data_list(self) -> list[str]:
-        """List of available data"""
-        return [x.name for x in self.get_data_list()]
+        Parameters
+        ----------
+        location : Path
+            The path to the pickle file containing the LZMA-compressed data.
 
-    def download_all_data(self):
-        """
-        Download all external data
+        Returns
+        -------
+        bytes
+            The decompressed data.
         """
+        compressed_data = Pickler.load(location=location)
+        return lzma.decompress(compressed_data)
 
-        logger.debug("Downloading data...")
-        try:
-            from absfuyu.util.api import APIRequest
-
-            for data_name, data_link in _EXTERNAL_DATA.items():
-                logger.debug(f"Downloading {data_name}...")
-                data = APIRequest(data_link, encoding="utf-8")
-                data.fetch_data(
-                    update=True,
-                    json_cache=DATA_PATH.joinpath(data_name),  # type:ignore
-                )
-                logger.debug(f"Downloading {data_name}...DONE")
-            logger.debug("Downloading data...DONE")
-        except Exception:
-            logger.debug("Downloading data...FAILED")
 
-    def clear_data(self) -> None:
-        """Clear data in data list"""
-        for x in self.get_data_list():
-            x.unlink()
+@versionadded("5.0.0")
+class DataLoader(BaseClass):
+    """A class to load package data"""
+
+    def __init__(self, data: DataList) -> None:
+        """
+        Initializes the DataLoader with a DataList object.
 
+        Parameters
+        ----------
+        data : DataList
+            A ``DataList`` object containing information about the data file to be loaded.
+            It is expected to have a ``'value'`` attribute representing the file path.
+        """
+        self.data = data
 
-PACKAGE_DATA = _ManagePkgData(DATA_PATH)  # type:ignore
+    def load(self):
+        """
+        Loads data from the specified file, handling different file formats automatically.
 
+        Returns
+        -------
+        Any
+            The loaded data from the file.
+        """
+        try:
+            data_name: str = self.data.value.stem  # type: ignore
+        except Exception:
+            data_name: str = self.data.value.name.split(".")[0]  # type: ignore
 
-# Run
-###########################################################################
-if __name__ == "__main__":
-    logger.setLevel(10)
+        if data_name.endswith("lzma"):
+            return BasicLZMAOperation.load_from_pickle(self.data.value)  # type: ignore
+        return Pickler.load(self.data.value)  # type: ignore

absfuyu/pkg_data/deprecated.py

@@ -0,0 +1,133 @@
+"""
+Absfuyu: Package data
+---------------------
+Deprecated (but might have some use)
+
+Version: 2.2.3
+Date updated: 14/11/2024 (dd/mm/yyyy)
+"""
+
+# Library
+# ---------------------------------------------------------------------------
+import zlib
+from ast import literal_eval
+from importlib.resources import files, read_binary
+from pathlib import Path
+
+from absfuyu.core import BaseClass
+from absfuyu.logger import logger
+
+# External Data
+# ---------------------------------------------------------------------------
+# These are sources of data
+_EXTERNAL_DATA = {
+    "chemistry.json": "https://raw.githubusercontent.com/Bowserinator/Periodic-Table-JSON/master/PeriodicTableJSON.json",
+    "tarot.json": "https://raw.githubusercontent.com/dariusk/corpora/master/data/divination/tarot_interpretations.json",
+    "word_list.json": "https://raw.githubusercontent.com/dwyl/english-words/master/words_dictionary.json",
+    # "countries.json": "https://raw.githubusercontent.com/dr5hn/countries-states-cities-database/refs/heads/master/json/countries.json",
+}
+
+
+# Deprecated
+# ---------------------------------------------------------------------------
+DATA_PATH = files("absfuyu.pkg_data")
+
+
+class _DatMaker(BaseClass):
+    """
+    Package data ``.dat`` maker/loader
+
+    *Deprecated since version 5.0.0*
+    """
+
+    def __init__(self, data_name: str) -> None:
+        self.name = data_name
+
+    def _make_dat(self, data: str, name: str | Path):
+        """
+        :param data: string data
+        :param name: name and location of the data
+        """
+        compressed_data = zlib.compress(str(data).encode(), zlib.Z_BEST_COMPRESSION)
+        with open(name, "wb") as file:
+            file.write(compressed_data)
+
+    def load_dat_data(self, evaluate: bool = False):
+        """
+        Load ``.dat`` data from package resource
+
+        :param evaluate: use ``ast.literal_eval()`` to evaluate string data
+        :type evaluate: bool
+        :returns: Loaded data
+        :rtype: Any
+        """
+        compressed_data = read_binary("absfuyu.pkg_data", self.name)
+        data = zlib.decompress(compressed_data).decode()
+        # return data
+        return literal_eval(data) if evaluate else data
+
+    def update_data(self, new_data: str):
+        """
+        Update existing data
+
+        :param new_data: Data to be updated
+        """
+        self._make_dat(data=new_data, name=DATA_PATH.joinpath(self.name))  # type:ignore
+        logger.debug("Data updated")
+
+
+class _ManagePkgData(BaseClass):
+    """
+    Manage this package data
+
+    *Deprecated since version 5.0.0*
+    """
+
+    def __init__(self, pkg_data_loc: str | Path) -> None:
+        """
+        pkg_data_loc: Package data location
+        """
+        self.data_loc = Path(pkg_data_loc)
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}({self.data_loc.name})"
+
+    def get_data_list(self, *, pattern: str = "*") -> list[Path]:
+        """Get a list of data available"""
+        excludes = [
+            x for x in self.data_loc.glob("*.[pP][yY]")
+        ]  # exclude python scripts
+        return [
+            x for x in self.data_loc.glob(pattern) if x not in excludes and x.is_file()
+        ]
+
+    @property
+    def data_list(self) -> list[str]:
+        """List of available data"""
+        return [x.name for x in self.get_data_list()]
+
+    def download_all_data(self):
+        """
+        Download all external data
+        """
+
+        logger.debug("Downloading data...")
+        try:
+            from absfuyu.util.api import APIRequest
+
+            for data_name, data_link in _EXTERNAL_DATA.items():
+                logger.debug(f"Downloading {data_name}...")
+                data = APIRequest(data_link, encoding="utf-8")
+                data.fetch_data(
+                    update=True,
+                    json_cache=DATA_PATH.joinpath(data_name),  # type: ignore
+                )
+                logger.debug(f"Downloading {data_name}...DONE")
+            logger.debug("Downloading data...DONE")
+        except Exception:
+            logger.debug("Downloading data...FAILED")
+
+    def clear_data(self) -> None:
+        """Clear data in data list"""
+        for x in self.get_data_list():
+            x.unlink()

absfuyu/sort.py

@@ -1,22 +1,18 @@
-# type: ignore
 """
 Absfuyu: Sort
 -------------
 Sort Module
 
-Version: 1.2.4
-Date updated: 20/03/2024 (mm/dd/yyyy)
+Version: 1.3.0
+Date updated: 11/02/2025 (mm/dd/yyyy)
 """
 
 # Module level
-###########################################################################
+# ---------------------------------------------------------------------------
 __all__ = [
     # Sort
     "selection_sort",
     "insertion_sort",
-    # Alphabet
-    "alphabetAppear",
-    "AlphabetAppearResult",
     # Search
     "linear_search",
     "binary_search",
@@ -24,22 +20,12 @@ __all__ = [
 
 
 # Library
-###########################################################################
-import operator
-from collections import Counter
-from itertools import accumulate
-from typing import Any, Dict, List, NamedTuple, Union
-
-from deprecated import deprecated
-from deprecated.sphinx import (
-    deprecated as sphinx_deprecated,  # versionadded,; versionchanged,
-)
-
-from absfuyu.logger import logger
+# ---------------------------------------------------------------------------
+from typing import Any
 
 
 # Functions
-###########################################################################
+# ---------------------------------------------------------------------------
 def selection_sort(iterable: list, reverse: bool = False) -> list:
     """
     Sort the list with selection sort (bubble sort) algorithm
@@ -100,110 +86,6 @@ def insertion_sort(iterable: list) -> list:
     return iterable
 
 
-def _alphabetAppear_old(
-    lst: List[str],
-) -> List[Union[Dict[str, int], List[int]]]:
-    r"""
-    Summary
-    -------
-    Make a dict that show the frequency of
-    item name's first character in list
-    in alphabet order
-
-    For example:
-
-    >>> ["apple","bee","book"]
-
-    freq = {"a": 1, "b": 2}
-
-    Parameters
-    ----------
-    lst : list
-        list that want to be analyzed
-
-    Returns
-    -------
-    list
-        analyzed list (list[0])
-        apperance incremental value index (list[1])
-    """
-
-    al_char = [x[0] for x in selection_sort(lst)]
-    times_appear = dict()
-    for x in al_char:
-        if x in times_appear:
-            times_appear[x] += 1
-        else:
-            times_appear[x] = 1
-
-    times_appear_increment = []
-    total = 0
-    for x in times_appear.values():
-        total += x
-        times_appear_increment.append(total)
-
-    # first item is character frequency
-    # second item is incremental index list
-    return [times_appear, times_appear_increment]
-
-
-class AlphabetAppearResult(NamedTuple):
-    times_appear: Dict[str, int]
-    times_appear_increment: List[int]
-
-
-@deprecated(version="3.0.0", reason="In absfuyu ``ListExt``")
-@sphinx_deprecated(version="3.0.0", reason="In absfuyu ``ListExt``")
-def alphabetAppear(iterable: list, num_of_char_sorted: int = 1) -> AlphabetAppearResult:
-    """
-    Make a dict that show the frequency of
-    item name's first character in list
-    in alphabet order
-
-    Parameters
-    ----------
-    iterable : list
-        List that want to be analyzed
-
-    num_of_char_sorted : int
-        Number of first character taken into account to sort
-        (default: ``1`` - first character in each item)
-
-    Returns
-    -------
-    AlphabetAppearResult
-        | Analyzed list (``AlphabetAppearResult.times_appear``)
-        | Apperance incremental value index (``AlphabetAppearResult.times_appear_increment``)
-
-
-    Example:
-    --------
-    >>> alphabetAppear(["apple", "bee", "book"])
-    AlphabetAppearResult(times_appear={'a': 1, 'b': 2}, times_appear_increment=[1, 3])
-    """
-
-    if not isinstance(num_of_char_sorted, int):
-        logger.debug("num_of_char_sorted is not int")
-        num_of_char_sorted = 1
-    if num_of_char_sorted < 1:
-        logger.debug("num_of_char_sorted < 1")
-        num_of_char_sorted = 1
-    if num_of_char_sorted > min([len(str(x)) for x in iterable]):
-        logger.debug("num_of_char_sorted > item length")
-        num_of_char_sorted = min([len(str(x)) for x in iterable])
-    temp = Counter([str(x)[:num_of_char_sorted] for x in iterable])
-    times_appear = dict(sorted(temp.items()))
-    logger.debug(times_appear)
-
-    temp = accumulate(times_appear.values(), operator.add)
-    times_appear_increment: List[int] = list(temp)
-    logger.debug(times_appear_increment)
-
-    # first item is character frequency
-    # second item is incremental index list
-    return AlphabetAppearResult(times_appear, times_appear_increment)
-
-
 def linear_search(iterable: list, key: Any) -> int:
     """
     Returns the position of ``key`` in the list
@@ -256,9 +138,3 @@ def binary_search(iterable: list, key: Any) -> int:
         if iterable[middle] < key:
             left = middle + 1
     return -1
-
-
-# Run
-###########################################################################
-if __name__ == "__main__":
-    logger.setLevel(10)

absfuyu/tools/__init__.py

@@ -3,6 +3,6 @@ Absfuyu: Tools
 --------------
 Some useful tools
 
-Version: 1.0.1
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 5.0.0
+Date updated: 15/02/2025 (dd/mm/yyyy)
 """