absfuyu 3.4.0__py3-none-any.whl → 4.1.0__py3-none-any.whl

absfuyu/game/sudoku.py

@@ -3,8 +3,8 @@ Game: Sudoku
 ------------
 Sudoku 9x9 Solver
 
-Version: 1.0.2
-Date updated: 24/11/2023 (mm/dd/yyyy)
+Version: 1.0.3
+Date updated: 15/11/2024 (dd/mm/yyyy)
 
 Credit:
 -------
@@ -15,11 +15,12 @@ Credit:
 __all__ = ["Sudoku"]
 
 
-from typing import List, Literal, Tuple
+from typing import Literal
 
 
 class Sudoku:
-    def __init__(self, sudoku_data: List[List[int]]) -> None:
+
+    def __init__(self, sudoku_data: list[list[int]]) -> None:
         self.data = sudoku_data
         # self._original = sudoku_data # Make backup
         self._row_len = len(self.data)
@@ -194,7 +195,7 @@ class Sudoku:
         # Return None when there is no empty cell
         return None
 
-    def _is_valid(self, number: int, position: Tuple[int, int]) -> bool:
+    def _is_valid(self, number: int, position: tuple[int, int]) -> bool:
         """
         Check valid number value in row, column, box
         """

absfuyu/game/tictactoe.py

@@ -2,8 +2,8 @@
 Game: Tic Tac Toe
 -----------------
 
-Version: 2.0.3
-Date updated: 05/04/2024 (mm/dd/yyyy)
+Version: 2.0.4
+Date updated: 15/11/2024 (dd/mm/yyyy)
 """
 
 __all__ = ["TicTacToe", "GameMode"]
@@ -11,11 +11,11 @@ __all__ = ["TicTacToe", "GameMode"]
 
 import random
 import time
-from typing import List, Literal, NamedTuple
+from typing import Literal, NamedTuple
 
 from absfuyu.core import CLITextColor
 
-BoardGame = List[List[str]]
+BoardGame = list[list[str]]
 
 
 class Pos(NamedTuple):

absfuyu/general/content.py

@@ -427,12 +427,12 @@ class ContentLoader:
             self.tag_dictionary = tag_dictionary
 
         # symbol stuff
-        assert (
-            comment_symbol != split_symbol
-        ), "comment_symbol and split_symbol should have different values"
-        assert (
-            tag_separate_symbol != split_symbol
-        ), "tag_separate_symbol and split_symbol should have different values"
+        assert comment_symbol != split_symbol, (
+            "comment_symbol and split_symbol should have different values"
+        )
+        assert tag_separate_symbol != split_symbol, (
+            "tag_separate_symbol and split_symbol should have different values"
+        )
         self.comment_symbol: str = comment_symbol
         self.split_symbol: str = split_symbol
         self.tag_separate_symbol: str = tag_separate_symbol
@@ -485,7 +485,7 @@ class ContentLoader:
                 if x.startswith(self.comment_symbol) or len(x) == 0:
                     continue  # skip comment and empty lines
                 logger.debug(
-                    f"### Loop {i+1} #####################################################################"
+                    f"### Loop {i + 1} #####################################################################"
                 )
 
                 temp = x.split(self.split_symbol)

absfuyu/general/data_extension.py

@@ -3,8 +3,8 @@ Absfuyu: Data extension
 -----------------------
 Extension for data type such as ``list``, ``str``, ``dict``, ...
 
-Version: 1.15.0
-Date updated: 27/04/2024 (dd/mm/yyyy)
+Version: 1.15.2
+Date updated: 06/01/2025 (dd/mm/yyyy)
 
 Features:
 ---------
@@ -47,23 +47,7 @@ import operator
 import random
 from collections import Counter
 from itertools import accumulate, chain, groupby
-from sys import version_info as _python_version
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    List,
-    NamedTuple,
-    Optional,
-    Tuple,
-    TypedDict,
-    Union,
-)
-
-if _python_version.minor >= 11:
-    from typing import NotRequired, Self
-else:
-    from typing_extensions import NotRequired, Self  # type: ignore
+from typing import Any, Callable, NamedTuple, NotRequired, Self, TypedDict, Union
 
 from deprecated.sphinx import versionadded, versionchanged
 
@@ -74,7 +58,7 @@ from absfuyu.util import set_min, set_min_max
 
 # Function
 ###########################################################################
-def _dict_bool(dict_object: dict, option: bool) -> Optional[dict]:
+def _dict_bool(dict_object: dict, option: bool) -> dict | None:
     """
     Support function DictBool class
     """
@@ -93,7 +77,7 @@ def _dict_bool(dict_object: dict, option: bool) -> Optional[dict]:
 class Pow:
     """Number power by a number"""
 
-    def __init__(self, number: Union[int, float], power_by: Union[int, float]) -> None:
+    def __init__(self, number: int | float, power_by: int | float) -> None:
         self.number = number
         self.power_by = power_by
 
@@ -107,7 +91,7 @@ class Pow:
     def __repr__(self) -> str:
         return self.__str__()
 
-    def to_list(self) -> List[Union[int, float]]:
+    def to_list(self) -> list[int | float]:
         """
         Convert into list
 
@@ -132,7 +116,7 @@ class ListREPR(list):
         return _compress_list_for_print(self, 9)
 
 
-class ListNoDunder(List[str]):
+class ListNoDunder(list[str]):
     """Use with ``object.__dir__()``"""
 
     def __repr__(self) -> str:
@@ -140,7 +124,7 @@ class ListNoDunder(List[str]):
         return out.__repr__()
 
 
-class DictBoolTrue(Dict[Any, bool]):
+class DictBoolTrue(dict[Any, bool]):
     """Only show items when ``values == True`` in ``__repr__()``"""
 
     def __repr__(self) -> str:
@@ -148,7 +132,7 @@ class DictBoolTrue(Dict[Any, bool]):
         return _dict_bool(temp, True).__repr__()
 
 
-class DictBoolFalse(Dict[Any, bool]):
+class DictBoolFalse(dict[Any, bool]):
     """Only show items when ``values == False`` in ``__repr__()``"""
 
     def __repr__(self) -> str:
@@ -206,8 +190,8 @@ class DictAnalyzeResult(NamedTuple):
     Result for ``DictExt.analyze()``
     """
 
-    max_value: Union[int, float]
-    min_value: Union[int, float]
+    max_value: int | float
+    min_value: int | float
     max_list: list
     min_list: list
 
@@ -220,7 +204,7 @@ class Text(str):
     ``str`` extension
     """
 
-    def divide(self, string_split_size: int = 60) -> List[str]:
+    def divide(self, string_split_size: int = 60) -> list[str]:
         """
         Divide long string into smaller size
 
@@ -255,8 +239,8 @@ class Text(str):
         self,
         split_size: int = 60,
         split_var_len: int = 12,
-        custom_var_name: Optional[str] = None,
-    ) -> List[str]:
+        custom_var_name: str | None = None,
+    ) -> list[str]:
         """
         Divide long string into smaller size,
         then assign a random variable to splited
@@ -318,7 +302,7 @@ class Text(str):
                 output.append(f"{splt_name[i]}='{temp[i]}'")
         else:
             for i in range(splt_len):
-                output.append(f"{custom_var_name}{i+1}='{temp[i]}'")
+                output.append(f"{custom_var_name}{i + 1}='{temp[i]}'")
 
         # joined variable
         temp = []
@@ -335,9 +319,9 @@ class Text(str):
                 if i == 0:
                     temp.append(f"{custom_var_name}=")
                 if i == splt_len - 1:
-                    temp.append(f"{custom_var_name}{i+1}")
+                    temp.append(f"{custom_var_name}{i + 1}")
                 else:
-                    temp.append(f"{custom_var_name}{i+1}+")
+                    temp.append(f"{custom_var_name}{i + 1}+")
 
         output.append("".join(temp))
         if custom_var_name is None:
@@ -546,7 +530,7 @@ class Text(str):
                 temp[i] = x.upper()
         return self.__class__("".join(temp))
 
-    def to_list(self) -> List[str]:
+    def to_list(self) -> list[str]:
         """
         Convert into list
 
@@ -625,7 +609,7 @@ class Text(str):
         return sum(out)
 
     @versionadded(version="3.3.0")
-    def hapax(self, strict: bool = False) -> List[str]:
+    def hapax(self, strict: bool = False) -> list[str]:
         """
         A hapax legomenon (often abbreviated to hapax)
         is a word which occurs only once in either
@@ -656,9 +640,9 @@ class Text(str):
         >>> test.hapax(strict=True)
         ['b']
         """
-        word_list: List[str] = self.lower().split()
+        word_list: list[str] = self.lower().split()
         if strict:
-            remove_characters: List[str] = list(r"\"'.,:;|()[]{}\/!@#$%^&*-_=+?<>`~")
+            remove_characters: list[str] = list(r"\"'.,:;|()[]{}\/!@#$%^&*-_=+?<>`~")
             temp = str(self)
             for x in remove_characters:
                 temp = temp.replace(x, "")
@@ -845,7 +829,7 @@ class IntNumber(int):
 
         else:
             # Faster way to check
-            perfect_number_index: List[int] = [
+            perfect_number_index: list[int] = [
                 61,
                 89,
                 107,
@@ -982,7 +966,7 @@ class IntNumber(int):
         return self.is_palindromic() and self.is_prime()
 
     # calculation stuff
-    @versionchanged(version="3.3.0", reason="Fix bug")
+    @versionchanged(version="4.0.0", reason="Update")
     def lcm(self, with_number: int) -> Self:
         """
         Least common multiple of ``self`` and ``with_number``
@@ -1004,10 +988,7 @@ class IntNumber(int):
         >>> test.lcm(5)
         510
         """
-        try:
-            return self.__class__(math.lcm(self, with_number))
-        except AttributeError:  # Python < 3.9
-            return self.__class__((self * with_number) // math.gcd(self, with_number))
+        return self.__class__(math.lcm(self, with_number))
 
     @versionchanged(version="3.3.0", reason="Fix bug")
     def gcd(self, with_number: int) -> Self:
@@ -1072,7 +1053,7 @@ class IntNumber(int):
             logger.debug(f"Sum after loop: {number}")
         return self.__class__(number)
 
-    def divisible_list(self, short_form: bool = True) -> List[int]:
+    def divisible_list(self, short_form: bool = True) -> list[int]:
         """
         A list of divisible number
 
@@ -1106,7 +1087,7 @@ class IntNumber(int):
             # return ListREPR(divi_list) ## FIX LATER
         return divi_list
 
-    def prime_factor(self, short_form: bool = True) -> Union[List[int], List[Pow]]:
+    def prime_factor(self, short_form: bool = True) -> Union[list[int], list[Pow]]:
         """
         Prime factor
 
@@ -1156,7 +1137,7 @@ class IntNumber(int):
         return factors
 
     # analyze
-    def analyze(self, short_form: bool = True) -> Dict[str, Dict[str, Any]]:
+    def analyze(self, short_form: bool = True) -> dict[str, dict[str, Any]]:
         """
         Analyze the number with almost all ``IntNumber`` method
 
@@ -1236,7 +1217,7 @@ class ListExt(list):
         >>> test.stringify()
         ['1', '1', '1', '2', '2', '3']
         """
-        return ListExt(map(str, self))
+        return self.__class__(map(str, self))
 
     def head(self, number_of_items: int = 5) -> list:
         """
@@ -1318,9 +1299,9 @@ class ListExt(list):
     def freq(
         self,
         sort: bool = False,
-        num_of_first_char: Optional[int] = None,
+        num_of_first_char: int | None = None,
         appear_increment: bool = False,
-    ) -> Union[dict, List[int]]:
+    ) -> Union[dict, list[int]]:
         """
         Find frequency of each item in list
 
@@ -1383,7 +1364,7 @@ class ListExt(list):
         logger.debug(times_appear)
 
         if appear_increment:
-            times_appear_increment: List[int] = list(
+            times_appear_increment: list[int] = list(
                 accumulate(times_appear.values(), operator.add)
             )
             logger.debug(times_appear_increment)
@@ -1391,7 +1372,7 @@ class ListExt(list):
         else:
             return times_appear
 
-    def slice_points(self, points: list) -> List[list]:
+    def slice_points(self, points: list) -> list[list]:
         """
         Slices a list at specific indices into constituent lists.
 
@@ -1474,7 +1455,7 @@ class ListExt(list):
         >>> test.len_items()
         [3, 3, 5]
         """
-        out = ListExt([len(str(x)) for x in self])
+        out = self.__class__([len(str(x)) for x in self])
         # out = ListExt(map(lambda x: len(str(x)), self))
         logger.debug(out)
         return out
@@ -1566,13 +1547,13 @@ class ListExt(list):
         return self.__class__([list(g) for _, g in temp])
 
     @staticmethod
-    def _group_by_unique(iterable: list) -> List[list]:
+    def _group_by_unique(iterable: list) -> list[list]:
         """
         Static method for ``group_by_unique``
         """
         return list([list(g) for _, g in groupby(iterable)])
 
-    def group_by_pair_value(self, max_loop: int = 3) -> List[list]:
+    def group_by_pair_value(self, max_loop: int = 3) -> list[list]:
         """
         Assume each ``list`` in ``list`` is a pair value,
         returns a ``list`` contain all paired value
@@ -1607,7 +1588,7 @@ class ListExt(list):
 
         # Init loop
         for _ in range(int(set_min(max_loop, min_value=3))):
-            temp: Dict[Any, list] = {}
+            temp: dict[Any, list] = {}
             # Make dict{key: all `item` that contains `key`}
             for item in iter:
                 for x in item:
@@ -1641,10 +1622,10 @@ class ListExt(list):
         ['test', 'test', 'test', 'test']
         """
         try:
-            return ListExt(chain(*self))
+            return self.__class__(chain(*self))
         except Exception:
             temp = list(map(lambda x: x if isinstance(x, list) else [x], self))
-            return ListExt(chain(*temp))
+            return self.__class__(chain(*temp))
 
     def numbering(self, start: int = 0) -> Self:
         """
@@ -1670,10 +1651,10 @@ class ListExt(list):
         [(0, 9), (1, 9), (2, 9)]
         """
         start = int(set_min(start, min_value=0))
-        return ListExt(enumerate(self, start=start))
+        return self.__class__(enumerate(self, start=start))
 
     @staticmethod
-    def _numbering(iterable: list, start: int = 0) -> List[Tuple[int, Any]]:
+    def _numbering(iterable: list, start: int = 0) -> list[tuple[int, Any]]:
         """
         Static method for ``numbering``
         """
@@ -1717,8 +1698,8 @@ class DictExt(dict):
         try:
             dct: dict = self.copy()
 
-            max_val: Union[int, float] = max(list(dct.values()))
-            min_val: Union[int, float] = min(list(dct.values()))
+            max_val: int | float = max(list(dct.values()))
+            min_val: int | float = min(list(dct.values()))
             max_list = []
             min_list = []
 
@@ -1798,8 +1779,8 @@ class DictExt(dict):
     @versionadded(version="3.4.0")
     def aggregate(
         self,
-        other_dict: Dict[Any, Union[int, float]],
-        default_value: Union[int, float] = 0,
+        other_dict: dict[Any, int | float],
+        default_value: int | float = 0,
     ) -> Self:
         """Dict with value type int or float"""
         out = {

absfuyu/general/generator.py

@@ -156,7 +156,9 @@ class Generator:
 
         while count < times:
             s = "".join(choice(char_lst) for _ in range(size))
-            logger.debug(f"Time generated: {count+1}. Remaining: {times-count-1}. {s}")
+            logger.debug(
+                f"Time generated: {count + 1}. Remaining: {times - count - 1}. {s}"
+            )
             if not unique:
                 unique_string.append(s)
                 count += 1
@@ -274,7 +276,7 @@ class Generator:
                 if num[i] >= 10:  # type: ignore
                     num[i] -= 9  # type: ignore
             sum += num[i]  # type: ignore
-            logger.debug(f"Loop {i+1}: {num[i]}, {sum}")
+            logger.debug(f"Loop {i + 1}: {num[i]}, {sum}")
 
         out = (10 - (sum % 10)) % 10
         logger.debug(f"Output: {out}")

absfuyu/logger.py

@@ -100,7 +100,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)}]"
 
@@ -123,7 +123,7 @@ def _compress_string_for_print(text: str, max_visible: Optional[int] = 120) -> s
         return str(text)
     else:
         cut_idx = math.floor((max_visible - 3) / 2)
-        temp = f"{text[:cut_idx]}...{text[len(text)-cut_idx:]}"
+        temp = f"{text[:cut_idx]}...{text[len(text) - cut_idx :]}"
         return f"{temp} [Len: {len(text)}]"
 
 

absfuyu/pkg_data/__init__.py

@@ -3,8 +3,8 @@ Absfuyu: Package data
 ---------------------
 Load package data
 
-Version: 2.2.2
-Date updated: 30/11/2023 (dd/mm/yyyy)
+Version: 2.2.3
+Date updated: 14/11/2024 (dd/mm/yyyy)
 """
 
 # Module level
@@ -16,18 +16,8 @@ __all__ = ["PkgData"]
 ###########################################################################
 import zlib
 from ast import literal_eval
-from importlib.resources import read_binary
+from importlib.resources import files, read_binary
 from pathlib import Path
-from sys import version_info as _python_version
-from typing import List, Union
-
-if _python_version.minor >= 10:
-    from importlib.resources import files
-else:
-    try:
-        from importlib_resources import files  # type: ignore
-    except Exception:
-        raise ImportError("Please install importlib-resources")  # noqa: B904
 
 from absfuyu.core import DATA_PATH
 from absfuyu.logger import logger
@@ -61,7 +51,7 @@ class PkgData:
     def __repr__(self) -> str:
         return self.__str__()
 
-    def _make_dat(self, data: str, name: Union[str, Path]):
+    def _make_dat(self, data: str, name: str | Path):
         """
         data: string data
         name: name and location of the data
@@ -90,14 +80,14 @@ class PkgData:
 
         :param new_data: Data to be updated
         """
-        self._make_dat(data=new_data, name=DATA_PATH.joinpath(self.name))
+        self._make_dat(data=new_data, name=DATA_PATH.joinpath(self.name))  # type:ignore
         logger.debug("Data updated")
 
 
 class _ManagePkgData:
     """Manage this package data"""
 
-    def __init__(self, pkg_data_loc: Union[str, Path]) -> None:
+    def __init__(self, pkg_data_loc: str | Path) -> None:
         """
         pkg_data_loc: Package data location
         """
@@ -109,7 +99,7 @@ class _ManagePkgData:
     def __repr__(self) -> str:
         return self.__str__()
 
-    def get_data_list(self, *, pattern: str = "*") -> List[Path]:
+    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]")
@@ -119,7 +109,7 @@ class _ManagePkgData:
         ]
 
     @property
-    def data_list(self) -> List[str]:
+    def data_list(self) -> list[str]:
         """List of available data"""
         return [x.name for x in self.get_data_list()]
 
@@ -135,7 +125,10 @@ class _ManagePkgData:
             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))
+                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:
@@ -147,7 +140,7 @@ class _ManagePkgData:
             x.unlink()
 
 
-PACKAGE_DATA = _ManagePkgData(DATA_PATH)
+PACKAGE_DATA = _ManagePkgData(DATA_PATH)  # type:ignore
 
 
 # Run

absfuyu/tools/checksum.py

@@ -0,0 +1,56 @@
+"""
+Absufyu: Checksum
+-----------------
+Check MD5, SHA256, ...
+
+Version: 1.0.0
+Date updated: 01/02/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+###########################################################################
+__all__ = ["checksum_operation"]
+
+
+# Library
+###########################################################################
+import hashlib
+from pathlib import Path
+from typing import Literal
+
+
+# Function
+###########################################################################
+def checksum_operation(
+    file: Path | str,
+    hash_mode: str | Literal["md5", "sha1", "sha256", "sha512"] = "sha256",
+) -> str:
+    """This performs checksum"""
+    if hash_mode.lower() == "md5":
+        hash_engine = hashlib.md5()
+    elif hash_mode.lower() == "sha1":
+        hash_engine = hashlib.sha1()
+    elif hash_mode.lower() == "sha256":
+        hash_engine = hashlib.sha256()
+    elif hash_mode.lower() == "sha512":
+        hash_engine = hashlib.sha512()
+    else:
+        hash_engine = hashlib.md5()
+
+    with open(Path(file), "rb") as f:
+        # Read and hash the file in 4K chunks. Reading the whole
+        # file at once might consume a lot of memory if it is
+        # large.
+        while True:
+            data = f.read(4096)
+            if len(data) == 0:
+                break
+            else:
+                hash_engine.update(data)
+    return hash_engine.hexdigest()
+
+
+# Run
+###########################################################################
+if __name__ == "__main__":
+    pass