absfuyu 3.3.3__py3-none-any.whl → 4.0.0__py3-none-any.whl

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/data_extension.py

@@ -3,8 +3,8 @@ Absfuyu: Data extension
 -----------------------
 Extension for data type such as ``list``, ``str``, ``dict``, ...
 
-Version: 1.14.3
-Date updated: 05/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
-else:
-    from typing_extensions import NotRequired  # 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:
+        custom_var_name: str | None = None,
+    ) -> list[str]:
         """
         Divide long string into smaller size,
         then assign a random variable to splited
@@ -277,7 +261,7 @@ class Text(str):
 
         Returns
         -------
-        list
+        list[str]
             A list in which each item is a smaller
             string with the size of ``split_size``
             and a way to concaternate them (when using ``print()``)
@@ -398,7 +382,7 @@ class Text(str):
 
         return detail
 
-    def reverse(self) -> "Text":
+    def reverse(self) -> Self:
         """
         Reverse the string
 
@@ -489,7 +473,7 @@ class Text(str):
         else:
             return hex_str
 
-    def random_capslock(self, probability: int = 50) -> "Text":
+    def random_capslock(self, probability: int = 50) -> Self:
         """
         Randomly capslock letter in string
 
@@ -522,7 +506,7 @@ class Text(str):
         logger.debug(temp)
         return self.__class__("".join(temp))
 
-    def reverse_capslock(self) -> "Text":
+    def reverse_capslock(self) -> Self:
         """
         Reverse capslock in string
 
@@ -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,
@@ -934,7 +918,7 @@ class IntNumber(int):
         except Exception:
             return False
 
-    def reverse(self) -> "IntNumber":
+    def reverse(self) -> Self:
         """
         Reverse a number. Reverse ``abs(number)`` if ``number < 0``
 
@@ -982,8 +966,8 @@ class IntNumber(int):
         return self.is_palindromic() and self.is_prime()
 
     # calculation stuff
-    @versionchanged(version="3.3.0", reason="Fix bug")
-    def lcm(self, with_number: int) -> "IntNumber":
+    @versionchanged(version="4.0.0", reason="Update")
+    def lcm(self, with_number: int) -> Self:
         """
         Least common multiple of ``self`` and ``with_number``
 
@@ -1004,13 +988,10 @@ 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) -> "IntNumber":
+    def gcd(self, with_number: int) -> Self:
         """
         Greatest common divisor of ``self`` and ``with_number``
 
@@ -1033,7 +1014,7 @@ class IntNumber(int):
         """
         return self.__class__(math.gcd(self, with_number))
 
-    def add_to_one_digit(self, master_number: bool = False) -> "IntNumber":
+    def add_to_one_digit(self, master_number: bool = False) -> Self:
         """
         Convert ``self`` into 1-digit number
         by adding all of the digits together
@@ -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
 
@@ -1220,7 +1201,7 @@ class ListExt(list):
     ``list`` extension
     """
 
-    def stringify(self) -> "ListExt":
+    def stringify(self) -> Self:
         """
         Convert all item in ``list`` into string
 
@@ -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:
         """
@@ -1278,7 +1259,7 @@ class ListExt(list):
         )
         return self[::-1][:number_of_items][::-1]
 
-    def sorts(self, reverse: bool = False) -> "ListExt":
+    def sorts(self, reverse: bool = False) -> Self:
         """
         Sort all items (with different type) in ``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.
 
@@ -1458,7 +1439,7 @@ class ListExt(list):
         """
         return [self.pick_one() for _ in range(number_of_items)]
 
-    def len_items(self) -> "ListExt":
+    def len_items(self) -> Self:
         """
         ``len()`` for every item in ``list[str]``
 
@@ -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
@@ -1499,7 +1480,7 @@ class ListExt(list):
         logger.debug(out)
         return out
 
-    def apply(self, func: Callable) -> "ListExt":
+    def apply(self, func: Callable) -> Self:
         """
         Apply function to each entry
 
@@ -1523,7 +1504,7 @@ class ListExt(list):
         # return __class__(func(x) for x in self)
         return self.__class__(map(func, self))
 
-    def unique(self) -> "ListExt":
+    def unique(self) -> Self:
         """
         Remove duplicates
 
@@ -1541,7 +1522,7 @@ class ListExt(list):
         """
         return self.__class__(set(self))
 
-    def group_by_unique(self) -> "ListExt":
+    def group_by_unique(self) -> Self:
         """
         Group duplicated elements into list
 
@@ -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:
@@ -1624,7 +1605,7 @@ class ListExt(list):
 
         return list(x for x, _ in groupby(iter))
 
-    def flatten(self) -> "ListExt":
+    def flatten(self) -> Self:
         """
         Flatten the list
 
@@ -1641,12 +1622,12 @@ 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) -> "ListExt":
+    def numbering(self, start: int = 0) -> Self:
         """
         Number the item in list
         (``enumerate`` wrapper)
@@ -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 = []
 
@@ -1744,7 +1725,7 @@ class DictExt(dict):
             logger.error(err_msg)
             raise ValueError(err_msg)  # noqa: B904
 
-    def swap_items(self) -> "DictExt":
+    def swap_items(self) -> Self:
         """
         Swap ``dict.keys()`` with ``dict.values()``
 
@@ -1762,7 +1743,7 @@ class DictExt(dict):
         """
         return self.__class__(zip(self.values(), self.keys()))
 
-    def apply(self, func: Callable, apply_to_value: bool = True) -> "DictExt":
+    def apply(self, func: Callable, apply_to_value: bool = True) -> Self:
         """
         Apply function to ``DictExt.keys()`` or ``DictExt.values()``
 
@@ -1795,6 +1776,19 @@ class DictExt(dict):
             v = self.values()  # type: ignore
         return self.__class__(zip(k, v))
 
+    @versionadded(version="3.4.0")
+    def aggregate(
+        self,
+        other_dict: dict[Any, int | float],
+        default_value: int | float = 0,
+    ) -> Self:
+        """Dict with value type int or float"""
+        out = {
+            k: self.get(k, default_value) + other_dict.get(k, default_value)
+            for k in set(self | other_dict)
+        }
+        return self.__class__(out)
+
 
 # Run
 ###########################################################################

absfuyu/general/human.py

@@ -3,8 +3,8 @@ Absfuyu: Human
 --------------
 Human related stuff
 
-Version: 1.3.1
-Date updated: 05/04/2024 (dd/mm/yyyy)
+Version: 1.4.0
+Date updated: 15/08/2024 (dd/mm/yyyy)
 """
 
 # Module level
@@ -14,13 +14,16 @@ __all__ = ["Human", "Person"]
 
 # Library
 ###########################################################################
+import re
 from datetime import datetime, time
 from typing import Optional, Union
+from urllib.parse import urlencode
 
 from dateutil.relativedelta import relativedelta
 
 from absfuyu.fun import zodiac_sign
 from absfuyu.general.data_extension import IntNumber
+from absfuyu.tools.web import soup_link
 from absfuyu.version import Version  # type: ignore
 
 
@@ -349,7 +352,78 @@ class Person(Human):
         return IntNumber(temp).add_to_one_digit(master_number=True)
 
 
+class Human2:
+    """W.I.P for cli"""
+
+    def __init__(self, birthday_string: str, is_male: bool = True) -> None:
+        """
+        :param birthday_string: Format ``<yyyymmddhhmm>`` or ``<yyyymmdd>``
+        """
+        if len(birthday_string) == 12:
+            day = datetime(
+                year=int(birthday_string[:4]),
+                month=int(birthday_string[4:6]),
+                day=int(birthday_string[6:8]),
+                hour=int(birthday_string[8:10]),
+                minute=int(birthday_string[10:]),
+            )
+        else:
+            day = datetime(
+                year=int(birthday_string[:4]),
+                month=int(birthday_string[4:6]),
+                day=int(birthday_string[6:]),
+            )
+        self._date_str = birthday_string[:8]
+        self.day = day
+        self.is_male = is_male
+
+    def __str__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}({str(self.day)})"
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}({str(self.day)})"
+
+    def numerology(self) -> int:
+        # numerology
+        return IntNumber(self._date_str).add_to_one_digit(master_number=True)
+
+    def _make_fengshui_check_query(self) -> str:
+        """
+        Generate query to check Feng-shui
+        """
+        params = {
+            "ngay": self.day.day.__str__().rjust(2, "0"),
+            "thang": self.day.month.__str__().rjust(2, "0"),
+            "nam": self.day.year,
+            "gio": self.day.hour.__str__().rjust(2, "0"),
+            "phut": self.day.minute.__str__().rjust(2, "0"),
+            "gioitinh": "nam" if self.is_male else "nu",
+        }
+        output = urlencode(params)
+        return output
+
+    def fs(self, number_string: str) -> float:
+        # fengshui
+        base = "https://thanglongdaoquan.vn/boi-so-tai-khoan/?taikhoan="
+        link = f"{base}{number_string}&{self._make_fengshui_check_query()}"
+        soup = soup_link(link)
+        val = soup.find_all(class_="total_point")[0].get_text()
+        pattern = r"([0-9.]{1,3})/10"
+        res = re.findall(pattern, val)[0]
+        return float(res)
+
+    def info(self) -> dict:
+        out = {
+            "numerology": self.numerology(),
+            "zodiac": zodiac_sign(self.day.day, self.day.month),
+        }
+        return out
+
+
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    print(Person.JohnDoe().__dict__)
+    # print(Person.JohnDoe().__dict__)
+    pass

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