fix: norme flake8

Author: ltuffery

api/entity/apple.py

@@ -57,8 +57,8 @@ def is_red(self) -> bool:
 
     def get_char(self) -> str:
         """
-        Returns a character representation of the apple, colored based on its
-        type.
+        Returns a character representation of the apple, colored based on
+        its type.
 
         Returns:
             str: A string representing the apple with appropriate color
@@ -68,7 +68,13 @@ def get_char(self) -> str:
             return "\033[32m@\033[0m"  # Green apple
 
         return "\033[31m@\033[0m"  # Red apple
-    
+
     def consume(self):
+        """
+        Removes the apple from the world and respawns it.
+
+        The apple is removed from the world and then spawned again at the
+        same location.
+        """
         self.__world.remove_entity(self)
         self.__world.spawn_entity(self)

api/entity/entity.py

@@ -65,8 +65,15 @@ def set_y(self, y: int) -> None:
             y (int): The new Y-coordinate.
         """
         self.__y = y
-    
+
     def teleport(self, x: int, y: int) -> None:
+        """
+        Teleports the entity to a new position (x, y).
+
+        Args:
+            x (int): The new X-coordinate.
+            y (int): The new Y-coordinate.
+        """
         self.__x = x
         self.__y = y
 

api/entity/snake.py

@@ -4,6 +4,7 @@
 from api.world import World
 from api.entity.entity import Entity
 import random
+from collections import deque
 
 
 class Snake(Entity):
@@ -12,12 +13,12 @@ class Snake(Entity):
     world.
 
     Attributes:
-        __x (int): The X-coordinate of the snake's head.
-        __y (int): The Y-coordinate of the snake's head.
-        __body (list[tuple[int, int]]): A list representing the snake's body
-            segments.
-        __world (World): The game world where the snake exists.
-        __last_direction (Direction): The last movement direction of the snake.
+        __body (deque[tuple[int, int]]):
+            Deque of tuples representing the snake's body segments.
+        __world (World):
+            The game world where the snake exists.
+        __last_direction (Direction):
+            The last movement direction of the snake.
     """
 
     def __init__(self, world: World, x: int, y: int, direction: Direction):
@@ -33,7 +34,7 @@ def __init__(self, world: World, x: int, y: int, direction: Direction):
         """
         super().__init__(x, y)
 
-        self.__body: list[tuple[int, int]] = []
+        self.__body: deque[tuple[int, int]] = deque()
         self.__world: World = world
         self.__last_direction: Direction = direction
 
@@ -44,57 +45,67 @@ def __init__(self, world: World, x: int, y: int, direction: Direction):
             x += dir_x
             y += dir_y
             self.__body.append((x, y))
-    
-    def teleport(self, x, y):
-        super().teleport(x, y)
 
-        for i in range(len(self.__body)):
-            del self.__body[i]
+    def teleport(self, x: int, y: int) -> None:
+        """
+        Teleports the snake to a new position and resets its body direction.
+
+        Args:
+            x (int): The new X position.
+            y (int): The new Y position.
+        """
+        super().teleport(x, y)
 
-            self.__last_direction = random.choice([ x for x in list(Direction) if x.name != self.__last_direction.name ])
+        new_body = deque()
+        for _ in range(len(self.__body)):
+            dir_name = self.__last_direction.name
+            self.__last_direction = random.choice([
+                d for d in list(Direction) if d.name != dir_name
+            ])
             dir_x, dir_y = self.__last_direction.value
 
             x += dir_x
             y += dir_y
 
-            self.__body.insert(i, (x, y))
+            new_body.append((x, y))
 
-    def move(self, direction: Direction):
+        self.__body = new_body
+
+    def move(self, direction: Direction) -> None:
         """
         Moves the snake in the given direction. If the new location is not
         passable, the game ends.
 
         Args:
             direction (Direction): The direction in which the snake should
-                move.
+            move.
 
         Raises:
             GameOver: If the snake collides with an obstacle or itself.
         """
         x, y = direction.value
-        info = self.__world.get_location(self.get_x() + x, self.get_y() + y)
-
-        if info.is_wall():
-            raise GameOver("End game")
+        new_x = self.get_x() + x
+        new_y = self.get_y() + y
+        info = self.__world.get_location(new_x, new_y)
 
-        if (self.get_x() + x, self.get_y() + y) in self.__body:
+        if info.is_wall() or (new_x, new_y) in self.__body:
             raise GameOver("End game")
 
         if isinstance(info.get_entity(), Apple):
             self.eat(info.get_entity())
 
-        self.set_x(self.get_x() + x)
-        self.set_y(self.get_y() + y)
+        self.set_x(new_x)
+        self.set_y(new_y)
         self.__last_direction = direction
 
         # Move the body segments following the head
-        self.__body.insert(0, (self.get_x() - x, self.get_y() - y))
-        del self.__body[-1]
+        self.__body.appendleft((self.get_x() - x, self.get_y() - y))
+        self.__body.pop()
 
-    def eat(self, apple: Apple):
+    def eat(self, apple: Apple) -> None:
         """
-        Handles the snake eating an apple. The snake grows if the apple is
-        green, otherwise, it loses a segment.
+        Handles the snake eating an apple.
+        The snake grows if the apple is green, otherwise, it loses a segment.
 
         Args:
             apple (Apple): The apple that the snake is eating.
@@ -109,12 +120,12 @@ def eat(self, apple: Apple):
             # Grow the snake by adding a new body segment
             self.__body.append((last_body[0] + x, last_body[1] + y))
         else:
-            if len(self.__body) == 0:
+            if not self.__body:
                 raise GameOver("End game")
 
             # Remove the last body segment
-            del self.__body[-1]
-        
+            self.__body.pop()
+
         apple.consume()
 
     def size(self) -> int:
@@ -127,33 +138,33 @@ def size(self) -> int:
         """
         return len(self.__body) + 1
 
-    def get_body(self) -> list[tuple[int, int]]:
+    def get_body(self) -> deque[tuple[int, int]]:
         """
         Returns the list of body segments of the snake.
 
         Returns:
-            list[tuple[int, int]]: The body segments of the snake.
+            deque[tuple[int, int]]: The body segments of the snake.
         """
         return self.__body
 
     def get_char(self) -> str:
         """
-        Returns the character representation of the snake, colored for
-        terminal output.
+        Returns the character representation of the snake, colored for terminal
+        output.
 
         Returns:
             str: A string representing the snake, colored in yellow.
         """
         return "\033[33m#\033[0m"
 
-    def render(self):
+    def render(self) -> list[tuple[str, int, int]]:
         """
         Renders the snake and its body in the world.
 
         Returns:
-            list: A list containing the snake's head and body positions.
+            list[tuple[str, int, int]]: A list containing the snake's head and
+            body positions.
         """
         render = super().render()
-        [render.append(("#", body[0], body[1])) for body in self.__body]
-
+        render.extend(("#", body[0], body[1]) for body in self.__body)
         return render

api/world.py

@@ -68,8 +68,15 @@ def get_location(self, x: int, y: int) -> MapLocation:
         is_wall = self.__world[y][x] == '*'
 
         return MapLocation(x, y, is_wall, self.get_entity_at(x, y))
-    
+
     def get_empty_locations(self) -> list[tuple[int, int]]:
+        """
+        Retrieves a list of all empty locations in the world.
+
+        Returns:
+            list[tuple[int, int]]: A list of coordinates (x, y) where there
+            are no entities.
+        """
         empty_list = []
 
         for y in range(len(self.__world)):
@@ -94,7 +101,7 @@ def get_entity_at(self, x: int, y: int) -> Entity | None:
 
         Returns:
             object | None: The entity found at the coordinates, or None if
-                empty.
+            empty.
         """
         for entity in self.__entities:
             if entity.get_x() == x and entity.get_y() == y:
@@ -115,6 +122,12 @@ def spawn_entity(self, entity: Entity) -> None:
         self.__entities.append(entity)
 
     def remove_entity(self, entity: Entity):
+        """
+        Removes an entity from the world.
+
+        Args:
+            entity (Entity): The entity to remove.
+        """
         self.__entities.remove(entity)
 
     def render(self):