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

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/{collections → general}/__init__.py

@@ -1,10 +1,10 @@
 """
-Absfuyu: Collections
---------------------
+Absfuyu: General
+----------------
 Collection of useful classes
 
-Version: 1.1.1
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 1.1.3
+Date updated: 26/11/2023 (dd/mm/yyyy)
 
 Features:
 ---------
@@ -16,9 +16,7 @@ Features:
 
 # Libary
 ###########################################################################
-from absfuyu.collections import (
-    content, data_extension, generator, human
-)
+from absfuyu.general import content, data_extension, generator, human
 
 
 # Class
@@ -29,27 +27,28 @@ class Dummy:
 
     Update attribute through dict
     """
+
     def __init__(self, data: dict = None) -> None:
         try:
             self.__dict__.update(data)
         except:
             pass
-    
+
     def __str__(self) -> str:
         class_name = self.__class__.__name__
         return f"{class_name}({self.__dict__})"
 
     def __repr__(self) -> str:
         return self.__str__()
-    
+
     def dir_(self):
         """List ``property``"""
         return [x for x in self.__dir__() if not x.startswith("_")]
-    
+
     def update(self, data: dict) -> None:
         """
         Update with dict data
-        
+
         :param data: Dict data
         :type data: dict
         """
@@ -58,10 +57,13 @@ class Dummy:
 
 class ClassBase:
     """Class base for other class"""
+
     def __init__(self) -> None:
         pass
+
     def __str__(self) -> str:
         return f"{self.__class__.__name__}({self._get_key_and_val_for_print()})"
+
     def __repr__(self) -> str:
         return self.__str__()
 
@@ -81,4 +83,4 @@ class ClassBase:
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    pass
+    pass