Pylint processing

Author: MyreMylar

pygame_gui/core/colour_parser.py

@@ -27,11 +27,10 @@
         of any additions to this parser TL,DR: Dev life will be easier if it is ensured that commas in colour schemas
         are inside of parentheses, brackets, or curly braces (like "rgb(20, 20, 20)")"""
 
-import pygame
+import enum
 from typing import (
     Callable,
     Union,
-    Iterable,
     TypeVar,
     Optional,
     List,
@@ -41,7 +40,8 @@
     TypedDict,
 )
 
-import enum
+import pygame
+
 from pygame_gui.core.colour_gradient import ColourGradient
 from pygame_gui.core.utility import premul_col
 from pygame_gui._constants import _namedColours
@@ -61,6 +61,13 @@ class NumParserType(enum.Enum):
 
 
 def is_num_str(string: str) -> bool:
+    """
+    Check if a string converts to a number.
+
+    :param string: the string to check
+
+    :return: A boolean, True if the string converts to a number, False otherwise
+    """
     try:
         float(string)
         return True
@@ -69,14 +76,36 @@ def is_num_str(string: str) -> bool:
 
 
 def is_int_str(string: str) -> bool:
+    """
+    Check if a string converts to a round number.
+
+    :param string: the string to check
+
+    :return: A boolean, True if the string converts to a non-fractional number, False otherwise
+    """
     return is_num_str(string) and "." not in string
 
 
 def is_float_str(string: str):
+    """
+    Check if a string converts to a fractional number.
+
+    :param string: the string to check
+
+    :return: A boolean, True if the string converts to a fractional number, False otherwise
+    """
     return is_num_str(string) and "." in string
 
 
 def is_degree_string(strdata: str) -> bool:
+    """
+    Check if a string converts to a degree. This means that it either ends 'deg' and the rest is an integer number
+    between -360 and 360; or it is just an integer number between -360 and 360.
+
+    :param strdata: the string to check
+
+    :return: A boolean, True if the string converts to a degree, False otherwise
+    """
     if strdata != "":
         if strdata.endswith("deg") and len(strdata) > 3:
             if is_int_str(strdata[:-3]):
@@ -89,30 +118,73 @@ def is_degree_string(strdata: str) -> bool:
 
 
 def parse_degree_string(strdata: str) -> int:
+    """
+    Converts a string to a degree integer. This means that it either ends 'deg' and the rest is an integer number
+    between -360 and 360; or it is just an integer number between -360 and 360.
+
+    Should be used with 'is_degree_string()' to check for validity.
+
+    :param strdata: the string to parse.
+
+    :return: an integer between -360 and 360
+    """
     if strdata != "":
         return int(strdata[:-3]) if strdata.endswith("deg") else int(strdata)
+    return 0
 
 
 def is_percentage_string(strdata: str) -> bool:
+    """
+    Check if a string converts to a percentage. This means that it either ends '%' and the rest is an integer number;
+    or it is a float number between 0.0 and 1.0.
+
+    :param strdata: the string to check
+
+    :return: A boolean, True if the string converts to a percentage, False otherwise
+    """
     if strdata != "":
         if strdata[-1] == "%" and is_int_str(strdata[:-1]):
             return True
 
         if is_float_str(strdata):
             float_value = float(strdata)
-            return 0 <= float_value <= 1
+            return 0.0 <= float_value <= 1.0
     return False
 
 
 def parse_percentage_string(strdata: str) -> float:
+    """
+    returns a percentage float value between 0.0 and 1.0 parsed from the input string.
+
+    Should be used in conjunction with is_percentage_string()
+
+    :param strdata: the string to parse
+
+    :return: a float between 0.0 and 1.0
+    """
     return float(strdata) if is_float_str(strdata) else float(strdata[:-1]) / 100
 
 
 def is_u8_string(strdata: str) -> bool:
+    """
+    Checks if the string can be converted to an integer between 0 and 255.
+
+    :param strdata: the string to parse
+    :return: a boolean - True if the string can convert to an integer between 0 and 255
+    """
     return is_int_str(strdata) and 0 <= int(strdata) <= 255
 
 
 def parse_u8_string(strdata: str) -> int:
+    """
+    Parse the input string to an integer (between 0 and 255).
+
+    Should be used in conjunction with is_u8_string()
+
+    :param strdata: the string to parse
+
+    :return: an integer between 0 and 255
+    """
     return int(strdata)
 
 
@@ -121,6 +193,11 @@ def parse_u8_string(strdata: str) -> int:
 
 
 class ColourValueParserData(TypedDict):
+    """
+    A class that groups together parsers and validators for turning strings into numerical values for colours.
+
+    """
+
     validator: ColourValueValidator
     parser: ColourValueParser
 
@@ -137,9 +214,9 @@ class ColourValueParserData(TypedDict):
     },
     NumParserType.FLOAT: {
         "validator": is_float_str,
-        "parser": lambda string: float(string),
+        "parser": float,
     },
-    NumParserType.INT: {"validator": is_int_str, "parser": lambda string: int(string)},
+    NumParserType.INT: {"validator": is_int_str, "parser": int},
 }
 """A mapping for each NumParserType to its corresponding validator and parser for strings of that type's 
 specification"""
@@ -669,8 +746,7 @@ def get_commas_outside_enclosing_glyphs(strdata: str) -> List[int]:
     opening_stack = []
     comma_indices_outside_parentheses: List[int] = []
 
-    for i in range(len(strdata)):
-        ch = strdata[i]
+    for i, ch in enumerate(strdata):
         if ch == "," and not opening_stack:
             comma_indices_outside_parentheses.append(i)
         if ch in glyphs.values():
@@ -720,9 +796,9 @@ def split_string_at_indices(
 
     splits = []
     last = 0
-    for i in range(len(indices)):
-        splits.append(strdata[last : indices[i]])
-        last = indices[i] + 1
+    for index in indices:
+        splits.append(strdata[last:index])
+        last = index + 1
         if last >= len(strdata):
             return splits
     splits.append(strdata[last:])

pygame_gui/core/drawable_shapes/drawable_shape.py

@@ -804,7 +804,7 @@ def apply_active_text_changes(self):
 
         """
         if self.text_box_layout is not None:
-            for state_id, state in self.states.items():
+            for _, state in self.states.items():
                 if (
                     state.pre_text_surface is not None
                     and state.text_surface is not None

pygame_gui/core/drawable_shapes/ellipse_drawable_shape.py

@@ -60,26 +60,18 @@ def full_rebuild_on_size_change(self):
         """
         super().full_rebuild_on_size_change()
         # clamping border and shadow widths so we can't form impossible negative sized surfaces
-        if self.shadow_width > min(
+        self.shadow_width = min(
+            self.shadow_width,
             math.floor(self.containing_rect.width / 2),
             math.floor(self.containing_rect.height / 2),
-        ):
-            self.shadow_width = min(
-                math.floor(self.containing_rect.width / 2),
-                math.floor(self.containing_rect.height / 2),
-            )
-
+        )
         self.shadow_width = max(self.shadow_width, 0)
 
-        if self.border_width > min(
-            math.floor((self.containing_rect.width - (self.shadow_width * 2)) / 2),
-            math.floor((self.containing_rect.height - (self.shadow_width * 2)) / 2),
-        ):
-            self.border_width = min(
-                math.floor((self.containing_rect.width - (self.shadow_width * 2)) / 2),
-                math.floor((self.containing_rect.height - (self.shadow_width * 2)) / 2),
-            )
-
+        self.border_width = min(
+            self.border_width,
+            math.floor((self.containing_rect.width - self.shadow_width * 2) / 2),
+            math.floor((self.containing_rect.height - self.shadow_width * 2) / 2),
+        )
         self.border_width = max(self.border_width, 0)
 
         if self.shadow_width > 0:
@@ -202,9 +194,6 @@ def redraw_state(self, state_str: str, add_text: bool = True):
         else:
             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"]
@@ -354,10 +343,10 @@ def redraw_state(self, state_str: str, add_text: bool = True):
                     )
 
             self.finalise_images_and_text(
-                image_state_str,
+                f"{state_str}_image",
                 state_str,
-                text_colour_state_str,
-                text_shadow_colour_state_str,
+                f"{state_str}_text",
+                f"{state_str}_text_shadow",
                 add_text,
             )
 

pygame_gui/core/drawable_shapes/rect_drawable_shape.py

@@ -65,26 +65,18 @@ def full_rebuild_on_size_change(self):
 
         self.base_surface = None
 
-        if self.shadow_width > min(
+        self.shadow_width = min(
+            self.shadow_width,
             math.floor(self.containing_rect.width / 2),
             math.floor(self.containing_rect.height / 2),
-        ):
-            self.shadow_width = min(
-                math.floor(self.containing_rect.width / 2),
-                math.floor(self.containing_rect.height / 2),
-            )
-
+        )
         self.shadow_width = max(self.shadow_width, 0)
 
-        if self.border_width > min(
-            math.floor((self.containing_rect.width - (self.shadow_width * 2)) / 2),
-            math.floor((self.containing_rect.height - (self.shadow_width * 2)) / 2),
-        ):
-            self.border_width = min(
-                math.floor((self.containing_rect.width - (self.shadow_width * 2)) / 2),
-                math.floor((self.containing_rect.height - (self.shadow_width * 2)) / 2),
-            )
-
+        self.border_width = min(
+            self.border_width,
+            math.floor((self.containing_rect.width - self.shadow_width * 2) / 2),
+            math.floor((self.containing_rect.height - self.shadow_width * 2) / 2),
+        )
         self.border_width = max(self.border_width, 0)
 
         if self.shadow_width > 0:

pygame_gui/core/gui_font_freetype.py

@@ -1,16 +1,30 @@
-import pygame
-
-from pygame_gui.core.interfaces.gui_font_interface import IGUIFontInterface
-from pygame.freetype import Font
 from typing import Union, IO, Optional, Dict, Tuple
 from os import PathLike
+
+import pygame
 from pygame import Color, Surface, Rect
+from pygame.freetype import Font
+
+from pygame_gui.core.interfaces.gui_font_interface import IGUIFontInterface
 
 AnyPath = Union[str, bytes, PathLike]
 FileArg = Union[AnyPath, IO]
 
 
 class GUIFontFreetype(IGUIFontInterface):
+    """
+    A GUI Font wrapping the 'freetype' Font class from pygame-ce to a common interface with the SDL based Font class
+    also from pygame-ce. This was to facilitate easy switching between the two when testing features.
+
+    NB: At this point the SDL based Font class seems clearly superior so this is legacy code that will likely be
+    removed in a future version
+
+    :param file: the font file
+    :param size: the font point size
+    :param force_style: whether we force the styling when the available font does not support it.
+    :param style: a style dictionary to set styling parameters like bold and italic
+    """
+
     def __init__(
         self,
         file: Optional[FileArg],
@@ -23,8 +37,8 @@ def __init__(
         self.__internal_font.origin = True
         self.__internal_font.kerning = True
 
-        self.__underline = False
-        self.__underline_adjustment = 0.0
+        self.__underline = False  # pylint: disable=unused-private-member
+        self.__underline_adjustment = 0.0  # pylint: disable=unused-private-member
 
         self.point_size = size
 
@@ -54,21 +68,19 @@ def underline_adjustment(self) -> float:
     def underline_adjustment(self, value: float):
         self.__internal_font.underline_adjustment = value
 
-    def get_point_size(self):
+    def get_point_size(self) -> int:
         return self.point_size
 
     def get_rect(self, text: str) -> Rect:
         supposed_rect = self.__internal_font.get_rect(text)
-        text_surface, text_rect = self.__internal_font.render(
-            text, pygame.Color("white")
-        )
+        text_surface, _ = self.__internal_font.render(text, pygame.Color("white"))
         return pygame.Rect(supposed_rect.topleft, text_surface.get_size())
 
     def get_metrics(self, text: str):
         return self.__internal_font.get_metrics(text)
 
     def render_premul(self, text: str, text_color: Color) -> Surface:
-        text_surface, text_rect = self.__internal_font.render(text, text_color)
+        text_surface, _ = self.__internal_font.render(text, text_color)
         text_surface = text_surface.convert_alpha()
         if text_surface.get_width() > 0 and text_surface.get_height() > 0:
             text_surface = text_surface.premul_alpha()
@@ -89,7 +101,7 @@ def render_premul_to(
             text_surface = text_surface.premul_alpha()
         return text_surface
 
-    def get_padding_height(self):
+    def get_padding_height(self) -> int:
         # 'font padding' this determines the amount of padding that
         # font.pad adds to the top of text excluding
         # any padding added to make glyphs even - this is useful