made some internal methods private & made internal classmethods static if the class object isn't required

Author: xulbux

src/xulbux/color.py

@@ -934,7 +934,7 @@ def is_valid(cls, color: AnyRgba | AnyHsla | AnyHexa, allow_alpha: bool = True)
         )
 
     @classmethod
-    def _parse_rgba(cls, color: AnyRgba) -> rgba:
+    def __parse_rgba(cls, color: AnyRgba) -> rgba:
         """Internal method to parse a color to an RGBA object."""
         if isinstance(color, rgba):
             return color
@@ -951,7 +951,7 @@ def _parse_rgba(cls, color: AnyRgba) -> rgba:
         raise ValueError(f"Could not parse RGBA color: {color!r}")
 
     @classmethod
-    def _parse_hsla(cls, color: AnyHsla) -> hsla:
+    def __parse_hsla(cls, color: AnyHsla) -> hsla:
         """Internal method to parse a color to an HSLA object."""
         if isinstance(color, hsla):
             return color
@@ -1007,11 +1007,11 @@ def to_rgba(cls, color: Rgba | Hsla | Hexa) -> rgba:
         if isinstance(color, (hsla, hexa)):
             return color.to_rgba()
         elif cls.is_valid_hsla(color):
-            return cls._parse_hsla(color).to_rgba()
+            return cls.__parse_hsla(color).to_rgba()
         elif cls.is_valid_hexa(color):
             return hexa(cast(str | int, color)).to_rgba()
         elif cls.is_valid_rgba(color):
-            return cls._parse_rgba(color)
+            return cls.__parse_rgba(color)
         raise ValueError(f"Could not convert color {color!r} to RGBA.")
 
     @classmethod
@@ -1022,11 +1022,11 @@ def to_hsla(cls, color: Rgba | Hsla | Hexa) -> hsla:
         if isinstance(color, (rgba, hexa)):
             return color.to_hsla()
         elif cls.is_valid_rgba(color):
-            return cls._parse_rgba(color).to_hsla()
+            return cls.__parse_rgba(color).to_hsla()
         elif cls.is_valid_hexa(color):
             return hexa(cast(str | int, color)).to_hsla()
         elif cls.is_valid_hsla(color):
-            return cls._parse_hsla(color)
+            return cls.__parse_hsla(color)
         raise ValueError(f"Could not convert color {color!r} to HSLA.")
 
     @classmethod
@@ -1037,9 +1037,9 @@ def to_hexa(cls, color: Rgba | Hsla | Hexa) -> hexa:
         if isinstance(color, (rgba, hsla)):
             return color.to_hexa()
         elif cls.is_valid_rgba(color):
-            return cls._parse_rgba(color).to_hexa()
+            return cls.__parse_rgba(color).to_hexa()
         elif cls.is_valid_hsla(color):
-            return cls._parse_hsla(color).to_hexa()
+            return cls.__parse_hsla(color).to_hexa()
         elif cls.is_valid_hexa(color):
             return color if isinstance(color, hexa) else hexa(cast(str | int, color))
         raise ValueError(f"Could not convert color {color!r} to HEXA")
@@ -1183,11 +1183,9 @@ def hex_int_to_rgba(cls, hex_int: int, preserve_original: bool = False) -> rgba:
         else:
             raise ValueError(f"Could not convert HEX integer 0x{hex_int:X} to RGBA color.")
 
-    @classmethod
-    def _linearize_srgb(cls, c: float) -> float:
-        """Helper method to linearize sRGB component following the WCAG standard.\n
-        ----------------------------------------------------------------------------
-        - `c` -⠀the sRGB component value in range [0.0, 1.0] inclusive"""
+    @staticmethod
+    def __linearize_srgb(c: float) -> float:
+        """Helper method to linearize sRGB component following the WCAG standard."""
         if not (0.0 <= c <= 1.0):
             raise ValueError(f"The 'c' parameter must be in range [0.0, 1.0] inclusive, got {c!r}")
 
@@ -1229,14 +1227,14 @@ def luminance(
         elif method == "bt601":
             luminance = 0.299 * _r + 0.587 * _g + 0.114 * _b
         elif method == "wcag3":
-            _r = cls._linearize_srgb(_r)
-            _g = cls._linearize_srgb(_g)
-            _b = cls._linearize_srgb(_b)
+            _r = cls.__linearize_srgb(_r)
+            _g = cls.__linearize_srgb(_g)
+            _b = cls.__linearize_srgb(_b)
             luminance = 0.2126729 * _r + 0.7151522 * _g + 0.0721750 * _b
         else:
-            _r = cls._linearize_srgb(_r)
-            _g = cls._linearize_srgb(_g)
-            _b = cls._linearize_srgb(_b)
+            _r = cls.__linearize_srgb(_r)
+            _g = cls.__linearize_srgb(_g)
+            _b = cls.__linearize_srgb(_b)
             luminance = 0.2126 * _r + 0.7152 * _g + 0.0722 * _b
 
         if output_type == int:

src/xulbux/console.py

@@ -513,32 +513,36 @@ def log(
                 end=end,
             )
 
+    @staticmethod
+    def __find_string_part(pos: int, cumulative_pos: list[int]) -> int:
+        """Finds the index of the string part that contains the given position."""
+        left, right = 0, len(cumulative_pos) - 1
+        while left < right:
+            mid = (left + right) // 2
+            if cumulative_pos[mid] <= pos < cumulative_pos[mid + 1]:
+                return mid
+            elif pos < cumulative_pos[mid]:
+                right = mid
+            else:
+                left = mid + 1
+        return left
+
     @classmethod
     def __add_back_removed_parts(cls, split_string: list[str], removals: tuple[tuple[int, str], ...]) -> list[str]:
         """Adds back the removed parts into the split string parts at their original positions."""
-        lengths, cumulative_pos = [len(s) for s in split_string], [0]
-        for length in lengths:
+        cumulative_pos = [0]
+        for length in (len(s) for s in split_string):
             cumulative_pos.append(cumulative_pos[-1] + length)
+
         result, offset_adjusts = split_string.copy(), [0] * len(split_string)
         last_idx, total_length = len(split_string) - 1, cumulative_pos[-1]
 
-        def find_string_part(pos: int) -> int:
-            left, right = 0, len(cumulative_pos) - 1
-            while left < right:
-                mid = (left + right) // 2
-                if cumulative_pos[mid] <= pos < cumulative_pos[mid + 1]:
-                    return mid
-                elif pos < cumulative_pos[mid]:
-                    right = mid
-                else:
-                    left = mid + 1
-            return left
-
         for pos, removal in removals:
             if pos >= total_length:
                 result[last_idx] = result[last_idx] + removal
                 continue
-            i = find_string_part(pos)
+
+            i = cls.__find_string_part(pos, cumulative_pos)
             adjusted_pos = (pos - cumulative_pos[i]) + offset_adjusts[i]
             parts = [result[i][:adjusted_pos], removal, result[i][adjusted_pos:]]
             result[i] = "".join(parts)
@@ -863,9 +867,8 @@ def log_box_bordered(
             end=end,
         )
 
-    @classmethod
+    @staticmethod
     def __prepare_log_box(
-        cls,
         values: list[object] | tuple[object, ...],
         default_color: Optional[Rgba | Hexa] = None,
         has_rules: bool = False,

src/xulbux/data.py

@@ -660,8 +660,8 @@ def print(
             end=end,
         )
 
-    @classmethod
-    def __sep_path_id(cls, path_id: str) -> list[int]:
+    @staticmethod
+    def __sep_path_id(path_id: str) -> list[int]:
         if len(split_id := path_id.split(">")) == 2:
             id_part_len, path_id_parts = split_id
 

src/xulbux/env_path.py

@@ -51,8 +51,8 @@ def remove_path(cls, path: Optional[str] = None, cwd: bool = False, base_dir: bo
         if cls.has_path(path := cls.__get(path, cwd, base_dir)):
             cls.__persistent(path, remove=True)
 
-    @classmethod
-    def __get(cls, path: Optional[str] = None, cwd: bool = False, base_dir: bool = False) -> str:
+    @staticmethod
+    def __get(path: Optional[str] = None, cwd: bool = False, base_dir: bool = False) -> str:
         """Get and/or normalize the given path, CWD or base directory.\n
         ------------------------------------------------------------------------------------
         Raise an error if no path is provided and neither `cwd` or `base_dir` is `True`."""

src/xulbux/format_codes.py

@@ -523,12 +523,12 @@ def _config_console(cls) -> None:
                     pass
             _CONSOLE_ANSI_CONFIGURED = True
 
-    @classmethod
-    def __formats_to_keys(cls, formats: str) -> list[str]:
+    @staticmethod
+    def __formats_to_keys(formats: str) -> list[str]:
         return [k.strip() for k in formats.split("|") if k.strip()]
 
-    @classmethod
-    def __validate_default_color(cls, default_color: Optional[Rgba | Hexa]) -> tuple[bool, Optional[rgba]]:
+    @staticmethod
+    def __validate_default_color(default_color: Optional[Rgba | Hexa]) -> tuple[bool, Optional[rgba]]:
         """Validate and convert `default_color` to rgba format."""
         if default_color is None:
             return False, None
@@ -538,9 +538,8 @@ def __validate_default_color(cls, default_color: Optional[Rgba | Hexa]) -> tuple
             return True, Color.to_rgba(default_color)
         raise TypeError("The 'default_color' parameter must be either a valid RGBA or HEXA color, or None.")
 
-    @classmethod
+    @staticmethod
     def __get_default_ansi(
-        cls,
         default_color: rgba,
         format_key: Optional[str] = None,
         brightness_steps: Optional[int] = None,
@@ -606,16 +605,15 @@ def __get_replacement(cls, format_key: str, default_color: Optional[rgba], brigh
             pass
         return _format_key
 
-    @classmethod
-    def __normalize_key(cls, format_key: str) -> str:
+    @staticmethod
+    def __normalize_key(format_key: str) -> str:
         """Normalizes the given format key."""
         k_parts = format_key.replace(" ", "").lower().split(":")
         prefix_str = "".join(
             f"{prefix_key.lower()}:" for prefix_key, prefix_values in _PREFIX.items()
             if any(k_part in prefix_values for k_part in k_parts)
         )
         return prefix_str + ":".join(
-            part for part in k_parts if part not in {val
-                                                     for values in _PREFIX.values()
-                                                     for val in values}
+            part for part in k_parts \
+            if part not in {val for values in _PREFIX.values() for val in values}
         )