absfuyu 3.2.0__py3-none-any.whl → 3.4.0__py3-none-any.whl

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())