Add type annotations and fix code quality issues across all source files

- position.py: convert to @DataClass(frozen=True) with typed row/column fields
- colors.py: annotate all color class attributes as tuple[int, int, int]; annotate get_cell_colors() return type
- block.py: annotate all instance attributes and method signatures
- blocks.py: fix LBlock tab indentation to 4-space; add -> None return types to all __init__ methods
- grid.py: annotate all instance attributes and method signatures
- game.py: replace wildcard 'from blocks import *' with explicit imports; add Block import; annotate all attributes and methods; replace == False/== True with not/direct bool checks
- main.py: split 'import pygame,sys' into two lines; add if __name__ == "__main__": guard wrapping game loop; replace all == True/== False comparisons with idiomatic boolean checks; annotate all top-level variables

Author: mcode-bot

block.py

@@ -2,41 +2,42 @@
 import pygame
 from position import Position
 
+
 class Block:
-	def __init__(self, id):
-		self.id = id
-		self.cells = {}
-		self.cell_size = 30
-		self.row_offset = 0
-		self.column_offset = 0
-		self.rotation_state = 0
-		self.colors = Colors.get_cell_colors()
+    def __init__(self, id: int) -> None:
+        self.id: int = id
+        self.cells: dict[int, list[Position]] = {}
+        self.cell_size: int = 30
+        self.row_offset: int = 0
+        self.column_offset: int = 0
+        self.rotation_state: int = 0
+        self.colors: list[tuple[int, int, int]] = Colors.get_cell_colors()
 
-	def move(self, rows, columns):
-		self.row_offset += rows
-		self.column_offset += columns
+    def move(self, rows: int, columns: int) -> None:
+        self.row_offset += rows
+        self.column_offset += columns
 
-	def get_cell_positions(self):
-		tiles = self.cells[self.rotation_state]
-		moved_tiles = []
-		for position in tiles:
-			position = Position(position.row + self.row_offset, position.column + self.column_offset)
-			moved_tiles.append(position)
-		return moved_tiles
+    def get_cell_positions(self) -> list[Position]:
+        tiles = self.cells[self.rotation_state]
+        moved_tiles: list[Position] = []
+        for position in tiles:
+            position = Position(position.row + self.row_offset, position.column + self.column_offset)
+            moved_tiles.append(position)
+        return moved_tiles
 
-	def rotate(self):
-		self.rotation_state += 1
-		if self.rotation_state == len(self.cells):
-			self.rotation_state = 0
+    def rotate(self) -> None:
+        self.rotation_state += 1
+        if self.rotation_state == len(self.cells):
+            self.rotation_state = 0
 
-	def undo_rotation(self):
-		self.rotation_state -= 1
-		if self.rotation_state == -1:
-			self.rotation_state = len(self.cells) - 1
+    def undo_rotation(self) -> None:
+        self.rotation_state -= 1
+        if self.rotation_state == -1:
+            self.rotation_state = len(self.cells) - 1
 
-	def draw(self, screen, offset_x, offset_y):
-		tiles = self.get_cell_positions()
-		for tile in tiles:
-			tile_rect = pygame.Rect(offset_x + tile.column * self.cell_size, 
-				offset_y + tile.row * self.cell_size, self.cell_size -1, self.cell_size -1)
-			pygame.draw.rect(screen, self.colors[self.id], tile_rect)
+    def draw(self, screen: pygame.Surface, offset_x: int, offset_y: int) -> None:
+        tiles = self.get_cell_positions()
+        for tile in tiles:
+            tile_rect = pygame.Rect(offset_x + tile.column * self.cell_size,
+                offset_y + tile.row * self.cell_size, self.cell_size - 1, self.cell_size - 1)
+            pygame.draw.rect(screen, self.colors[self.id], tile_rect)

blocks.py

@@ -1,20 +1,22 @@
 from block import Block
 from position import Position
 
+
 class LBlock(Block):
-	def __init__(self):
-		super().__init__(id = 1)
-		self.cells = {
-			0: [Position(0, 2), Position(1, 0), Position(1, 1), Position(1, 2)],
-			1: [Position(0, 1), Position(1, 1), Position(2, 1), Position(2, 2)],
-			2: [Position(1, 0), Position(1, 1), Position(1, 2), Position(2, 0)],
-			3: [Position(0, 0), Position(0, 1), Position(1, 1), Position(2, 1)]
-		}
-		self.move(0, 3)
+    def __init__(self) -> None:
+        super().__init__(id=1)
+        self.cells = {
+            0: [Position(0, 2), Position(1, 0), Position(1, 1), Position(1, 2)],
+            1: [Position(0, 1), Position(1, 1), Position(2, 1), Position(2, 2)],
+            2: [Position(1, 0), Position(1, 1), Position(1, 2), Position(2, 0)],
+            3: [Position(0, 0), Position(0, 1), Position(1, 1), Position(2, 1)]
+        }
+        self.move(0, 3)
+
 
 class JBlock(Block):
-    def __init__(self):
-        super().__init__(id = 2)
+    def __init__(self) -> None:
+        super().__init__(id=2)
         self.cells = {
             0: [Position(0, 0), Position(1, 0), Position(1, 1), Position(1, 2)],
             1: [Position(0, 1), Position(0, 2), Position(1, 1), Position(2, 1)],
@@ -23,9 +25,10 @@ def __init__(self):
         }
         self.move(0, 3)
 
+
 class IBlock(Block):
-    def __init__(self):
-        super().__init__(id = 3)
+    def __init__(self) -> None:
+        super().__init__(id=3)
         self.cells = {
             0: [Position(1, 0), Position(1, 1), Position(1, 2), Position(1, 3)],
             1: [Position(0, 2), Position(1, 2), Position(2, 2), Position(3, 2)],
@@ -34,17 +37,19 @@ def __init__(self):
         }
         self.move(-1, 3)
 
+
 class OBlock(Block):
-    def __init__(self):
-        super().__init__(id = 4)
+    def __init__(self) -> None:
+        super().__init__(id=4)
         self.cells = {
             0: [Position(0, 0), Position(0, 1), Position(1, 0), Position(1, 1)]
         }
         self.move(0, 4)
 
+
 class SBlock(Block):
-    def __init__(self):
-        super().__init__(id = 5)
+    def __init__(self) -> None:
+        super().__init__(id=5)
         self.cells = {
             0: [Position(0, 1), Position(0, 2), Position(1, 0), Position(1, 1)],
             1: [Position(0, 1), Position(1, 1), Position(1, 2), Position(2, 2)],
@@ -53,9 +58,10 @@ def __init__(self):
         }
         self.move(0, 3)
 
+
 class TBlock(Block):
-    def __init__(self):
-        super().__init__(id = 6)
+    def __init__(self) -> None:
+        super().__init__(id=6)
         self.cells = {
             0: [Position(0, 1), Position(1, 0), Position(1, 1), Position(1, 2)],
             1: [Position(0, 1), Position(1, 1), Position(1, 2), Position(2, 1)],
@@ -64,13 +70,14 @@ def __init__(self):
         }
         self.move(0, 3)
 
+
 class ZBlock(Block):
-    def __init__(self):
-        super().__init__(id = 7)
+    def __init__(self) -> None:
+        super().__init__(id=7)
         self.cells = {
             0: [Position(0, 0), Position(0, 1), Position(1, 1), Position(1, 2)],
             1: [Position(0, 2), Position(1, 1), Position(1, 2), Position(2, 1)],
             2: [Position(1, 0), Position(1, 1), Position(2, 1), Position(2, 2)],
             3: [Position(0, 1), Position(1, 0), Position(1, 1), Position(2, 0)]
         }
-        self.move(0, 3)
+        self.move(0, 3)

colors.py

@@ -1,16 +1,16 @@
 class Colors:
-	dark_grey = (26, 31, 40)
-	green = (47, 230, 23)
-	red = (232, 18, 18)
-	orange = (226, 116, 17)
-	yellow = (237, 234, 4)
-	purple = (166, 0, 247)
-	cyan = (21, 204, 209)
-	blue = (13, 64, 216)
-	white = (255, 255, 255)
-	dark_blue = (44, 44, 127)
-	light_blue = (59, 85, 162)
+    dark_grey: tuple[int, int, int] = (26, 31, 40)
+    green: tuple[int, int, int] = (47, 230, 23)
+    red: tuple[int, int, int] = (232, 18, 18)
+    orange: tuple[int, int, int] = (226, 116, 17)
+    yellow: tuple[int, int, int] = (237, 234, 4)
+    purple: tuple[int, int, int] = (166, 0, 247)
+    cyan: tuple[int, int, int] = (21, 204, 209)
+    blue: tuple[int, int, int] = (13, 64, 216)
+    white: tuple[int, int, int] = (255, 255, 255)
+    dark_blue: tuple[int, int, int] = (44, 44, 127)
+    light_blue: tuple[int, int, int] = (59, 85, 162)
 
-	@classmethod
-	def get_cell_colors(cls):
-		return [cls.dark_grey, cls.green, cls.red, cls.orange, cls.yellow, cls.purple, cls.cyan, cls.blue]
+    @classmethod
+    def get_cell_colors(cls) -> list[tuple[int, int, int]]:
+        return [cls.dark_grey, cls.green, cls.red, cls.orange, cls.yellow, cls.purple, cls.cyan, cls.blue]

game.py

@@ -1,102 +1,104 @@
 from grid import Grid
-from blocks import *
+from blocks import IBlock, JBlock, LBlock, OBlock, SBlock, TBlock, ZBlock
+from block import Block
 import random
 import pygame
 
+
 class Game:
-	def __init__(self):
-		self.grid = Grid()
-		self.blocks = [IBlock(), JBlock(), LBlock(), OBlock(), SBlock(), TBlock(), ZBlock()]
-		self.current_block = self.get_random_block()
-		self.next_block = self.get_random_block()
-		self.game_over = False
-		self.score = 0
-		self.rotate_sound = pygame.mixer.Sound("Sounds/rotate.ogg")
-		self.clear_sound = pygame.mixer.Sound("Sounds/clear.ogg")
+    def __init__(self) -> None:
+        self.grid: Grid = Grid()
+        self.blocks: list[Block] = [IBlock(), JBlock(), LBlock(), OBlock(), SBlock(), TBlock(), ZBlock()]
+        self.current_block: Block = self.get_random_block()
+        self.next_block: Block = self.get_random_block()
+        self.game_over: bool = False
+        self.score: int = 0
+        self.rotate_sound: pygame.mixer.Sound = pygame.mixer.Sound("Sounds/rotate.ogg")
+        self.clear_sound: pygame.mixer.Sound = pygame.mixer.Sound("Sounds/clear.ogg")
 
-		pygame.mixer.music.load("Sounds/music.ogg")
-		pygame.mixer.music.play(-1)
+        pygame.mixer.music.load("Sounds/music.ogg")
+        pygame.mixer.music.play(-1)
 
-	def update_score(self, lines_cleared, move_down_points):
-		if lines_cleared == 1:
-			self.score += 100
-		elif lines_cleared == 2:
-			self.score += 300
-		elif lines_cleared == 3:
-			self.score += 500
-		self.score += move_down_points
+    def update_score(self, lines_cleared: int, move_down_points: int) -> None:
+        if lines_cleared == 1:
+            self.score += 100
+        elif lines_cleared == 2:
+            self.score += 300
+        elif lines_cleared == 3:
+            self.score += 500
+        self.score += move_down_points
 
-	def get_random_block(self):
-		if len(self.blocks) == 0:
-			self.blocks = [IBlock(), JBlock(), LBlock(), OBlock(), SBlock(), TBlock(), ZBlock()]
-		block = random.choice(self.blocks)
-		self.blocks.remove(block)
-		return block
+    def get_random_block(self) -> Block:
+        if len(self.blocks) == 0:
+            self.blocks = [IBlock(), JBlock(), LBlock(), OBlock(), SBlock(), TBlock(), ZBlock()]
+        block = random.choice(self.blocks)
+        self.blocks.remove(block)
+        return block
 
-	def move_left(self):
-		self.current_block.move(0, -1)
-		if self.block_inside() == False or self.block_fits() == False:
-			self.current_block.move(0, 1)
+    def move_left(self) -> None:
+        self.current_block.move(0, -1)
+        if not self.block_inside() or not self.block_fits():
+            self.current_block.move(0, 1)
 
-	def move_right(self):
-		self.current_block.move(0, 1)
-		if self.block_inside() == False or self.block_fits() == False:
-			self.current_block.move(0, -1)
+    def move_right(self) -> None:
+        self.current_block.move(0, 1)
+        if not self.block_inside() or not self.block_fits():
+            self.current_block.move(0, -1)
 
-	def move_down(self):
-		self.current_block.move(1, 0)
-		if self.block_inside() == False or self.block_fits() == False:
-			self.current_block.move(-1, 0)
-			self.lock_block()
+    def move_down(self) -> None:
+        self.current_block.move(1, 0)
+        if not self.block_inside() or not self.block_fits():
+            self.current_block.move(-1, 0)
+            self.lock_block()
 
-	def lock_block(self):
-		tiles = self.current_block.get_cell_positions()
-		for position in tiles:
-			self.grid.grid[position.row][position.column] = self.current_block.id
-		self.current_block = self.next_block
-		self.next_block = self.get_random_block()
-		rows_cleared = self.grid.clear_full_rows()
-		if rows_cleared > 0:
-			self.clear_sound.play()
-			self.update_score(rows_cleared, 0)
-		if self.block_fits() == False:
-			self.game_over = True
+    def lock_block(self) -> None:
+        tiles = self.current_block.get_cell_positions()
+        for position in tiles:
+            self.grid.grid[position.row][position.column] = self.current_block.id
+        self.current_block = self.next_block
+        self.next_block = self.get_random_block()
+        rows_cleared = self.grid.clear_full_rows()
+        if rows_cleared > 0:
+            self.clear_sound.play()
+            self.update_score(rows_cleared, 0)
+        if not self.block_fits():
+            self.game_over = True
 
-	def reset(self):
-		self.grid.reset()
-		self.blocks = [IBlock(), JBlock(), LBlock(), OBlock(), SBlock(), TBlock(), ZBlock()]
-		self.current_block = self.get_random_block()
-		self.next_block = self.get_random_block()
-		self.score = 0
+    def reset(self) -> None:
+        self.grid.reset()
+        self.blocks = [IBlock(), JBlock(), LBlock(), OBlock(), SBlock(), TBlock(), ZBlock()]
+        self.current_block = self.get_random_block()
+        self.next_block = self.get_random_block()
+        self.score = 0
 
-	def block_fits(self):
-		tiles = self.current_block.get_cell_positions()
-		for tile in tiles:
-			if self.grid.is_empty(tile.row, tile.column) == False:
-				return False
-		return True
+    def block_fits(self) -> bool:
+        tiles = self.current_block.get_cell_positions()
+        for tile in tiles:
+            if not self.grid.is_empty(tile.row, tile.column):
+                return False
+        return True
 
-	def rotate(self):
-		self.current_block.rotate()
-		if self.block_inside() == False or self.block_fits() == False:
-			self.current_block.undo_rotation()
-		else:
-			self.rotate_sound.play()
+    def rotate(self) -> None:
+        self.current_block.rotate()
+        if not self.block_inside() or not self.block_fits():
+            self.current_block.undo_rotation()
+        else:
+            self.rotate_sound.play()
 
-	def block_inside(self):
-		tiles = self.current_block.get_cell_positions()
-		for tile in tiles:
-			if self.grid.is_inside(tile.row, tile.column) == False:
-				return False
-		return True
+    def block_inside(self) -> bool:
+        tiles = self.current_block.get_cell_positions()
+        for tile in tiles:
+            if not self.grid.is_inside(tile.row, tile.column):
+                return False
+        return True
 
-	def draw(self, screen):
-		self.grid.draw(screen)
-		self.current_block.draw(screen, 11, 11)
+    def draw(self, screen: pygame.Surface) -> None:
+        self.grid.draw(screen)
+        self.current_block.draw(screen, 11, 11)
 
-		if self.next_block.id == 3:
-			self.next_block.draw(screen, 255, 290)
-		elif self.next_block.id == 4:
-			self.next_block.draw(screen, 255, 280)
-		else:
-			self.next_block.draw(screen, 270, 270)
+        if self.next_block.id == 3:
+            self.next_block.draw(screen, 255, 290)
+        elif self.next_block.id == 4:
+            self.next_block.draw(screen, 255, 280)
+        else:
+            self.next_block.draw(screen, 270, 270)