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

absfuyu/fun/tarot.py

@@ -4,8 +4,8 @@ Absfuyu: Tarot
 Tarot stuff
 
 
-Version: 1.0.2
-Date updated: 27/11/2023 (dd/mm/yyyy)
+Version: 1.0.3
+Date updated: 01/01/2024 (dd/mm/yyyy)
 
 Usage:
 ------
@@ -23,8 +23,8 @@ __all__ = ["Tarot", "TarotCard"]
 import random
 from typing import Dict, List
 
-from absfuyu.core import DATA_PATH
 from absfuyu.logger import logger
+from absfuyu.pkg_data import DataList
 from absfuyu.util.pkl import Pickler
 
 
@@ -60,7 +60,7 @@ class Tarot:
     """Tarot data"""
 
     def __init__(self) -> None:
-        self.data_location = DATA_PATH.joinpath("tarot.pkl")
+        self.data_location = DataList.TAROT
 
     def __str__(self) -> str:
         return f"{self.__class__.__name__}()"
@@ -68,9 +68,10 @@ class Tarot:
     def __repr__(self) -> str:
         return self.__str__()
 
-    def _load(self) -> List[TarotCard]:
+    @property
+    def tarot_deck(self) -> List[TarotCard]:
         """
-        Load tarot pickle data
+        Load pickled tarot data
 
         :rtype: list[TarotCard]
         """
@@ -97,10 +98,11 @@ class Tarot:
         TarotCard
             Random Tarot card
         """
-        return random.choice(self._load())
+        return random.choice(self.tarot_deck)
 
 
 # Run
 ###########################################################################
 if __name__ == "__main__":
+    logger.setLevel(10)
     pass

absfuyu/game/tictactoe2.py

@@ -2,24 +2,22 @@
 Game: Tic Tac Toe
 -----------------
 
-Version: 2.0.1
-Date updated: 22/11/2023 (mm/dd/yyyy)
+Version: 2.0.2
+Date updated: 04/12/2023 (mm/dd/yyyy)
 """
 
 
 # Module level
 ###########################################################################
-__all__ = [
-    "TicTacToe", "GameMode"
-]
+__all__ = ["TicTacToe", "GameMode"]
 
 
 # Library
 ###########################################################################
-from collections import namedtuple
+# from collections import namedtuple
 import random
 import time
-from typing import Dict, List, Union
+from typing import Dict, List, NamedTuple, Union
 
 from absfuyu.core import CLITextColor
 
@@ -27,7 +25,12 @@ from absfuyu.core import CLITextColor
 # Class
 ###########################################################################
 BoardGame = List[List[str]]
-Pos = namedtuple("Pos", ["row", "col"]) # Position
+# Pos = namedtuple("Pos", ["row", "col"])  # Position
+class Pos(NamedTuple):
+    """Position"""
+    row: int
+    col: int
+
 
 class GameMode:
     ONE_V_ONE = "1v1"
@@ -37,18 +40,18 @@ class GameMode:
 
 class TicTacToe:
     """Tic Tac Toe game"""
+
     def __init__(
-            self,
-            game_size: int = 3,
-            *,
-            x: str = "X",
-            o: str = "O",
-            blank: str = " ",
-            position_split_symbol: str = ",",
-            end_break_word: str = "END",
-            welcome_message: bool = True
-
-        ) -> None:
+        self,
+        game_size: int = 3,
+        *,
+        x: str = "X",
+        o: str = "O",
+        blank: str = " ",
+        position_split_symbol: str = ",",
+        end_break_word: str = "END",
+        welcome_message: bool = True,
+    ) -> None:
         """
         :param game_size: Board size (Default: 3x3)
         :param x: X symbol
@@ -76,56 +79,57 @@ class TicTacToe:
 
     def __str__(self) -> str:
         return f"{self.__class__.__name__}(game_size={self.row_size})"
+
     def __repr__(self) -> str:
         return self.__str__()
-    
+
     # Game
     def _gen_board(self) -> BoardGame:
         """
         Generate board game
         """
         board = [
-            [self.BLANK for _ in range(self.row_size)]
-            for _ in range(self.col_size)
+            [self.BLANK for _ in range(self.row_size)] for _ in range(self.col_size)
         ]
         return board
-    
+
     def _check_state(self) -> Dict[str, Union[str, int]]:
         """
         Check game winning state
-        
-        Return:
-        ---
-        X | O | BLANK
+
+        Returns
+        -------
+        dict[str, str | int]
+            ``X`` | ``O`` | ``BLANK``
         """
 
         # Check rows
         for row in range(self.row_size):
             if len(set(self.board[row])) == 1:
                 key = list(set(self.board[row]))[0]
-                return {"key": key, "location": "row", "pos": row} # modified
+                return {"key": key, "location": "row", "pos": row}  # modified
 
         # Check cols
         for col in range(self.col_size):
             temp = [self.board[row][col] for row in range(self.row_size)]
             if len(set(temp)) == 1:
                 key = list(set(temp))[0]
-                return {"key": key, "location": "col", "pos": col} # modified
-        
+                return {"key": key, "location": "col", "pos": col}  # modified
+
         # Check diagonal
         diag1 = [self.board[i][i] for i in range(len(self.board))]
         if len(set(diag1)) == 1:
             key = list(set(diag1))[0]
-            return {"key": key, "location": "diag", "pos": 1} # modified
-        
-        diag2 = [self.board[i][len(self.board)-i-1] for i in range(len(self.board))]
+            return {"key": key, "location": "diag", "pos": 1}  # modified
+
+        diag2 = [self.board[i][len(self.board) - i - 1] for i in range(len(self.board))]
         if len(set(diag2)) == 1:
             key = list(set(diag2))[0]
-            return {"key": key, "location": "diag", "pos": 2} # modified
-        
+            return {"key": key, "location": "diag", "pos": 2}  # modified
+
         # Else
         return {"key": self.BLANK}
-    
+
     @staticmethod
     def _print_board(board: BoardGame) -> None:
         """
@@ -138,7 +142,7 @@ class TicTacToe:
             for col in range(ncol):
                 print(f"| {board[row][col]} ", end="")
             print(f"|\n{'+---'*length}+")
-    
+
     def _win_hightlight(self) -> BoardGame:
         """
         Hight light the win by removing other placed key
@@ -165,44 +169,44 @@ class TicTacToe:
                     board[i][i] = detail["key"]
             else:
                 for i in range(len(board)):
-                    board[i][len(board)-i-1] = detail["key"]
-        
+                    board[i][len(board) - i - 1] = detail["key"]
+
         # Output
         return board
-    
+
     def _is_blank(self, pos: Pos) -> bool:
         """Check if current pos is filled"""
         return self.board[pos.row][pos.col] == self.BLANK
 
     @staticmethod
-    def _convert_bot_output(pos: Pos):
+    def _convert_bot_output(pos: Pos) -> Pos:
         """
         Turn to real pos by:
-        - +1 to row and col
-        - convert into str
+
+        - +1 to ``row`` and ``col``
+        - convert into ``str``
         """
         return Pos(pos.row + 1, pos.col + 1)
-    
-    def _generate_random_move(self):
+
+    def _generate_random_move(self) -> Pos:
         """
         Generate a random move from board game
         """
         while True:
             output = Pos(
-                random.randint(0, len(self.board)-1),
-                random.randint(0, len(self.board)-1)
+                random.randint(0, len(self.board) - 1),
+                random.randint(0, len(self.board) - 1),
             )
             if self._is_blank(output):
                 break
         return self._convert_bot_output(output)
 
-
     def play(
-            self,
-            game_mode: str = GameMode.ONE_V_BOT,
-            *,
-            bot_time: float = 0,
-        ) -> None:
+        self,
+        game_mode: str = GameMode.ONE_V_BOT,
+        *,
+        bot_time: float = 0,
+    ) -> None:
         """
         Play a game of Tic Tac Toe
 
@@ -210,7 +214,7 @@ class TicTacToe:
         ----------
         game_mode : str
             Game mode
-        
+
         bot_time : float
             Time sleep between each bot move (Default: ``0``)
         """
@@ -223,63 +227,71 @@ class TicTacToe:
 
         # Welcome message
         if self.welcome_message:
-            print(f"""\
+            print(
+                f"""\
 {CLITextColor.GREEN}Welcome to Tic Tac Toe!
 
 {CLITextColor.YELLOW}Rules: Match lines vertically, horizontally or diagonally
 {CLITextColor.YELLOW}{self.X} goes first, then {self.O}
-{CLITextColor.RED}Type '{self.END_BREAK}' to end the game{CLITextColor.RESET}""")
-        
+{CLITextColor.RED}Type '{self.END_BREAK}' to end the game{CLITextColor.RESET}"""
+            )
+
         # Check gamemode
         _game_mode = [
-            "1v1", # Player vs player
-            "1v0", # Player vs BOT
-            "0v0" # BOT vs BOT
+            "1v1",  # Player vs player
+            "1v0",  # Player vs BOT
+            "0v0",  # BOT vs BOT
         ]
         if game_mode not in _game_mode:
-            game_mode = _game_mode[1] # Force vs BOT
+            game_mode = _game_mode[1]  # Force vs BOT
         if game_mode.startswith(GameMode.ONE_V_BOT):
             BOT = True
         if game_mode.startswith(GameMode.BOT_V_BOT):
             BOT = True
             BOT2 = True
-        
+
         # Game
         self._print_board(self.board)
 
         place_pos = None
         while state == self.BLANK and filled < self.row_size**2:
             print(f"{CLITextColor.BLUE}{current_player}'s turn:{CLITextColor.RESET}")
-            
-            try: # Error handling
+
+            try:  # Error handling
                 if (BOT and current_player == self.O) or BOT2:
                     move = self._generate_random_move()
                     str_move = f"{move.row}{self.POS_SPLIT}{move.col}"
                     move = str_move
                 else:
-                    move = input(f"Place {CLITextColor.BLUE}{current_player}{CLITextColor.RESET} at {CLITextColor.BLUE}<row{self.POS_SPLIT}col>:{CLITextColor.RESET} ")
+                    move = input(
+                        f"Place {CLITextColor.BLUE}{current_player}{CLITextColor.RESET} at {CLITextColor.BLUE}<row{self.POS_SPLIT}col>:{CLITextColor.RESET} "
+                    )
 
-                if move.upper() == self.END_BREAK: # Failsafe
+                if move.upper() == self.END_BREAK:  # Failsafe
                     print(f"{CLITextColor.RED}Game ended{CLITextColor.RESET}")
                     break
-                
+
                 move = move.split(self.POS_SPLIT)
                 row = int(move[0])
                 col = int(move[1])
-                place_pos = Pos(row-1, col-1)
+                place_pos = Pos(row - 1, col - 1)
 
                 if self._is_blank(place_pos):
                     self.board[place_pos.row][place_pos.col] = current_player
                     filled += 1
-                
-                else: # User and BOT error
-                    print(f"{CLITextColor.RED}Invalid move, please try again{CLITextColor.RESET}")
+
+                else:  # User and BOT error
+                    print(
+                        f"{CLITextColor.RED}Invalid move, please try again{CLITextColor.RESET}"
+                    )
                     continue
-            
-            except: # User error
-                print(f"{CLITextColor.RED}Invalid move, please try again{CLITextColor.RESET}")
+
+            except:  # User error
+                print(
+                    f"{CLITextColor.RED}Invalid move, please try again{CLITextColor.RESET}"
+                )
                 continue
-            
+
             state = self._check_state()["key"]
             self._print_board(self.board)
 
@@ -288,9 +300,9 @@ class TicTacToe:
                 self._print_board(self._win_hightlight())
 
             # Change turn
-            if BOT2: # BOT delay
+            if BOT2:  # BOT delay
                 time.sleep(bot_time)
-            
+
             if current_player == self.X:
                 current_player = self.O
             else:
@@ -303,4 +315,4 @@ class TicTacToe:
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    pass
+    pass

absfuyu/general/data_extension.py

@@ -3,8 +3,8 @@ Absfuyu: Data extension
 -----------------------
 Extension for data type such as ``list``, ``str``, ``dict``, ...
 
-Version: 1.9.0
-Date updated: 01/12/2023 (dd/mm/yyyy)
+Version: 1.12.3
+Date updated: 23/01/2024 (dd/mm/yyyy)
 
 Features:
 ---------
@@ -30,8 +30,10 @@ __all__ = [
     # Sub
     "Pow",
     "ListREPR",
+    "ListNoDunder",
     "DictBoolTrue",
     "DictBoolFalse",
+    # "DictNoDunder",
 ]
 
 
@@ -42,7 +44,8 @@ from itertools import accumulate, chain, groupby
 import math
 import operator
 import random
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from sys import version_info as python_version
 
 from absfuyu.general.generator import Generator, Charset
 from absfuyu.logger import logger, _compress_list_for_print
@@ -109,6 +112,14 @@ class ListREPR(list):
         return _compress_list_for_print(self, 9)
 
 
+class ListNoDunder(List[str]):
+    """Use with ``object.__dir__()``"""
+
+    def __repr__(self) -> str:
+        out = [x for x in self if not x.startswith("__")]
+        return out.__repr__()
+
+
 class DictBoolTrue(Dict[Any, bool]):
     """Only show items when ``values == True`` in ``__repr__()``"""
 
@@ -125,6 +136,18 @@ class DictBoolFalse(Dict[Any, bool]):
         return _dict_bool(temp, False).__repr__()
 
 
+# class DictNoDunder(dict):  # W.I.P
+#     """Remove dunder methods in ``__repr__()`` of dict"""
+
+#     def __repr__(self) -> str:
+#             temp = self.copy()
+#             out = dict()
+#             for k, v in temp.items():
+#                 if not str(k).startswith("__"):
+#                     out.__setattr__(k, v)
+#             return out.__repr__()
+
+
 # Class
 ###########################################################################
 class Text(str):
@@ -419,6 +442,48 @@ class Text(str):
         logger.debug(temp)
         return __class__("".join(temp))
 
+    def reverse_capslock(self) -> "Text":
+        """
+        Reverse capslock in string
+
+        Returns
+        -------
+        Text
+            Reversed capslock ``Text``
+
+
+        Example:
+        --------
+        >>> test = Text("Foo")
+        >>> test.reverse_capslock()
+        'fOO'
+        """
+        temp = list(self)
+        for i, x in enumerate(temp):
+            if x.isupper():
+                temp[i] = x.lower()
+            else:
+                temp[i] = x.upper()
+        return __class__("".join(temp))
+
+    def to_list(self) -> List[str]:
+        """
+        Convert into list
+        
+        Returns
+        -------
+        list[str]
+            List of string
+
+
+        Example:
+        --------
+        >>> test = Text("test")
+        >>> test.to_list()
+        ['t', 'e', 's', 't']
+        """
+        return list(self)
+
 
 class IntNumber(int):
     """
@@ -776,7 +841,10 @@ class IntNumber(int):
         >>> test.gcd(8)
         8
         """
-        return __class__(math.gcd(self, with_number))
+        if python_version.micro < 9:
+            return __class__(math.gcd(self, with_number))
+        else:
+            return __class__(math.lcm(self, with_number))
 
     def add_to_one_digit(self, master_number: bool = False) -> "IntNumber":
         """
@@ -806,7 +874,7 @@ class IntNumber(int):
         11
         """
         number = self
-        if number <= 1:
+        if number < 0:
             number *= -1
         logger.debug(f"Current number: {number}")
         while len(str(number)) != 1:
@@ -847,7 +915,8 @@ class IntNumber(int):
         divi_list = [x for x in range(1, int(self / 2) + 1) if self % x == 0] + [self]
 
         if short_form:
-            return ListREPR(divi_list)
+            return divi_list
+            # return ListREPR(divi_list) ## FIX LATER
         return divi_list
 
     def prime_factor(self, short_form: bool = True) -> Union[List[int], List[Pow]]:
@@ -921,8 +990,8 @@ class IntNumber(int):
         >>> test = IntNumber(1024)
         >>> test.analyze()
         {
-            'summary': {'number': 1024, 'length': 4, 'even': True, 'prime factor': [2^10], 'divisible': [1, 2, 4, 8, ...,128, 256, 512, 1024] [Len: 11]},
-            'convert': {'binary': '10000000000', 'reverse': 4201, 'add to one': 7},
+            'summary': {'number': 1024, 'length': 4, 'even': True, 'prime factor': [2^10], 'divisible': [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]},
+            'convert': {'binary': '10000000000', 'octa': '2000', 'hex': '400', 'reverse': 4201, 'add to one': 7},
             'characteristic': {'prime': False, 'twisted prime': False, 'perfect': False, 'narcissistic': False, 'palindromic': False, 'palindromic prime': False}
         }
         """
@@ -935,7 +1004,10 @@ class IntNumber(int):
                 "divisible": self.divisible_list(short_form=short_form),
             },
             "convert": {
-                "binary": self.to_binary(),
+                "binary": bin(self)[2:],
+                "octa": oct(self)[2:],
+                "hex": hex(self)[2:],
+                # "hash": hash(self),
                 "reverse": self.reverse(),
                 "add to one": self.add_to_one_digit(),
             },
@@ -1235,7 +1307,7 @@ class ListExt(list):
         logger.debug(out)
         return out
 
-    def apply(self, func) -> "ListExt":
+    def apply(self, func: Callable) -> "ListExt":
         """
         Apply function to each entry
 
@@ -1301,6 +1373,13 @@ class ListExt(list):
         temp = groupby(self.sorts())
         return __class__([list(g) for _, g in temp])
 
+    @staticmethod
+    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]:
         """
         Assume each ``list`` in ``list`` is a pair value,
@@ -1353,6 +1432,62 @@ class ListExt(list):
 
         return list(x for x, _ in groupby(iter))
 
+    def flatten(self) -> "ListExt":
+        """
+        Flatten the list
+
+        Returns
+        -------
+        ListExt
+            Flattened list
+
+
+        Example:
+        --------
+        >>> test = ListExt([["test"], ["test", "test"], ["test"]])
+        >>> test.flatten()
+        ['test', 'test', 'test', 'test']
+        """
+        try:
+            return ListExt(chain(*self))
+        except:
+            temp = list(map(lambda x: x if isinstance(x, list) else [x], self))
+            return ListExt(chain(*temp))
+
+    def numbering(self, start: int = 0) -> "ListExt":
+        """
+        Number the item in list
+        (``enumerate`` wrapper)
+
+        Parameters
+        ----------
+        start : int
+            Start from which number
+            (Default: ``0``)
+
+        Returns
+        -------
+        ListExt
+            Counted list
+
+
+        Example:
+        --------
+        >>> test = ListExt([9, 9, 9])
+        >>> test.numbering()
+        [(0, 9), (1, 9), (2, 9)]
+        """
+        start = set_min(start, min_value=0)
+        return ListExt(enumerate(self, start=start))
+
+    @staticmethod
+    def _numbering(iterable: list, start: int = 0) -> List[Tuple[int, Any]]:
+        """
+        Static method for ``numbering``
+        """
+        start = set_min(start, min_value=0)
+        return list(enumerate(iterable, start=start))
+
 
 class DictExt(dict):
     """
@@ -1434,7 +1569,7 @@ class DictExt(dict):
         """
         return __class__(zip(self.values(), self.keys()))
 
-    def apply(self, func, apply_to_value: bool = True) -> "DictExt":
+    def apply(self, func: Callable, apply_to_value: bool = True) -> "DictExt":
         """
         Apply function to ``DictExt.keys()`` or ``DictExt.values()``
 
@@ -1472,3 +1607,4 @@ class DictExt(dict):
 ###########################################################################
 if __name__ == "__main__":
     logger.setLevel(10)
+    # from rich import print