absfuyu 2.8.1__py3-none-any.whl → 3.1.0__py3-none-any.whl

absfuyu/{collections → general}/generator.py

@@ -3,14 +3,15 @@ Absfuyu: Generator
 ------------------
 This generate stuff (Not python's ``generator``)
 
-Version: 1.0.4
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 1.1.0
+Date updated: 06/03/2024 (dd/mm/yyyy)
 
 Features:
 ---------
 - Generate random string
 - Generate key
 - Generate check digit
+- Generate combinations of list in range
 """
 
 
@@ -24,10 +25,21 @@ __all__ = [
 
 # Library
 ###########################################################################
+from itertools import chain, combinations
 from random import choice
 import string
+# from string import (
+#     ascii_letters as _ascii_letters,
+#     ascii_uppercase as _ascii_uppercase,
+#     ascii_lowercase as _ascii_lowercase,
+#     digits as _digits,
+#     printable as _printable,
+#     punctuation as _punctuation,
+# )
+from typing import List
 
 from absfuyu.logger import logger
+from absfuyu.util import set_max, set_min_max
 
 
 # Class
@@ -45,10 +57,19 @@ class Charset:
     SPECIAL = string.punctuation
     ALL = string.printable
     PRODUCT_KEY = "BCDFGHJKMNPQRTVWXY2346789" # Charset that various key makers use
+    # DEFAULT = _ascii_letters + _digits
+    # ALPHABET = _ascii_letters
+    # FULL = _ascii_letters + _digits + _punctuation
+    # UPPERCASE = _ascii_uppercase
+    # LOWERCASE = _ascii_lowercase
+    # DIGIT = _digits
+    # SPECIAL = _punctuation
+    # ALL = _printable
 
     def __str__(self) -> str:
         charset = [x for x in __class__.__dict__.keys() if not x.startswith("__")]
-        return f"List of Charset: {charset}"
+        return f"List of Character set: {charset}"
+
     def __repr__(self) -> str:
         return self.__str__()
 
@@ -258,8 +279,48 @@ class Generator:
         logger.debug(f"Output: {out}")
         return out
 
+    @staticmethod
+    def combinations_range(sequence: list, *, min_len: int = 1, max_len: int = 0) -> List[tuple]:
+        """
+        Generate all combinations of a ``sequence`` from ``min_len`` to ``max_len``
+
+        Parameters
+        ----------
+        sequence : list
+            A sequence that need to generate combination
+
+        min_len : int
+            Minimum ``r`` of ``combinations``
+            (Default: ``1``)
+
+        max_len : int
+            Maximum ``r`` of ``combinations``
+            (Default: ``0`` - len of ``sequence``)
+
+        Returns
+        -------
+        list[tuple]
+            A list of all combinations from range(``min_len``, ``max_len``) of ``sequence``
+        """
+        # Restrain
+        if max_len < 1:
+            max_len = len(sequence)
+        max_len = set_max(max_len, max_value=len(sequence))
+        min_len = set_min_max(min_len, min_value=1, max_value=max_len)
+        logger.debug(f"Combination range: [{min_len}, {max_len}]")
+
+        # Return
+        return list(
+            chain.from_iterable(
+                [
+                    list(combinations(sequence, i))
+                    for i in range(min_len, max_len + 1)
+                ]
+            )
+        )
+
 
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    logger.setLevel(10) # DEBUG
+    logger.setLevel(10) # DEBUG

absfuyu/{collections → general}/human.py

@@ -3,8 +3,8 @@ Absfuyu: Human
 --------------
 Human related stuff
 
-Version: 1.2.3
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 1.3.0
+Date updated: 08/12/2023 (dd/mm/yyyy)
 """
 
 
@@ -22,12 +22,37 @@ from typing import Optional, Union
 
 from dateutil.relativedelta import relativedelta
 
-from absfuyu.collections.data_extension import IntNumber
+from absfuyu.general.data_extension import IntNumber
 from absfuyu.fun import zodiac_sign
 # from absfuyu.util import set_min_max
 from absfuyu.version import Version
 
 
+# Sub-Class
+###########################################################################
+class _FloatBase:
+    """To show some unit"""
+
+    def __init__(self, value: float) -> None:
+        self.value = value
+
+    def __str__(self) -> str:
+        return self.value.__str__()
+
+    def to_float(self) -> float:
+        return float(self.value)
+
+
+class _Height(_FloatBase):
+    def __repr__(self) -> str:
+        return f"{self.value:.2f} cm"
+
+
+class _Weight(_FloatBase):
+    def __repr__(self) -> str:
+        return f"{self.value:.2f} kg"
+
+
 # Class
 ###########################################################################
 class BloodType:

absfuyu/pkg_data/__init__.py

@@ -3,8 +3,8 @@ Absfuyu: Package data
 ---------------------
 Load package data
 
-Version: 2.2.1
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 2.2.2
+Date updated: 30/11/2023 (dd/mm/yyyy)
 """
 
 
@@ -22,42 +22,20 @@ from importlib.resources import read_binary
 from pathlib import Path
 from typing import List, Union
 import zlib
+import sys
+
+if sys.version_info.minor >= 10:
+    from importlib.resources import files
+else:
+    try:
+        from importlib_resources import files
+    except:
+        raise ImportError("Please install importlib-resources")
 
 from absfuyu.core import DATA_PATH
 from absfuyu.logger import logger
 
 
-# Legacy - depreciated
-###########################################################################
-def __data_validate(data_name: str) -> bool:
-    """Validate if data exist"""
-    DATA_LIST = [
-        "dummy", "punishment_windows",
-    ]
-    if data_name not in DATA_LIST:
-        return False
-    else:
-        return True
-
-def __load_data_string(data_name: str):
-    """Load data and convert into string"""
-    data = read_binary("absfuyu.pkg_data", f"{data_name}.dat")
-    decompressed_data = zlib.decompress(data).decode()
-    return decompressed_data
-
-def __data_string_to_list(data_string: str):
-    """Convert data to list"""
-    data = literal_eval(data_string)
-    return data
-
-def loadData(data_name: str):
-    """Load data"""
-    if __data_validate(data_name):
-        return __data_string_to_list(__load_data_string(data_name))
-    else:
-        return None
-
-
 # External Data
 ###########################################################################
 _EXTERNAL_DATA = {
@@ -70,9 +48,9 @@ _EXTERNAL_DATA = {
 
 # Class
 ###########################################################################
-# class DataList:
-#     DUMMY = None
-#     PWIN = None
+class DataList:
+    CHEMISTRY = files("absfuyu.pkg_data").joinpath("chemistry.pkl")
+    TAROT = files("absfuyu.pkg_data").joinpath("tarot.pkl")
 
 
 class PkgData:

absfuyu/tools/converter.py

@@ -3,42 +3,58 @@ Absufyu: Converter
 ------------------
 Convert stuff
 
-Version: 1.1.1
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 1.2.1
+Date updated: 30/11/2023 (dd/mm/yyyy)
 
 Feature:
 --------
 - Text2Chemistry
 - Str2Pixel
+- Base64EncodeDecode
 """
 
 
 # Module level
 ###########################################################################
 __all__ = [
-    "Text2Chemistry", "Str2Pixel"
+    "Text2Chemistry", "Str2Pixel", "Base64EncodeDecode"
 ]
 
 
 # Library
 ###########################################################################
+import base64
 from itertools import combinations, chain
 import math
 import re
 import string
-from typing import List, Union
+from typing import Dict, List, Union
 
-from absfuyu.core import DATA_PATH, CLITextColor
+from absfuyu.core import CLITextColor
 from absfuyu.logger import logger
-from absfuyu.pkg_data import _EXTERNAL_DATA
+from absfuyu.pkg_data import DataList
 from absfuyu.util import set_min
-from absfuyu.util.api import APIRequest
+from absfuyu.util.pkl import Pickler
 
 
 # Class
 ###########################################################################
+class Base64EncodeDecode:
+    """
+    Encode and decode base64
+    """
+    @staticmethod
+    def encode(data: str) -> str:
+        return base64.b64encode(data.encode()).decode()
+
+    @staticmethod
+    def decode(data: str) -> str:
+        return base64.b64decode(data).decode()
+
+
 class ChemistryElement:
     """Chemistry Element"""
+    _VERSION = (1, 1, 0)
     def __init__(
             self,
             name: str,
@@ -61,39 +77,50 @@ class ChemistryElement:
     def __repr__(self) -> str:
         # return self.symbol
         return f"{self.__class__.__name__}({self.symbol})"
+    
+    def to_dict(self) -> Dict[str, Union[str, int, float]]:
+        """
+        Output content to dict
+        
+        :rtype: dict[str, str | int | float]
+        """
+        return {
+            "name": self.name,
+            "number": self.number,
+            "symbol": self.symbol,
+            "atomic_mass": self.atomic_mass
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Union[str, int, float]]) -> "ChemistryElement":
+        """
+        Convert from ``dict`` data
+        
+        :param data: Dict data
+        :type data: dict[str, str | int | float]
+        :rtype: ChemistryElement
+        """
+        return cls(
+                name=data["name"],
+                number=int(data["number"]),
+                symbol=data["symbol"],
+                atomic_mass=float(data["atomic_mass"])
+        )
 
 class Text2Chemistry:
     def __init__(self) -> None:
-        self.data = APIRequest(
-            _EXTERNAL_DATA.get("chemistry.json"),
-            encoding="utf-8"
-        )
-        self.data_location = DATA_PATH.joinpath("chemistry.json")
+        self.data_location = DataList.CHEMISTRY
     def __str__(self) -> str:
         return f"{self.__class__.__name__}()"
     def __repr__(self) -> str:
         return self.__str__()
     
-    def _load_chemistry_data(self, update: bool = False) -> List[ChemistryElement]:
+    def _load_chemistry_data(self) -> List[ChemistryElement]:
         """
-        Load chemistry json data from API
-
-        update: Refresh the cache (Default: ``False``)
+        Load chemistry pickle data
         """
-        json_data = self.data.fetch_data(
-            update=update,
-            json_cache=self.data_location
-        )
-        elements = json_data["elements"]
-        logger.debug(f"{len(elements)} elements loaded")
-        return [
-            ChemistryElement(
-                name=element["name"],
-                number=int(element["number"]),
-                symbol=element["symbol"],
-                atomic_mass=float(element["atomic_mass"])
-            ) for element in elements
-        ]
+        data: List[dict] = Pickler.load(self.data_location)
+        return [ChemistryElement.from_dict(x) for x in data]
         
     @property
     def unvailable_characters(self):
@@ -261,4 +288,4 @@ class Str2Pixel:
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    logger.setLevel(10)
+    logger.setLevel(10)

absfuyu/tools/obfuscator.py

@@ -3,8 +3,8 @@ Absfuyu: Obfuscator
 -------------------
 Obfuscate code
 
-Version: 2.0.2
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 2.0.1
+Date updated: 26/11/2023 (dd/mm/yyyy)
 """
 
 
@@ -23,8 +23,8 @@ import random
 import zlib
 
 from absfuyu.logger import logger
-from absfuyu.collections.generator import Generator as gen, Charset
-from absfuyu.collections.data_extension import Text
+from absfuyu.general.generator import Generator as gen, Charset
+from absfuyu.general.data_extension import Text
 
 
 # Class

absfuyu/tools/stats.py

@@ -3,8 +3,8 @@ Absfuyu: Stats
 --------------
 List's stats
 
-Version: 2.0.1
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 2.0.3
+Date updated: 26/11/2023 (dd/mm/yyyy)
 """
 
 
@@ -20,7 +20,7 @@ __all__ = [
 import math
 from typing import List, Union
 
-from absfuyu.collections.data_extension import ListKai
+from absfuyu.general.data_extension import ListExt
 from absfuyu.logger import logger
 
 
@@ -92,7 +92,7 @@ class ListStats(List[Union[int, float]]):
         [1]
         """
         lst = self
-        frequency = ListKai(lst).freq()
+        frequency = ListExt(lst).freq()
         
         max_val = max(frequency.values())
         keys = []

absfuyu/tools/web.py

@@ -45,7 +45,7 @@ def soup_link(link: str) -> BeautifulSoup:
 def gen_random_commit_msg() -> str:
     """
     Generate random commit message
-    
+
     :returns: Random commit message
     :rtype: str
     """
@@ -58,4 +58,4 @@ def gen_random_commit_msg() -> str:
 ###########################################################################
 if __name__ == "__main__":
     logger.setLevel(10)
-    gen_random_commit_msg()
+    gen_random_commit_msg()