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

absfuyu/fun/__init__.py

@@ -3,16 +3,15 @@ Absfuyu: Fun
 ------------
 Some fun or weird stuff
 
-Version: 1.0.5
-Date updated: 27/11/2023 (dd/mm/yyyy)
+Version: 1.0.6
+Date updated: 05/04/2023 (dd/mm/yyyy)
 """
 
-
 # Library
 ###########################################################################
-from datetime import date
 import subprocess
 import sys
+from datetime import date
 
 from absfuyu.logger import logger
 from absfuyu.util.api import APIRequest
@@ -55,7 +54,7 @@ def zodiac_sign(
         0 < month < 13,
     ]
     if not all(conditions):
-        raise SystemExit("Value out of range")
+        raise ValueError("Value out of range")
 
     zodiac = {
         "Aquarius": any(
@@ -148,8 +147,8 @@ def im_bored() -> str:
     """
     try:
         api = APIRequest("https://www.boredapi.com/api/activity")
-        return api.fetch_data_only().json()["activity"]
-    except:
+        return api.fetch_data_only().json()["activity"]  # type: ignore
+    except Exception:
         return "FAILED"
 
 

absfuyu/fun/tarot.py

@@ -75,7 +75,7 @@ class Tarot:
 
         :rtype: list[TarotCard]
         """
-        tarot_data: list = Pickler.load(self.data_location)
+        tarot_data: list = Pickler.load(self.data_location)  # type: ignore
         logger.debug(f"{len(tarot_data)} tarot cards loaded")
         return [
             TarotCard(

absfuyu/game/__init__.py

@@ -3,65 +3,66 @@ Absfuyu: Game
 -------------
 Contain some game that can be played on terminal
 
-Version: 1.0.2
-Date updated: 24/11/2023 (mm/dd/yyyy)
+Version: 1.1.0
+Date updated: 14/04/2024 (mm/dd/yyyy)
 """
 
-
-# Module Package
-###########################################################################
 __all__ = [
-    "game_escapeLoop", "game_RockPaperScissors",
+    "game_escapeLoop",
+    "game_RockPaperScissors",
 ]
 
 
-# Library
-###########################################################################
-from random import choice as __randChoice
+import random
+import time
+
+from .game_stat import GameStats
+
+# Escape loop
+_ESCAPE_LOOP_GAME_MSG = """\
+Are you sure about this?
+Don't leave me =((
+I can't believe you did this to me!
+Are you very much sure?
+I'll be sad. Pick again please.
+I still don't believe you.
+Choose again.
+You actually have to answer the correct keyword
+I think you need to choose again.
+Last chance!
+Okay okay, i believe you ;)
+Almost there.
+I can do this all day
+So close!
+You can't escape from me.
+How are you still here, just to suffer?
+Never gonna give you up
+Never gonna let you down
+"""
 
 
-# Default games
-###########################################################################
 def game_escapeLoop() -> None:
     """Try to escape the infinite loop"""
-    
+
     init = True
     welcome_messages = [
         "Congrats! You are now stuck inside an infinite loop.",
-        "Do you want to escape this loop?"
+        "Do you want to escape this loop?",
     ]
 
-    num1 = __randChoice([2,3,4,5,6,7,8,9,10,11,12])
-    num2 = __randChoice([2,3,4,5,6,7,8,9,10,11,12])
+    num1 = random.choice(range(2, 13))
+    num2 = random.choice(range(2, 13))
     hidden_answer = str(num1 * num2)
 
-    game_messages = [
-        "Are you sure about this?",
-        "Don't leave me =((",
-        "I can't believe you did this to me!",
-        "Are you very much sure?",
-        "I'll be sad. Pick again please.",
-        "I still don't believe you.", 
-        "Choose again.",
-        "You actually have to answer the correct keyword",
-        "I think you need to choose again.",
-        "Last chance!",
-        "Okay okay, i believe you ;)",
-        "Almost there.",
-        "I can do this all day", 
-        "So close!",
-        "You can't escape from me.",
-        "How are you still here, just to suffer?",
-        "Never gonna give you up",
-        "Never gonna let you down",
+    gm_msg = {x for x in _ESCAPE_LOOP_GAME_MSG.splitlines() if len(x) > 0}
+    game_messages = list(gm_msg) + [
         f"Hint 01: The keyword is: {num1}",
-        f"Hint 02: *{num2}",
+        f"Hint 02: {num2}",
     ]
 
-    congrats_messages = [
-        "Congratulation! You've escaped."
-    ]
-    
+    congrats_messages = ["Congratulation! You've escaped."]
+
+    start_time = time.time()
     while True:
         # Welcome
         if init:
@@ -69,9 +70,9 @@ def game_escapeLoop() -> None:
                 print(x)
             answer = str(input())
             init = False
-        
+
         # Random text
-        mess = __randChoice(game_messages)
+        mess = random.choice(game_messages)
         print(mess)
 
         # Condition check
@@ -79,24 +80,22 @@ def game_escapeLoop() -> None:
         if answer == hidden_answer:
             for x in congrats_messages:
                 print(x)
+            stop_time = time.time()
             break
-    pass
+    print(f"= Escaped in {stop_time-start_time:,.2f}s =")
 
 
-def game_RockPaperScissors(hard_mode=False):
+# Rock Paper Scissors
+def game_RockPaperScissors(hard_mode: bool = False) -> GameStats:
     """
     Rock Paper Scissors
-    
+
     :param hard_mode: The bot only win or draw (Default: ``False``)
     :type hard_mode: bool
     """
-    
-    state_dict = {
-        0: "rock",
-        1: "paper",
-        2: "scissors"
-    }
-    
+
+    state_dict = {"0": "rock", "1": "paper", "2": "scissors"}
+
     init = True
 
     end_message = "end"
@@ -108,67 +107,62 @@ def game_RockPaperScissors(hard_mode=False):
 
     game_messages = [
         "Pick one option to begin:",
+        " ".join([f"{k}={v}" for k, v in state_dict.items()]),
     ]
 
-    game_summary = {
-        "Win": 0,
-        "Draw": 0,
-        "Lose": 0
-    }
-    
+    game_summary = GameStats()
+
     while True:
         # Welcome
         if init:
             for x in welcome_messages:
                 print(x)
             init = False
-        
+
         # Game start
         print("")
         for x in game_messages:
             print(x)
-        print(state_dict)
-        
+
         # Player's choice
-        answer = input()
+        answer = input().strip().lower()
 
         # Condition check
         if answer == end_message:
             print(game_summary)
             break
-        
-        elif answer not in ["0","1","2"]:
+
+        elif answer not in ["0", "1", "2"]:
             print("Invalid option. Choose again!")
-        
+
         else:
             # Calculation
-            answer = int(answer)
             if hard_mode:
-                if answer == 0:
-                    game_choice = __randChoice([0,1])
-                if answer == 1:
-                    game_choice = __randChoice([1,2])
-                if answer == 2:
-                    game_choice = __randChoice([0,2])
+                if answer == "0":
+                    game_choice = random.choice(["0", "1"])
+                if answer == "1":
+                    game_choice = random.choice(["1", "2"])
+                if answer == "2":
+                    game_choice = random.choice(["0", "2"])
             else:
-                game_choice = __randChoice([0,1,2])
+                game_choice = random.choice(["0", "1", "2"])
             print(f"You picked: {state_dict[answer]}")
             print(f"BOT picked: {state_dict[game_choice]}")
-            
-            if answer == 2 and game_choice == 0:
+
+            if answer == "2" and game_choice == "0":
                 print("You Lose!")
-                game_summary["Lose"] += 1
-            elif answer == 0 and game_choice == 2:
+                game_summary.update_score("lose")
+            elif answer == "0" and game_choice == "2":
                 print("You Win!")
-                game_summary["Win"] += 1
+                game_summary.update_score("win")
             elif answer == game_choice:
                 print("Draw Match!")
-                game_summary["Draw"] += 1
+                game_summary.update_score("draw")
             elif answer > game_choice:
                 print("You Win!")
-                game_summary["Win"] += 1
+                game_summary.update_score("win")
             else:
                 print("You Lose!")
-                game_summary["Lose"] += 1
+                game_summary.update_score("lose")
 
-    return game_summary
+    return game_summary

absfuyu/game/game_stat.py

@@ -0,0 +1,36 @@
+"""
+Game: Game Stat
+
+Version: 1.0.0
+Date updated: 14/04/2024 (dd/mm/yyyy)
+"""
+
+__all__ = ["GameStats"]
+
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+
+@dataclass
+class GameStats:
+    win: int = field(default=0)
+    draw: int = field(default=0)
+    lose: int = field(default=0)
+    win_rate: str = field(init=False)
+    _win_rate: float = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        self._update_win_rate()
+
+    def _update_win_rate(self) -> None:
+        try:
+            self._win_rate = self.win / (self.win + self.draw + self.lose)
+            self.win_rate = f"{self._win_rate*100:,.2f}%"
+        except ZeroDivisionError:
+            self._win_rate = 0
+            self.win_rate = "N/A"
+
+    def update_score(self, option: Literal["win", "draw", "lose"]) -> None:
+        self.__setattr__(option, self.__getattribute__(option) + 1)
+        self._update_win_rate()

absfuyu/game/sudoku.py

@@ -12,21 +12,12 @@ Credit:
 - [Solve algo](https://www.techwithtim.net/tutorials/python-programming/sudoku-solver-backtracking/)
 """
 
-
-# Module level
-###########################################################################
-__all__ = [
-    "Sudoku"
-]
+__all__ = ["Sudoku"]
 
 
-# Library
-###########################################################################
-from typing import List
+from typing import List, Literal, Tuple
 
 
-# Class
-###########################################################################
 class Sudoku:
     def __init__(self, sudoku_data: List[List[int]]) -> None:
         self.data = sudoku_data
@@ -34,21 +25,23 @@ class Sudoku:
         self._row_len = len(self.data)
         self._col_len = len(self.data[0])
         # self.solved = None
+
     def __str__(self) -> str:
         return f"{self.__class__.__name__}({self.export_to_string()})"
+
     def __repr__(self) -> str:
         return self.__str__()
-    
-    def export_to_string(self, *, style: str = "dot") -> str:
+
+    def export_to_string(self, *, style: Literal["dot", "zero"] = "dot") -> str:
         """
         Export Sudoku data to string form
 
         Parameters
         ----------
-        style : str
+        style : Literal["dot", "zero"]
             - "zero": ``0`` is ``0``
             - "dot": ``0`` is ``.``
-        
+
         Returns
         -------
         str
@@ -57,16 +50,16 @@ class Sudoku:
         style_option = ["zero", "dot"]
         if style.lower() not in style_option:
             style = "dot"
-        
+
         out = "".join(str(self.data))
         remove = ["[", "]", " ", ","]
         for x in remove:
             out = out.replace(x, "")
-        
+
         if style.startswith("zero"):
             return out
         elif style.startswith("dot"):
-            out = out.replace("0",".")
+            out = out.replace("0", ".")
             return out
         else:
             return out
@@ -80,7 +73,7 @@ class Sudoku:
         ----------
         string_data : str
             String data
-        
+
         Returns
         -------
         Sudoku
@@ -102,38 +95,39 @@ class Sudoku:
         """
         if len(string_data) == 81:
             # Convert
-            sdk = str(string_data).replace(".","0")
-            
+            sdk = str(string_data).replace(".", "0")
+
             # Divide into 9 equal parts
             temp = []
             while len(sdk) != 0:
                 temp.append(sdk[:9])
                 sdk = sdk[9:]
-            
+
             # Turn into list[list[int]]
             out = []
             for value in temp:
                 temp_list = [int(x) for x in value]
                 out.append(temp_list)
-        
+
         else:
             # Invalid length
             raise ValueError("Invalid length")
         return cls(out)
-    
+
     @classmethod
     def hardest_sudoku(cls):
         """
-        Create Hardest Sudoku instance 
+        Create Hardest Sudoku instance
         ([Source](https://www.telegraph.co.uk/news/science/science-news/9359579/Worlds-hardest-sudoku-can-you-crack-it.html))
-        
+
         Returns
         -------
         Sudoku
             ``Sudoku`` instance
         """
-        return cls.from_string("8..........36......7..9.2...5...7.......457.....1...3...1....68..85...1..9....4..")
-
+        return cls.from_string(
+            "8..........36......7..9.2...5...7.......457.....1...3...1....68..85...1..9....4.."
+        )
 
     def to_board_form(self) -> str:
         """
@@ -144,7 +138,7 @@ class Sudoku:
         str
             Sudoku Board data that ready to print
 
-            
+
         Example:
         --------
         >>> demo = Sudoku.hardest_sudoku()
@@ -167,22 +161,21 @@ class Sudoku:
         for row in range(self._row_len):
             if row % 3 == 0:
                 if row == 0:
-                    out_string = out_string + u" \u250E" + u"\u2500"*29 + u"\u2512\n"
+                    out_string = out_string + " \u250E" + "\u2500" * 29 + "\u2512\n"
                 else:
-                    out_string = out_string + u" \u2520" + u"\u2500"*29 + u"\u2528\n"
+                    out_string = out_string + " \u2520" + "\u2500" * 29 + "\u2528\n"
 
             for col in range(self._col_len):
                 if col % 3 == 0:
-                    out_string += u" \u2503  "
+                    out_string += " \u2503  "
 
                 if col == 8:
-                    out_string = out_string + str(self.data[row][col]) + u"  \u2503\n"
+                    out_string = out_string + str(self.data[row][col]) + "  \u2503\n"
                 else:
                     out_string = out_string + str(self.data[row][col]) + " "
 
-        out_string = out_string + u" \u2516" + u"\u2500"*29 + u"\u251A"
+        out_string = out_string + " \u2516" + "\u2500" * 29 + "\u251A"
         return out_string
-    
 
     # Solve
     def _find_empty(self):
@@ -200,15 +193,15 @@ class Sudoku:
                     return (row, col)
         # Return None when there is no empty cell
         return None
-    
-    def _is_valid(self, number: int, position: tuple) -> bool:
+
+    def _is_valid(self, number: int, position: Tuple[int, int]) -> bool:
         """
         Check valid number value in row, column, box
         """
-        row, col = position # unpack tuple
+        row, col = position  # unpack tuple
 
         # Check row
-        for i in range(self._col_len): # each item in row i; row i has `col_len` items
+        for i in range(self._col_len):  # each item in row i; row i has `col_len` items
             if self.data[row][i] == number and col != i:
                 return False
 
@@ -236,12 +229,12 @@ class Sudoku:
         # Find empty cell
         empty_pos = self._find_empty()
         if empty_pos is None:
-            return True # solve_state (True: every cell filled)
+            return True  # solve_state (True: every cell filled)
         else:
             # unpack position when exist empty cell
             row, col = empty_pos
 
-        for num in range(1,10): # sudoku value (1-9)
+        for num in range(1, 10):  # sudoku value (1-9)
             if self._is_valid(num, empty_pos):
                 self.data[row][col] = num
 
@@ -253,17 +246,17 @@ class Sudoku:
 
         # End recursive
         return False
-    
+
     def solve(self):
         """
         Solve the Sudoku
-        
+
         Returns
         -------
         Sudoku
             ``Sudoku`` instance
-        
-    
+
+
         Example:
         --------
         >>> test = Sudoku.hardest_sudoku()
@@ -286,11 +279,11 @@ class Sudoku:
         self._solve()
         # self.solved = self.data
         # self.data = self._original
-        return __class__(self.data)
-    
+        return self.__class__(self.data)
+
 
 # Run
 ###########################################################################
 if __name__ == "__main__":
     test = Sudoku.hardest_sudoku()
-    print(test.solve().to_board_form())
+    print(test.solve().to_board_form())