General Code Quality & formatting

Author: MyreMylar

pygame_gui/_constants.py

@@ -40,8 +40,7 @@ class OldType(int):
     all the old events.
     """
     def __new__(cls, x,  *args, **kwargs):
-        instance = int.__new__(cls, x, *args, **kwargs)
-        return instance
+        return int.__new__(cls, x, *args, **kwargs)
 
     def __eq__(self, other):
         warn("Pygame GUI event types can now "

pygame_gui/core/colour_gradient.py

@@ -59,14 +59,22 @@ def __str__(self) -> str:
 
         :return: The string representation.
         """
-        result = (str(self.angle_direction) + '_' +
-                  str(self.colour_1.r) + '_' + str(self.colour_1.g) + '_' +
-                  str(self.colour_1.b) + '_' + str(self.colour_1.a) + '_' +
-                  str(self.colour_2.r) + '_' + str(self.colour_2.g) + '_' +
-                  str(self.colour_2.b) + '_' + str(self.colour_2.a))
+        result = (f'{str(self.angle_direction)}_'
+                  f'{str(self.colour_1.r)}_'
+                  f'{str(self.colour_1.g)}_'
+                  f'{str(self.colour_1.b)}_'
+                  f'{str(self.colour_1.a)}_'
+                  f'{str(self.colour_2.r)}_'
+                  f'{str(self.colour_2.g)}_'
+                  f'{str(self.colour_2.b)}_'
+                  f'{str(self.colour_2.a)}')
+
         if self.colour_3 is not None:
-            result += ('_' + str(self.colour_3.r) + '_' + str(self.colour_3.g) +
-                       '_' + str(self.colour_3.b) + '_' + str(self.colour_3.a))
+            result += (
+                f'_{str(self.colour_3.r)}_'
+                f'{str(self.colour_3.g)}_'
+                f'{str(self.colour_3.b)}_'
+                f'{str(self.colour_3.a)}')
 
         return result
 

pygame_gui/core/colour_parser.py

@@ -107,13 +107,9 @@ def collide_point(self, point: Union[pygame.math.Vector2,
         :return: True if the point is inside the shape.
 
         """
-        collided = False
         x_val = ((point[0] - self.ellipse_center[0]) ** 2) / (self.ellipse_half_diameters[0] ** 2)
         y_val = ((point[1] - self.ellipse_center[1]) ** 2) / (self.ellipse_half_diameters[1] ** 2)
-        if (x_val + y_val) < 1:
-            collided = True
-
-        return collided
+        return x_val + y_val < 1
 
     def set_dimensions(self, dimensions: Union[pygame.math.Vector2,
                                                Tuple[int, int],
@@ -167,11 +163,11 @@ def redraw_state(self, state_str: str, add_text: bool = True):
             self.states[state_str].surface = self.ui_manager.get_universal_empty_surface()
         else:
 
-            border_colour_state_str = state_str + '_border'
-            bg_colour_state_str = state_str + '_bg'
-            text_colour_state_str = state_str + '_text'
-            text_shadow_colour_state_str = state_str + '_text_shadow'
-            image_state_str = state_str + '_image'
+            border_colour_state_str = f'{state_str}_border'
+            bg_colour_state_str = f'{state_str}_bg'
+            text_colour_state_str = f'{state_str}_text'
+            text_shadow_colour_state_str = f'{state_str}_text_shadow'
+            image_state_str = f'{state_str}_image'
             border_overlap = 0
             if 'border_overlap' in self.theming:
                 border_overlap = self.theming['border_overlap']

pygame_gui/core/drawable_shapes/drawable_shape.py

@@ -174,11 +174,11 @@ def redraw_state(self, state_str: str, add_text: bool = True):
         if self.containing_rect.width <= 0 or self.containing_rect.height <= 0:
             self.states[state_str].surface = self.ui_manager.get_universal_empty_surface()
         else:
-            border_colour_state_str = state_str + '_border'
-            bg_colour_state_str = state_str + '_bg'
-            text_colour_state_str = state_str + '_text'
-            text_shadow_colour_state_str = state_str + '_text_shadow'
-            image_state_str = state_str + '_image'
+            border_colour_state_str = f'{state_str}_border'
+            bg_colour_state_str = f'{state_str}_bg'
+            text_colour_state_str = f'{state_str}_text'
+            text_shadow_colour_state_str = f'{state_str}_text_shadow'
+            image_state_str = f'{state_str}_image'
 
             found_shape = None
             shape_id = None

pygame_gui/core/drawable_shapes/ellipse_drawable_shape.py

@@ -66,10 +66,9 @@ def full_rebuild_on_size_change(self):
         super().full_rebuild_on_size_change()
 
         self.base_surface = None
-        self.temp_additive_shape = None
         self.temp_subtractive_shape = None
         self.temp_shadow_subtractive_shape = None
-
+        self.temp_additive_shape = None
         # clamping border, shadow widths and corner radii, so we can't form impossible shapes
         # having impossible values here will also mean the shadow pre-generating system fails
         # leading to slow down when creating elements
@@ -79,12 +78,13 @@ def full_rebuild_on_size_change(self):
             self.shadow_width = min(math.floor(self.containing_rect.width / 2),
                                     math.floor(self.containing_rect.height / 2))
             warnings.warn(
-                'Clamping shadow_width of: ' + str(old_width) + ', to: ' + str(self.shadow_width))
+                f'Clamping shadow_width of: {str(old_width)}, to: {str(self.shadow_width)}'
+            )
 
         if self.shadow_width < 0:
             old_width = self.shadow_width
             self.shadow_width = 0
-            warnings.warn('Clamping shadow_width of: ' + str(old_width) + ', to: ' + str(0))
+            warnings.warn(f'Clamping shadow_width of: {str(old_width)}, to: 0')
 
         if self.border_width > min(math.floor((self.containing_rect.width -
                                                (self.shadow_width * 2)) / 2),
@@ -95,13 +95,13 @@ def full_rebuild_on_size_change(self):
                                                 (self.shadow_width * 2)) / 2),
                                     math.floor((self.containing_rect.height -
                                                 (self.shadow_width * 2)) / 2))
-            warnings.warn('Clamping border_width of: ' +
-                          str(old_width) + ', to: ' +
-                          str(self.border_width))
+            warnings.warn(
+                f'Clamping border_width of: {str(old_width)}, to: {str(self.border_width)}'
+            )
         if self.border_width < 0:
             old_width = self.border_width
             self.border_width = 0
-            warnings.warn('Clamping border_width of: ' + str(old_width) + ', to: ' + str(0))
+            warnings.warn(f'Clamping border_width of: {str(old_width)}, to: 0')
 
         corner_radii = self.theming['shape_corner_radius']
         if self.shadow_width > 0:
@@ -120,12 +120,12 @@ def full_rebuild_on_size_change(self):
                                        self.click_area_shape.height / 2):
                     corner_radius = int(min(self.click_area_shape.width / 2,
                                             self.click_area_shape.height / 2))
-                    warnings.warn('Clamping shape_corner_radius of: ' +
-                                  str(old_radius) + ', to: ' + str(corner_radius))
+                    warnings.warn(
+                        f'Clamping shape_corner_radius of: {str(old_radius)}, to: {corner_radius}'
+                    )
                 if corner_radius < 0:
                     corner_radius = 0
-                    warnings.warn('Clamping shape_corner_radius of: ' +
-                                  str(old_radius) + ', to: ' + str(0))
+                    warnings.warn(f'Clamping shape_corner_radius of: {str(old_radius)}, to: 0')
                 self.shape_corner_radius[i] = corner_radius
 
             shadow = self.ui_manager.get_shadow(self.containing_rect.size,
@@ -326,10 +326,10 @@ def redraw_state(self, state_str: str, add_text: bool = True):
         if self.containing_rect.width <= 0 or self.containing_rect.height <= 0:
             self.states[state_str].surface = self.ui_manager.get_universal_empty_surface()
         else:
-            text_colour_state_str = state_str + '_text'
-            text_shadow_colour_state_str = state_str + '_text_shadow'
-            bg_col = self.theming[state_str + '_bg']
-            border_col = self.theming[state_str + '_border']
+            text_colour_state_str = f'{state_str}_text'
+            text_shadow_colour_state_str = f'{state_str}_text_shadow'
+            bg_col = self.theming[f'{state_str}_bg']
+            border_col = self.theming[f'{state_str}_border']
             border_overlap = 0
             if 'border_overlap' in self.theming:
                 border_overlap = self.theming['border_overlap']
@@ -425,9 +425,13 @@ def redraw_state(self, state_str: str, add_text: bool = True):
                                                           shape_id)
                     self.states[state_str].cached_background_id = shape_id
 
-            self.finalise_images_and_text(state_str + '_image', state_str,
-                                          text_colour_state_str,
-                                          text_shadow_colour_state_str, add_text)
+            self.finalise_images_and_text(
+                f'{state_str}_image',
+                state_str,
+                text_colour_state_str,
+                text_shadow_colour_state_str,
+                add_text,
+            )
 
         self.states[state_str].has_fresh_surface = True
         self.states[state_str].generated = True
@@ -541,25 +545,22 @@ def create_subtract_surface(self,
         surface to leave a transparent hole in it.
 
         """
-        if subtract_size[0] > 0 and subtract_size[1] > 0:
-            if self.temp_subtractive_shape is None:
-                # for the subtract surface we want to blend in all RGBA channels to clear
-                # correctly for our new shape
-                self.temp_subtractive_shape = pygame.surface.Surface(subtract_size,
-                                                                     flags=pygame.SRCALPHA,
-                                                                     depth=32)
-                clear_colour = '#00000000'
-                self.temp_subtractive_shape.fill(pygame.Color(clear_colour))
-                RoundedRectangleShape.draw_colourless_rounded_rectangle(corner_radii,
-                                                                        self.temp_subtractive_shape,
-                                                                        int(aa_amount / 2))
-                large_sub_surface = self.temp_subtractive_shape
-            else:
-                large_sub_surface = pygame.transform.scale(self.temp_subtractive_shape,
-                                                           subtract_size)
-
-            return large_sub_surface
-        return None
+        if subtract_size[0] <= 0 or subtract_size[1] <= 0:
+            return None
+        if self.temp_subtractive_shape is not None:
+            return pygame.transform.scale(
+                self.temp_subtractive_shape, subtract_size
+            )
+        # for the subtract surface we want to blend in all RGBA channels to clear
+        # correctly for our new shape
+        self.temp_subtractive_shape = pygame.surface.Surface(subtract_size,
+                                                             flags=pygame.SRCALPHA,
+                                                             depth=32)
+        self.temp_subtractive_shape.fill(pygame.Color('#00000000'))
+        RoundedRectangleShape.draw_colourless_rounded_rectangle(
+            corner_radii, self.temp_subtractive_shape, aa_amount // 2
+        )
+        return self.temp_subtractive_shape
 
     @staticmethod
     def draw_colourless_rounded_rectangle(large_corner_radius: List[int],

pygame_gui/core/drawable_shapes/rect_drawable_shape.py

@@ -81,7 +81,7 @@ def get_padding_height(self):
         # font.pad adds to the top of text excluding
         # any padding added to make glyphs even - this is useful
         # for 'base-line centering' when we want to center text
-        # that doesn't drop below the base line (no y's, g's, p's etc)
+        # that doesn't drop below the baseline (no y's, g's, p's etc.)
         # but also don't want it to flicker on and off. Base-line
         # centering is the default for chunks on a single style row.
 

pygame_gui/core/drawable_shapes/rounded_rect_drawable_shape.py

@@ -67,7 +67,7 @@ def get_point_size(self):
 
     def get_rect(self, text: str) -> Rect:
         # only way to get accurate font layout data with kerning is to render it ourselves it seems
-        if len(text) > 0:
+        if text != "":
             text_surface = self.__internal_font.render(text, self.antialiased, pygame.Color("white"))
             ascent = self.__internal_font.get_ascent()
             return pygame.Rect((0, ascent), text_surface.get_size())
@@ -102,7 +102,7 @@ def get_padding_height(self):
         # font.pad adds to the top of text excluding
         # any padding added to make glyphs even - this is useful
         # for 'base-line centering' when we want to center text
-        # that doesn't drop below the base line (no y's, g's, p's etc)
+        # that doesn't drop below the baseline (no y's, g's, p's etc.)
         # but also don't want it to flicker on and off. Base-line
         # centering is the default for chunks on a single style row.
 
@@ -115,5 +115,3 @@ def get_direction(self) -> int:
         :return:
         """
         return self.direction
-
-

pygame_gui/core/gui_font_freetype.py

@@ -7,9 +7,17 @@
 
 
 class SpriteWithHealth(Protocol):
+    """
+    A protocol for sprites that have health. This protocol defines the required attributes for
+    sprites that have health, including current health, health capacity, rect, and image.
+
+    Attributes:
+        current_health: The current health of the sprite.
+        health_capacity: The maximum health of the sprite.
+        rect: The rectangular area of the sprite.
+        image: The image of the sprite.
+    """
     current_health: int
     health_capacity: int
     rect: Rect
     image: Surface
-
-

pygame_gui/core/gui_font_pygame.py

@@ -14,7 +14,7 @@
 
 class IUIAppearanceThemeInterface(metaclass=ABCMeta):
     """
-    A meta class that defines the interface that a UI Appearance Theme uses.
+    A metaclass that defines the interface that a UI Appearance Theme uses.
 
     Interfaces like this help us evade cyclical import problems by allowing us to define the
     actual manager class later on and have it make use of the classes that use the interface.
@@ -89,7 +89,7 @@ def get_font_info(self, combined_element_ids: List[str]) -> Dict[str, Any]:
         """
         Uses some data about a UIElement to get font data as dictionary
 
-        :param combined_element_ids: A list of IDs representing an element's location in a
+        :param combined_element_ids: A list of IDs representing an element's location in an
                                      interleaved hierarchy of elements.
 
         :return dictionary: Data about the font requested
@@ -100,7 +100,7 @@ def get_font(self, combined_element_ids: List[str]) -> IGUIFontInterface:
         """
         Uses some data about a UIElement to get a font object.
 
-        :param combined_element_ids: A list of IDs representing an element's location in a
+        :param combined_element_ids: A list of IDs representing an element's location in an
                                      interleaved hierarchy of elements.
 
         :return IGUIFontInterface: An interface to a pygame font object wrapper.
@@ -113,7 +113,7 @@ def get_misc_data(self, misc_data_id: str, combined_element_ids: List[str]) -> U
         theming data. Raises an exception if it can't find the data requested, UI elements
         requesting optional data will need to handle this exception.
 
-        :param combined_element_ids: A list of IDs representing an element's location in a
+        :param combined_element_ids: A list of IDs representing an element's location in an
                                      interleaved hierarchy of elements.
         :param misc_data_id: The id for the specific piece of miscellaneous data we are looking for.
 

pygame_gui/core/gui_type_hints.py

@@ -6,7 +6,7 @@
 
 class IColourGradientInterface(metaclass=ABCMeta):
     """
-    A meta class that defines the interface that a colour gradient uses.
+    A metaclass that defines the interface that a colour gradient uses.
 
     Interfaces like this help us evade cyclical import problems by allowing us to define the
     actual manager class later on and have it make use of the classes that use the interface.

pygame_gui/core/interfaces/appearance_theme_interface.py

@@ -26,7 +26,7 @@ def get_rect(self) -> pygame.Rect:
     @abstractmethod
     def add_element(self, element: IUIElementInterface):
         """
-        Add a UIElement to the container. The UI's relative_rect parameter will be relative to
+        Add a UIElement to the container. The element's relative_rect parameter will be relative to
         this container.
 
         :param element: A UIElement to add to this container.

pygame_gui/core/interfaces/colour_gradient_interface.py

@@ -1,5 +1,5 @@
 from abc import ABCMeta, abstractmethod
-from typing import Tuple, Union, List, Set, Any, Dict
+from typing import Union, List, Set, Any, Dict
 
 import pygame
 
@@ -19,7 +19,7 @@ class IUIElementInterface(IGUISpriteInterface, metaclass=ABCMeta):
     @abstractmethod
     def hovered(self) -> bool:
         """
-        Are we hovering over this element with the mouse pointer or other input highlighting method.
+        Returns True if we are hovering over this element with the mouse pointer, or other input highlighting method.
 
         :return: True if hovered.
         """

pygame_gui/core/interfaces/container_interface.py

@@ -23,7 +23,9 @@ def render_premul(self, text: str, text_color: Color) -> Surface:
         Draws text to a surface ready for pre-multiplied alpha-blending
         """
 
-    def render_premul_to(self, text: str, text_colour: Color, surf_size: Tuple[int, int], surf_position: Tuple[int, int]):
+    def render_premul_to(self, text: str, text_colour: Color,
+                         surf_size: Tuple[int, int],
+                         surf_position: Tuple[int, int]):
         """