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

absfuyu/sort.py

@@ -1,32 +1,39 @@
-# -*- coding: utf-8 -*-
+# type: ignore
 """
 Absfuyu: Sort
 -------------
 Sort Module
 
-Version: 1.2.3
-Date updated: 23/11/2023 (mm/dd/yyyy)
+Version: 1.2.4
+Date updated: 20/03/2024 (mm/dd/yyyy)
 """
 
-
 # Module level
 ###########################################################################
 __all__ = [
     # Sort
-    "selection_sort","insertion_sort",
+    "selection_sort",
+    "insertion_sort",
     # Alphabet
-    "alphabetAppear", "AlphabetAppearResult",
+    "alphabetAppear",
+    "AlphabetAppearResult",
     # Search
-    "linear_search", "binary_search"
+    "linear_search",
+    "binary_search",
 ]
 
 
 # Library
 ###########################################################################
-from collections import Counter, namedtuple
-from itertools import accumulate
 import operator
-from typing import Any, Dict, List, Union
+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
 
@@ -36,12 +43,12 @@ from absfuyu.logger import logger
 def selection_sort(iterable: list, reverse: bool = False) -> list:
     """
     Sort the list with selection sort (bubble sort) algorithm
- 
+
     Parameters
     ----------
     iterable : list
         List that want to be sorted
-    
+
     reverse : bool
         | if ``True``: sort in descending order
         | if ``False``: sort in ascending order
@@ -53,65 +60,67 @@ def selection_sort(iterable: list, reverse: bool = False) -> list:
         sorted list
     """
 
-    if reverse: # descending order
+    if reverse:  # descending order
         for i in range(len(iterable)):
-            for j in range(i+1, len(iterable)):
+            for j in range(i + 1, len(iterable)):
                 if iterable[i] < iterable[j]:
                     iterable[i], iterable[j] = iterable[j], iterable[i]
         return iterable
-        
-    else: # ascending order
+
+    else:  # ascending order
         for i in range(len(iterable)):
-            for j in range(i+1, len(iterable)):
+            for j in range(i + 1, len(iterable)):
                 if iterable[i] > iterable[j]:
                     iterable[i], iterable[j] = iterable[j], iterable[i]
         return iterable
 
+
 def insertion_sort(iterable: list) -> list:
     """
     Sort the list with insertion sort algorithm
- 
+
     Parameters
     ----------
     iterable : list
         List that want to be sorted
-    
+
     Returns
     -------
     list
         sorted list (ascending order)
     """
 
-    for i in range (1, len(iterable)):
+    for i in range(1, len(iterable)):
         key = iterable[i]
-        j = i-1
-        while j>=0 and key < iterable[j]:
-            iterable[j+1] = iterable[j]
+        j = i - 1
+        while j >= 0 and key < iterable[j]:
+            iterable[j + 1] = iterable[j]
             j -= 1
-        iterable[j+1] = key
+        iterable[j + 1] = key
     return iterable
 
 
-def alphabetAppear_old(lst: List[str],
-    ) -> List[Union[Dict[str, int],List[int]]]:
+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
@@ -126,7 +135,7 @@ def alphabetAppear_old(lst: List[str],
             times_appear[x] += 1
         else:
             times_appear[x] = 1
-    
+
     times_appear_increment = []
     total = 0
     for x in times_appear.values():
@@ -137,36 +146,40 @@ def alphabetAppear_old(lst: List[str],
     # second item is incremental index list
     return [times_appear, times_appear_increment]
 
-AlphabetAppearResult = namedtuple("AlphabetAppearResult", ["times_appear", "times_appear_increment"])
 
-def alphabetAppear(
-        iterable: list,
-        num_of_char_sorted: int = 1
-    ) -> AlphabetAppearResult:
+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
-    
-    For example:
 
-    >>> ["apple","bee","book"]
-    freq = {"a": 1, "b": 2}
- 
     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):
@@ -181,9 +194,9 @@ def alphabetAppear(
     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(temp)
+    times_appear_increment: List[int] = list(temp)
     logger.debug(times_appear_increment)
 
     # first item is character frequency
@@ -199,7 +212,7 @@ def linear_search(iterable: list, key: Any) -> int:
     ----------
     iterable : list
         List want to search
-    
+
     key: Any
         Item want to find
 
@@ -213,6 +226,7 @@ def linear_search(iterable: list, key: Any) -> int:
             return i
     return -1
 
+
 def binary_search(iterable: list, key: Any) -> int:
     """
     Returns the position of ``key`` in the list (list must be sorted)
@@ -221,7 +235,7 @@ def binary_search(iterable: list, key: Any) -> int:
     ----------
     iterable : list
         List want to search
-    
+
     key: Any
         Item want to find
 
@@ -234,7 +248,7 @@ def binary_search(iterable: list, key: Any) -> int:
     right = len(iterable) - 1
     while left <= right:
         middle = (left + right) // 2
-        
+
         if iterable[middle] == key:
             return middle
         if iterable[middle] > key:

absfuyu/tools/__init__.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """
 Absfuyu: Tools
 --------------

absfuyu/tools/converter.py

@@ -3,8 +3,8 @@ Absufyu: Converter
 ------------------
 Convert stuff
 
-Version: 1.2.1
-Date updated: 30/11/2023 (dd/mm/yyyy)
+Version: 1.2.2
+Date updated: 05/04/2024 (dd/mm/yyyy)
 
 Feature:
 --------
@@ -13,21 +13,18 @@ Feature:
 - Base64EncodeDecode
 """
 
-
 # Module level
 ###########################################################################
-__all__ = [
-    "Text2Chemistry", "Str2Pixel", "Base64EncodeDecode"
-]
+__all__ = ["Text2Chemistry", "Str2Pixel", "Base64EncodeDecode"]
 
 
 # Library
 ###########################################################################
 import base64
-from itertools import combinations, chain
 import math
 import re
 import string
+from itertools import chain, combinations
 from typing import Dict, List, Union
 
 from absfuyu.core import CLITextColor
@@ -43,6 +40,7 @@ class Base64EncodeDecode:
     """
     Encode and decode base64
     """
+
     @staticmethod
     def encode(data: str) -> str:
         return base64.b64encode(data.encode()).decode()
@@ -54,14 +52,10 @@ class Base64EncodeDecode:
 
 class ChemistryElement:
     """Chemistry Element"""
+
     _VERSION = (1, 1, 0)
-    def __init__(
-            self,
-            name: str,
-            number: int,
-            symbol: str,
-            atomic_mass: float
-        ) -> None:
+
+    def __init__(self, name: str, number: int, symbol: str, atomic_mass: float) -> None:
         """
         name: element name
         number: order in periodic table
@@ -72,69 +66,76 @@ class ChemistryElement:
         self.number = number
         self.symbol = symbol
         self.atomic_mass = atomic_mass
+
     def __str__(self) -> str:
         return self.symbol
+
     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
+            "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"])
+            name=data["name"],  # type: ignore
+            number=int(data["number"]),
+            symbol=data["symbol"],  # type: ignore
+            atomic_mass=float(data["atomic_mass"]),
         )
 
+
 class Text2Chemistry:
     def __init__(self) -> None:
         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) -> List[ChemistryElement]:
         """
         Load chemistry pickle data
         """
-        data: List[dict] = Pickler.load(self.data_location)
+        data: List[dict] = Pickler.load(self.data_location)  # type: ignore
         return [ChemistryElement.from_dict(x) for x in data]
-        
+
     @property
     def unvailable_characters(self):
         """
         Characters that can not be converted (unvailable chemistry symbol)
-        
+
         :rtype: set[str]
         """
         base = set(string.ascii_lowercase)
-        available = set("".join(map(lambda x: x.symbol.lower(), self._load_chemistry_data())))
+        available = set(
+            "".join(map(lambda x: x.symbol.lower(), self._load_chemistry_data()))
+        )
         # logger.debug(base)
         # logger.debug(available)
         return base.difference(available)
-    
+
     def convert(self, text: str) -> List[List[ChemistryElement]]:
         """
         Convert text to chemistry symbol
@@ -151,27 +152,33 @@ class Text2Chemistry:
             raise ValueError("Convert Failed. Word Only!")
         for x in self.unvailable_characters:
             if text.find(x) != -1:
-                logger.debug(f"{text} contains unvailable characters: {self.unvailable_characters}")
+                logger.debug(
+                    f"{text} contains unvailable characters: {self.unvailable_characters}"
+                )
                 # raise ValueError(f"Text contains {self.unvailable_character}")
                 return []
-        
+
         # Setup
         text_lower = text.lower()
         data = self._load_chemistry_data()
-        
+
         # List possible elements
         possible_elements: List[ChemistryElement] = []
         for i, letter in enumerate(text_lower):
             for element in data:
-                if element.symbol.lower().startswith(letter): # Check for `element.symbol` starts with `letter`
+                if element.symbol.lower().startswith(
+                    letter
+                ):  # Check for `element.symbol` starts with `letter`
                     # logger.debug(f"{letter} {element}")
-                    if element.symbol.lower().startswith(text_lower[i:i+len(element.symbol)]): # Check for `element.symbol` with len > 1 starts with `letter` of len(element.symbol)
+                    if element.symbol.lower().startswith(
+                        text_lower[i : i + len(element.symbol)]
+                    ):  # Check for `element.symbol` with len > 1 starts with `letter` of len(element.symbol)
                         possible_elements.append(element)
                     # Break when reach last letter in text
                     if letter == text_lower[-1]:
                         break
         logger.debug(possible_elements)
-        if len(possible_elements) < 1: # No possible elements
+        if len(possible_elements) < 1:  # No possible elements
             return []
 
         # temp = []
@@ -179,12 +186,19 @@ class Text2Chemistry:
         #     comb = combinations(possible_elements, i)
         #     temp.append(comb)
         # possible_combinations = chain(*temp)
-        max_symbol_len = max(map(lambda x: len(x.symbol), possible_elements)) # Max len of `element.symbol`
+        max_symbol_len = max(
+            map(lambda x: len(x.symbol), possible_elements)
+        )  # Max len of `element.symbol`
         min_combination_range = math.ceil(len(text_lower) / max_symbol_len)
         logger.debug(f"Combination range: [{min_combination_range}, {len(text_lower)}]")
-        possible_combinations = chain(*(combinations(possible_elements, i) for i in range(min_combination_range, len(text_lower)+1)))
+        possible_combinations = chain(
+            *(
+                combinations(possible_elements, i)
+                for i in range(min_combination_range, len(text_lower) + 1)
+            )
+        )
         # logger.debug(list(possible_combinations))
-        
+
         output = []
         for comb in possible_combinations:
             merged = "".join(map(lambda x: x.symbol, comb))
@@ -197,14 +211,16 @@ class Text2Chemistry:
 
 class Str2Pixel:
     """Convert str into pixel"""
-    PIXEL = u"\u2588"
+
+    PIXEL = "\u2588"
+
     def __init__(
-            self,
-            str_data: str,
-            *,
-            pixel_size: int = 2,
-            pixel_symbol_overwrite: Union[str, None] = None
-        ) -> None:
+        self,
+        str_data: str,
+        *,
+        pixel_size: int = 2,
+        pixel_symbol_overwrite: Union[str, None] = None,
+    ) -> None:
         """
         str_data: Pixel string data (Format: <number_of_pixel><color_code>)
         pixel_size: Pixel size (Default: 2)
@@ -214,27 +230,29 @@ class Str2Pixel:
         """
         self.data = str_data
         if pixel_symbol_overwrite is None:
-            self.pixel = self.PIXEL * set_min(pixel_size, min_value=1)
+            self.pixel = self.PIXEL * int(set_min(pixel_size, min_value=1))
         else:
             self.pixel = pixel_symbol_overwrite
+
     def __str__(self) -> str:
         return f"{self.__class__.__name__}(pixel={self.pixel})"
+
     def __repr__(self) -> str:
         return self.__str__()
-    
+
     def _extract_pixel(self):
         """Split str_data into corresponding int and str"""
-        num = re.split("[a-zA-Z]", self.data)
-        num = filter(lambda x: x != "", num) # Clean "" in list
-        num = list(map(int, num))
+        num = re.split("[a-zA-Z]", self.data)  # type: ignore
+        num = filter(lambda x: x != "", num)  # type: ignore # Clean "" in list
+        num = list(map(int, num))  # type: ignore
         char = re.split("[0-9]", self.data)
-        char = filter(lambda x: x != "", char)
+        char = filter(lambda x: x != "", char)  # type: ignore
         return [x for y in zip(num, char) for x in y]
 
     def convert(self, line_break: bool = True) -> str:
         """
         Convert data into pixel
-        
+
         :param line_break: add ``\\n`` at the end of line (Default: ``False``)
         :type line_break: bool
         :returns: Converted colored pixels
@@ -246,16 +264,16 @@ class Str2Pixel:
         # Translation to color
         translate = {
             "w": CLITextColor.WHITE,
-            "b": CLITextColor.BLACK, 
-            "B": CLITextColor.BLUE, 
-            "g": CLITextColor.GRAY, 
-            "G": CLITextColor.GREEN, 
-            "r": CLITextColor.RED, 
-            "R": CLITextColor.DARK_RED, 
-            "m": CLITextColor.MAGENTA, 
-            "y": CLITextColor.YELLOW, 
+            "b": CLITextColor.BLACK,
+            "B": CLITextColor.BLUE,
+            "g": CLITextColor.GRAY,
+            "G": CLITextColor.GREEN,
+            "r": CLITextColor.RED,
+            "R": CLITextColor.DARK_RED,
+            "m": CLITextColor.MAGENTA,
+            "y": CLITextColor.YELLOW,
             "E": CLITextColor.RESET,
-            "N": "\n" # New line
+            "N": "\n",  # New line
         }
 
         # import colorama
@@ -277,7 +295,7 @@ class Str2Pixel:
         out = ""
         for i, x in enumerate(pixel_map):
             if isinstance(x, str):
-                temp = self.pixel * pixel_map[i-1]
+                temp = self.pixel * pixel_map[i - 1]
                 out += f"{translate[x]}{temp}{translate['E']}"
         if line_break:
             return out + "\n"