maze.py 1.0.1: fix linter/typing errors, reformat script, remove history, add SPDX copyright and license tags

Author: flashcode

REUSE.toml

@@ -1331,12 +1331,6 @@ precedence = "override"
 SPDX-FileCopyrightText = "2015-2016 Jos Ahrens <zarthus@lovebytes.me>"
 SPDX-License-Identifier = "MIT"
 
-[[annotations]]
-path = "python/maze.py"
-precedence = "override"
-SPDX-FileCopyrightText = "2012-2022 Sébastien Helleu <flashcode@flashtux.org>"
-SPDX-License-Identifier = "GPL-3.0-or-later"
-
 [[annotations]]
 path = "python/memon.py"
 precedence = "override"

python/maze.py

@@ -1,5 +1,7 @@
 #
-# Copyright (C) 2012-2022 Sébastien Helleu <flashcode@flashtux.org>
+# SPDX-FileCopyrightText: 2012-2026 Sébastien Helleu <flashcode@flashtux.org>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -15,26 +17,14 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-#
-# Interactive maze generator and solver for WeeChat.
-#
-# History:
-#
-# 2022-02-20, Sébastien Helleu <flashcode@flashtux.org>:
-#     version 1.0.0: first public version
-# 2012-10-10, Sébastien Helleu <flashcode@flashtux.org>:
-#     version 0.0.1: initial release
-#
-
-"""Maze generator and solver for WeeChat."""
-
-from dataclasses import dataclass, field
-from typing import ClassVar, Dict, List, Optional, Tuple
+"""Interactive maze generator and solver for WeeChat."""
 
 import random
+from dataclasses import dataclass, field
 
 try:
-    import weechat
+    import weechat  # type: ignore[import]
+
     IMPORT_OK = True
 except ImportError:
     print("This script must be run under WeeChat.")
@@ -43,13 +33,13 @@
 
 SCRIPT_NAME = "maze"
 SCRIPT_AUTHOR = "Sébastien Helleu <flashcode@flashtux.org>"
-SCRIPT_VERSION = "1.0.0"
+SCRIPT_VERSION = "1.0.1"
 SCRIPT_LICENSE = "GPL3"
 SCRIPT_DESC = "Interactive maze generator and solver"
 
 SCRIPT_COMMAND = "maze"
 
-MAZE_KEYS: Dict[str, Tuple[str, str]] = {
+MAZE_KEYS: dict[str, tuple[str, str]] = {
     "n": ("", "new maze"),
     "d": ("default", "default size"),
     "+": ("+", "bigger"),
@@ -63,23 +53,23 @@
 @dataclass
 class Maze:
     """Maze."""
+
     width: int = 0
     height: int = 0
 
-    cells: List[int] = field(default_factory=list, init=False)
-    solution: List[tuple[int, int, bool]] = field(default_factory=list,
-                                                  init=False)
+    cells: list[int] = field(default_factory=list, init=False)
+    solution: list[tuple[int, int, bool]] = field(default_factory=list, init=False)
     buffer: str = field(init=False)
     timer: str = field(default="", init=False)
 
     # cell status
-    VISITED: ClassVar[int] = 1        # visited cell
-    TOP: ClassVar[int] = 2            # door opened on top
-    BOTTOM: ClassVar[int] = 4         # door opened on bottom
-    LEFT: ClassVar[int] = 8           # door opened on the left
-    RIGHT: ClassVar[int] = 16         # door opened on the right
-    SOLUTION: ClassVar[int] = 32      # cell part of the solution
-    SOLUTION_INT: ClassVar[int] = 64  # cell displayed for solution
+    VISITED: int = 1  # visited cell
+    TOP: int = 2  # door opened on top
+    BOTTOM: int = 4  # door opened on bottom
+    LEFT: int = 8  # door opened on the left
+    RIGHT: int = 16  # door opened on the right
+    SOLUTION: int = 32  # cell part of the solution
+    SOLUTION_INT: int = 64  # cell displayed for solution
 
     def __post_init__(self) -> None:
         """Initialize maze with the given size."""
@@ -89,10 +79,9 @@ def __post_init__(self) -> None:
         self.solution = []
         self.buffer = Maze.open_buffer()
         if self.buffer:
-            keys = ", ".join([
-                f"alt+\"{key}\": {value[1]}"
-                for key, value in MAZE_KEYS.items()
-            ])
+            keys = ", ".join(
+                [f'alt+"{key}": {value[1]}' for key, value in MAZE_KEYS.items()]
+            )
             weechat.buffer_set(
                 self.buffer,
                 "title",
@@ -123,8 +112,8 @@ def open_buffer() -> str:
         return buf
 
     def get_adjacent_cells(
-            self, col: int, line: int
-    ) -> List[Tuple[int, int, int, int]]:
+        self, col: int, line: int
+    ) -> list[tuple[int, int, int, int]]:
         """Get adjacent cells."""
         list_cells = []
         if col < self.width - 1:  # right
@@ -144,11 +133,11 @@ def generate(self) -> None:
         col: int = 0
         line: int = 0
         self.cells[0] |= self.VISITED
-        stack: List[Tuple[int, int]] = []
+        stack: list[tuple[int, int]] = []
         while True:
             pos: int = (line * self.width) + col
-            list_cells: List[Tuple[int, int, int, int]] = (
-                self.get_adjacent_cells(col, line)
+            list_cells: list[tuple[int, int, int, int]] = self.get_adjacent_cells(
+                col, line
             )
             random.shuffle(list_cells)
             for col2, line2, to_neighbor, from_neighbor in list_cells:
@@ -171,25 +160,28 @@ def solve(self, interactive: bool = False) -> None:
         """Solve a maze: find path from entry (0,0) to exit (n,n)."""
         self.remove_timer()
         for index, cell in enumerate(self.cells):
-            self.cells[index] = cell & ~(self.VISITED | self.SOLUTION
-                                         | self.SOLUTION_INT)
+            self.cells[index] = cell & ~(
+                self.VISITED | self.SOLUTION | self.SOLUTION_INT
+            )
         col: int = 0
         line: int = 0
         self.cells[0] |= self.SOLUTION
         self.solution = [(col, line, True)]
-        stack: List[Tuple[int, int]] = []
+        stack: list[tuple[int, int]] = []
         visited_solution = self.VISITED | self.SOLUTION
         while not self.cells[-1] & self.SOLUTION:
             pos: int = (line * self.width) + col
             self.cells[pos] |= self.VISITED
-            list_cells: List[Tuple[int, int, int, int]] = (
-                self.get_adjacent_cells(col, line)
+            list_cells: list[tuple[int, int, int, int]] = self.get_adjacent_cells(
+                col, line
             )
             for col2, line2, to_neighbor, _ in list_cells:
                 pos2: int = (line2 * self.width) + col2
                 # door opened and neighbor not visited/solution?
-                if self.cells[pos] & to_neighbor \
-                        and not self.cells[pos2] & visited_solution:
+                if (
+                    self.cells[pos] & to_neighbor
+                    and not self.cells[pos2] & visited_solution
+                ):
                     self.cells[pos2] |= visited_solution
                     self.solution.append((col2, line2, True))
                     stack.append((col, line))
@@ -217,27 +209,27 @@ def display_line(self, line: int) -> None:
         """Display a line of maze."""
         str_line: str
         if line >= self.height:
-            str_line = (
-                weechat.color("white")
-                + ("▀" * ((self.width * 2) + 1))
-            )
+            str_line = weechat.color("white") + ("▀" * ((self.width * 2) + 1))
         else:
             both_sol: int = self.SOLUTION | self.SOLUTION_INT
             cell: int = self.cells[line * self.width]
             color: str = (
-                "lightred" if cell & self.SOLUTION_INT
-                else "blue" if cell & self.SOLUTION
+                "lightred"
+                if cell & self.SOLUTION_INT
+                else "blue"
+                if cell & self.SOLUTION
                 else "black"
             )
-            str_line = (
-                weechat.color(f"{color},white")
-                + ("▄" if cell & self.LEFT else " ")
+            str_line = weechat.color(f"{color},white") + (
+                "▄" if cell & self.LEFT else " "
             )
             for col in range(self.width):
                 cell = self.cells[(line * self.width) + col]
                 color = (
-                    "lightred" if cell & self.SOLUTION_INT
-                    else "blue" if cell & self.SOLUTION
+                    "lightred"
+                    if cell & self.SOLUTION_INT
+                    else "blue"
+                    if cell & self.SOLUTION
                     else "black"
                 )
                 # door opened on top?
@@ -250,9 +242,8 @@ def display_line(self, line: int) -> None:
                 else:
                     str_line += weechat.color(f"{color},white") + "▄"
                 # door opened on the right?
-                str_line += (
-                    weechat.color(f"{color},white")
-                    + ("▄" if cell & self.RIGHT else " ")
+                str_line += weechat.color(f"{color},white") + (
+                    "▄" if cell & self.RIGHT else " "
                 )
         str_line += weechat.color("reset")
         weechat.prnt_y(self.buffer, line, str_line)
@@ -278,9 +269,6 @@ def show_interactive_solution(self) -> None:
 
     def show_next_solution(self) -> None:
         """Show next solution step."""
-        col: int
-        line: int
-        show: bool
         col, line, show = self.solution.pop(0)
         pos: int = (line * self.width) + col
         if show:
@@ -296,10 +284,10 @@ def __del__(self) -> None:
         self.remove_timer()
 
 
-maze: Optional[Maze] = None
+maze: Maze | None = None
 
 
-def maze_input_buffer(data: str, buffer: str, str_input: str) -> int:
+def maze_input_buffer(_data: str, buffer: str, str_input: str) -> int:
     """Input data in maze buffer."""
     # pylint: disable=unused-argument
     if str_input.lower() == "q":
@@ -309,23 +297,23 @@ def maze_input_buffer(data: str, buffer: str, str_input: str) -> int:
     return weechat.WEECHAT_RC_OK
 
 
-def maze_close_buffer(data: str, buffer: str) -> int:
+def maze_close_buffer(_data: str, _buffer: str) -> int:
     """Called when maze buffer is closed."""
     # pylint: disable=unused-argument
     global maze
     maze = None
     return weechat.WEECHAT_RC_OK
 
 
-def maze_timer_cb(data: str, remaining_calls: int) -> int:
+def maze_timer_cb(_data: str, _remaining_calls: int) -> int:
     """Timer used to show solution, one cell by one cell."""
     global maze
     if maze:
         maze.show_next_solution()
     return weechat.WEECHAT_RC_OK
 
 
-def maze_get_size(args: str = "") -> Tuple[int, int]:
+def maze_get_size(args: str = "") -> tuple[int, int]:
     """Get maze size with args, defaulting to current maze or window size."""
     global maze
     width: int = 0
@@ -348,20 +336,20 @@ def maze_get_size(args: str = "") -> Tuple[int, int]:
             width, height = 0, 0
     if not width or not height:
         # automatic size with size of window
-        win_width: int = weechat.window_get_integer(weechat.current_window(),
-                                                    "win_chat_width") - 1
-        win_height: int = weechat.window_get_integer(weechat.current_window(),
-                                                     "win_chat_height") - 1
+        win_width: int = (
+            weechat.window_get_integer(weechat.current_window(), "win_chat_width") - 1
+        )
+        win_height: int = (
+            weechat.window_get_integer(weechat.current_window(), "win_chat_height") - 1
+        )
         size: int = min(win_width, win_height)
         width, height = size, size
     return width, height
 
 
-def maze_get_other_size(pct_diff: int) -> Tuple[int, int]:
+def maze_get_other_size(pct_diff: int) -> tuple[int, int]:
     """Get another size using a percent of size to add or subtract."""
     factor: int = pct_diff // abs(pct_diff)
-    width: int
-    height: int
     width, height = maze_get_size()
     add_width: int = max(2, (width * abs(pct_diff)) // 100)
     add_height: int = max(2, (height * abs(pct_diff)) // 100)
@@ -378,11 +366,9 @@ def maze_new(width: int, height: int) -> None:
     maze.display()
 
 
-def maze_cmd_cb(data: str, buffer: str, args: str) -> int:
+def maze_cmd_cb(_data: str, _buffer: str, args: str) -> int:
     """The /maze command."""
     global maze
-    width: int
-    height: int
     if args in ("s", "solve"):
         if maze:
             maze.solve()
@@ -403,21 +389,24 @@ def maze_cmd_cb(data: str, buffer: str, args: str) -> int:
             width, height = maze_get_size()
         else:
             error = weechat.prefix("error")
-            weechat.prnt("", f"{error}maze error: unknown option \"{args}\"")
+            weechat.prnt("", f'{error}maze error: unknown option "{args}"')
             return weechat.WEECHAT_RC_OK
         maze_new(width, height)
     return weechat.WEECHAT_RC_OK
 
 
-if __name__ == "__main__" and IMPORT_OK:
-    if weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION,
-                        SCRIPT_LICENSE, SCRIPT_DESC, "", ""):
-        weechat.hook_command(
-            SCRIPT_COMMAND,
-            "Generate and solve a maze.",
-            "size || n|new || d|default || s|solve || i|isolve || r|reset "
-            "|| +|-",
-            """\
+if (
+    __name__ == "__main__"
+    and IMPORT_OK
+    and weechat.register(
+        SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, SCRIPT_DESC, "", ""
+    )
+):
+    weechat.hook_command(
+        SCRIPT_COMMAND,
+        "Generate and solve a maze.",
+        "size || n|new || d|default || s|solve || i|isolve || r|reset || +|-",
+        """\
    size: one size (square) or width and height separated by spaces
     new: regenerate another maze
 default: regenerate another maze with default size
@@ -429,7 +418,7 @@ def maze_cmd_cb(data: str, buffer: str, args: str) -> int:
 
 All options shown above can be given in input of maze buffer.
 """,
-            "",
-            "maze_cmd_cb",
-            "",
-        )
+        "",
+        "maze_cmd_cb",
+        "",
+    )