fix C901 too complex linting errors

Author: xulbux

src/xulbux/data.py

@@ -290,9 +290,9 @@ def get_path_id(
 
         data = cls.remove_comments(data, comment_start, comment_end)
         if isinstance(value_paths, str):
-            return cls._get_path_id(value_paths, path_sep, data, ignore_not_found)
+            return _DataGetPathIdHelper(value_paths, path_sep, data, ignore_not_found)()
 
-        results = [cls._get_path_id(path, path_sep, data, ignore_not_found) for path in value_paths]
+        results = [_DataGetPathIdHelper(path, path_sep, data, ignore_not_found)() for path in value_paths]
         return results if len(results) > 1 else results[0] if results else None
 
     @classmethod
@@ -512,51 +512,6 @@ def _sep_path_id(path_id: str) -> list[int]:
 
         raise ValueError(f"Path ID '{path_id}' is an invalid format.")
 
-    @staticmethod
-    def _get_path_id(path: str, path_sep: str, data_obj: DataStructure, ignore_not_found: bool) -> Optional[str]:
-        """Internal method to process a single data-path and generate its path ID."""
-        keys = path.split(path_sep)
-        path_ids, max_id_length = [], 0
-        current_data: Any = data_obj
-
-        for key in keys:
-            if isinstance(current_data, dict):
-                if key.isdigit():
-                    if ignore_not_found:
-                        return None
-                    raise TypeError(f"Key '{key}' is invalid for a dict type.")
-
-                try:
-                    idx = list(current_data.keys()).index(key)
-                    current_data = current_data[key]
-                except (ValueError, KeyError):
-                    if ignore_not_found:
-                        return None
-                    raise KeyError(f"Key '{key}' not found in dict.")
-
-            elif isinstance(current_data, IndexIterableTypes):
-                try:
-                    idx = int(key)
-                    current_data = list(current_data)[idx]  # CONVERT TO LIST FOR INDEXING
-                except ValueError:
-                    try:
-                        idx = list(current_data).index(key)
-                        current_data = list(current_data)[idx]
-                    except ValueError:
-                        if ignore_not_found:
-                            return None
-                        raise ValueError(f"Value '{key}' not found in '{type(current_data).__name__}'")
-
-            else:
-                break
-
-            path_ids.append(str(idx))
-            max_id_length = max(max_id_length, len(str(idx)))
-
-        if not path_ids:
-            return None
-        return f"{max_id_length}>{''.join(id.zfill(max_id_length) for id in path_ids)}"
-
     @classmethod
     def _set_nested_val(cls, data: DataStructure, id_path: list[int], value: Any) -> Any:
         """Internal method to set a value in a nested data structure based on the provided ID path."""
@@ -605,19 +560,19 @@ def __init__(self, data: DataStructure, comment_start: str, comment_end: str, co
         )) if len(comment_end) > 0 else None
 
     def __call__(self) -> DataStructure:
-        return self.rem_nested_comments(self.data)
+        return self.remove_nested_comments(self.data)
 
-    def rem_nested_comments(self, item: Any) -> Any:
+    def remove_nested_comments(self, item: Any) -> Any:
         if isinstance(item, dict):
             return {
                 key: val
                 for key, val in ( \
-                    (self.rem_nested_comments(k), self.rem_nested_comments(v)) for k, v in item.items()
+                    (self.remove_nested_comments(k), self.remove_nested_comments(v)) for k, v in item.items()
                 ) if key is not None
             }
 
         if isinstance(item, IndexIterableTypes):
-            processed = (v for v in map(self.rem_nested_comments, item) if v is not None)
+            processed = (v for v in map(self.remove_nested_comments, item) if v is not None)
             return type(item)(processed)
 
         if isinstance(item, str):
@@ -632,6 +587,77 @@ def rem_nested_comments(self, item: Any) -> Any:
         return item
 
 
+class _DataGetPathIdHelper:
+    """Internal, callable helper class to process a data path and generate its unique path ID."""
+
+    def __init__(self, path: str, path_sep: str, data_obj: DataStructure, ignore_not_found: bool):
+        self.keys = path.split(path_sep)
+        self.data_obj = data_obj
+        self.ignore_not_found = ignore_not_found
+
+        self.path_ids: list[str] = []
+        self.max_id_length = 0
+        self.current_data: Any = data_obj
+
+    def __call__(self) -> Optional[str]:
+        for key in self.keys:
+            if not self.process_key(key):
+                break
+
+        if not self.path_ids:
+            return None
+        return f"{self.max_id_length}>{''.join(id.zfill(self.max_id_length) for id in self.path_ids)}"
+
+    def process_key(self, key: str) -> bool:
+        """Process a single key and update `path_ids`. Returns `False` if processing should stop."""
+        idx: Optional[int] = None
+
+        if isinstance(self.current_data, dict):
+            if (idx := self.process_dict_key(key)) is None:
+                return False
+        elif isinstance(self.current_data, IndexIterableTypes):
+            if (idx := self.process_iterable_key(key)) is None:
+                return False
+        else:
+            return False
+
+        self.path_ids.append(str(idx))
+        self.max_id_length = max(self.max_id_length, len(str(idx)))
+        return True
+
+    def process_dict_key(self, key: str) -> Optional[int]:
+        """Process a key for dictionary data. Returns the index or `None` if not found."""
+        if key.isdigit():
+            if self.ignore_not_found:
+                return None
+            raise TypeError(f"Key '{key}' is invalid for a dict type.")
+
+        try:
+            idx = list(self.current_data.keys()).index(key)
+            self.current_data = self.current_data[key]
+            return idx
+        except (ValueError, KeyError):
+            if self.ignore_not_found:
+                return None
+            raise KeyError(f"Key '{key}' not found in dict.")
+
+    def process_iterable_key(self, key: str) -> Optional[int]:
+        """Process a key for iterable data. Returns the index or `None` if not found."""
+        try:
+            idx = int(key)
+            self.current_data = list(self.current_data)[idx]
+            return idx
+        except ValueError:
+            try:
+                idx = list(self.current_data).index(key)
+                self.current_data = list(self.current_data)[idx]
+                return idx
+            except ValueError:
+                if self.ignore_not_found:
+                    return None
+                raise ValueError(f"Value '{key}' not found in '{type(self.current_data).__name__}'")
+
+
 class _DataRenderHelper:
     """Internal, callable helper class to format data structures as strings."""
 

src/xulbux/format_codes.py

@@ -420,11 +420,6 @@ def _validate_default_color(default_color: Optional[Rgba | Hexa]) -> tuple[bool,
             return True, Color._parse_rgba(default_color)
         raise TypeError("The 'default_color' parameter must be either a valid RGBA or HEXA color, or None.")
 
-    @staticmethod
-    def _is_valid_color(color: str) -> bool:
-        """Internal method to check whether the given color string is a valid formatting-key color."""
-        return bool((color in ANSI.COLOR_MAP) or Color.is_valid_rgba(color) or Color.is_valid_hexa(color))
-
     @staticmethod
     def _formats_to_keys(formats: str) -> list[str]:
         """Internal method to convert a string of multiple format keys
@@ -588,88 +583,140 @@ def __init__(
         self.default_color = default_color
         self.brightness_steps = brightness_steps
 
+        # INSTANCE VARIABLES FOR CURRENT PROCESSING STATE
+        self.formats: str = ""
+        self.original_formats: str = ""
+        self.formats_escaped: bool = False
+        self.auto_reset_escaped: bool = False
+        self.auto_reset_txt: Optional[str] = None
+        self.format_keys: list[str] = []
+        self.ansi_formats: list[str] = []
+        self.ansi_resets: list[str] = []
+
     def __call__(self, match: _rx.Match[str]) -> str:
-        _formats = formats = match.group(1)
-        auto_reset_escaped = match.group(2)
-        auto_reset_txt = match.group(3)
+        self.original_formats = self.formats = match.group(1)
+        self.auto_reset_escaped = bool(match.group(2))
+        self.auto_reset_txt = match.group(3)
+
+        # CHECK IF THERE'S ESCAPED FORMAT CODES
+        self.formats_escaped = bool(_PATTERNS.escape_char_cond.match(match.group(0)))
+        if self.formats_escaped:
+            self.original_formats = self.formats = _PATTERNS.escape_char.sub(r"\1", self.formats)
+
+        self.process_formats_and_auto_reset()
 
-        if formats_escaped := bool(_PATTERNS.escape_char_cond.match(match.group(0))):
-            _formats = formats = _PATTERNS.escape_char.sub(r"\1", formats)  # REMOVE / OR \\
+        if not self.formats:
+            return match.group(0)
+
+        self.convert_to_ansi()
+        return self.build_output(match)
 
-        if auto_reset_txt and auto_reset_txt.count("[") > 0 and auto_reset_txt.count("]") > 0:
-            auto_reset_txt = self.cls.to_ansi(
-                auto_reset_txt,
+    def process_formats_and_auto_reset(self) -> None:
+        """Process nested formatting in both formats and auto-reset text."""
+        # PROCESS AUTO-RESET TEXT IF IT CONTAINS NESTED FORMATTING
+        if self.auto_reset_txt and self.auto_reset_txt.count("[") > 0 and self.auto_reset_txt.count("]") > 0:
+            self.auto_reset_txt = self.cls.to_ansi(
+                self.auto_reset_txt,
                 self.default_color,
                 self.brightness_steps,
                 _default_start=False,
                 _validate_default=False,
             )
 
-        if not formats:
-            return match.group(0)
-
-        if formats.count("[") > 0 and formats.count("]") > 0:
-            formats = self.cls.to_ansi(
-                formats,
+        # PROCESS NESTED FORMATTING IN FORMATS
+        if self.formats and self.formats.count("[") > 0 and self.formats.count("]") > 0:
+            self.formats = self.cls.to_ansi(
+                self.formats,
                 self.default_color,
                 self.brightness_steps,
                 _default_start=False,
                 _validate_default=False,
             )
 
-        format_keys = self.cls._formats_to_keys(formats)
-        ansi_formats = [
+    def convert_to_ansi(self) -> None:
+        """Convert format keys to ANSI codes and generate resets if needed."""
+        self.format_keys = self.cls._formats_to_keys(self.formats)
+        self.ansi_formats = [
             r if (r := self.cls._get_replacement(k, self.default_color, self.brightness_steps)) != k else f"[{k}]"
-            for k in format_keys
+            for k in self.format_keys
         ]
 
-        if auto_reset_txt and not auto_reset_escaped:
-            reset_keys: list[str] = []
-            default_color_resets = ("_bg", "default") if self.use_default else ("_bg", "_c")
-
-            for k in format_keys:
-                k_lower = k.lower()
-                k_set = set(k_lower.split(":"))
-
-                if _PREFIX["BG"] & k_set and len(k_set) <= 3:
-                    if k_set & _PREFIX["BR"]:
-                        for i in range(len(k)):
-                            if self.cls._is_valid_color(k[i:]):
-                                reset_keys.extend(default_color_resets)
-                                break
-                    else:
-                        for i in range(len(k)):
-                            if self.cls._is_valid_color(k[i:]):
-                                reset_keys.append("_bg")
-                                break
-
-                elif self.cls._is_valid_color(k) or any(
-                        k_lower.startswith(pref_colon := f"{prefix}:") and self.cls._is_valid_color(k[len(pref_colon):])
-                        for prefix in _PREFIX["BR"]):
-                    reset_keys.append(default_color_resets[1])
-
+        # GENERATE RESET CODES IF AUTO-RESET IS ACTIVE
+        if self.auto_reset_txt and not self.auto_reset_escaped:
+            self.gen_reset_codes()
+        else:
+            self.ansi_resets = []
+
+    def gen_reset_codes(self) -> None:
+        """Generate appropriate ANSI reset codes for each format key."""
+        default_color_resets = ("_bg", "default") if self.use_default else ("_bg", "_c")
+        reset_keys: list[str] = []
+
+        for k in self.format_keys:
+            k_lower = k.lower()
+            k_set = set(k_lower.split(":"))
+
+            # BACKGROUND COLOR FORMAT
+            if _PREFIX["BG"] & k_set and len(k_set) <= 3:
+                if k_set & _PREFIX["BR"]:
+                    # BRIGHT BACKGROUND COLOR - RESET BOTH BG AND COLOR
+                    for i in range(len(k)):
+                        if self.is_valid_color(k[i:]):
+                            reset_keys.extend(default_color_resets)
+                            break
                 else:
-                    reset_keys.append(f"_{k}")
-
-            ansi_resets = [
-                r for k in reset_keys if (r := self.cls._get_replacement(k, self.default_color, self.brightness_steps)
-                                          ).startswith(f"{ANSI.CHAR}{ANSI.START}")
-            ]
+                    # REGULAR BACKGROUND COLOR - RESET ONLY BG
+                    for i in range(len(k)):
+                        if self.is_valid_color(k[i:]):
+                            reset_keys.append("_bg")
+                            break
+
+            # TEXT COLOR FORMAT
+            elif self.is_valid_color(k) or any(
+                k_lower.startswith(pref_colon := f"{prefix}:") and self.is_valid_color(k[len(pref_colon):]) \
+                for prefix in _PREFIX["BR"]
+            ):
+                reset_keys.append(default_color_resets[1])
+
+            # TEXT STYLE FORMAT
+            else:
+                reset_keys.append(f"_{k}")
+
+        # CONVERT RESET KEYS TO ANSI CODES
+        self.ansi_resets = [
+            r for k in reset_keys if ( \
+                r := self.cls._get_replacement(k, self.default_color, self.brightness_steps)
+            ).startswith(f"{ANSI.CHAR}{ANSI.START}")
+        ]
 
-        else:
-            ansi_resets = []
+    def build_output(self, match: _rx.Match[str]) -> str:
+        """Build the final output string based on processed formats and resets."""
+        # CHECK IF ALL FORMATS WERE VALID
+        has_single_valid_ansi = len(self.ansi_formats) == 1 and self.ansi_formats[0].count(f"{ANSI.CHAR}{ANSI.START}") >= 1
+        all_formats_valid = all(f.startswith(f"{ANSI.CHAR}{ANSI.START}") for f in self.ansi_formats)
 
-        if (
-            not (len(ansi_formats) == 1 and ansi_formats[0].count(f"{ANSI.CHAR}{ANSI.START}") >= 1) and \
-            not all(f.startswith(f"{ANSI.CHAR}{ANSI.START}") for f in ansi_formats)  # FORMATTING WAS INVALID
-        ):
+        if not has_single_valid_ansi and not all_formats_valid:
             return match.group(0)
-        elif formats_escaped:  # FORMATTING WAS VALID BUT ESCAPED
-            return f"[{_formats}]({auto_reset_txt})" if auto_reset_txt else f"[{_formats}]"
-        else:
-            return (
-                "".join(ansi_formats) + (
-                    f"({self.cls.to_ansi(auto_reset_txt, self.default_color, self.brightness_steps, _default_start=False, _validate_default=False)})"
-                    if auto_reset_escaped and auto_reset_txt else auto_reset_txt if auto_reset_txt else ""
-                ) + ("" if auto_reset_escaped else "".join(ansi_resets))
-            )
+
+        # HANDLE ESCAPED FORMATTING
+        if self.formats_escaped:
+            return f"[{self.original_formats}]({self.auto_reset_txt})" if self.auto_reset_txt else f"[{self.original_formats}]"
+
+        # BUILD NORMAL OUTPUT WITH FORMATS AND RESETS
+        output = "".join(self.ansi_formats)
+
+        # ADD AUTO-RESET TEXT
+        if self.auto_reset_escaped and self.auto_reset_txt:
+            output += f"({self.cls.to_ansi(self.auto_reset_txt, self.default_color, self.brightness_steps, _default_start=False, _validate_default=False)})"
+        elif self.auto_reset_txt:
+            output += self.auto_reset_txt
+
+        # ADD RESET CODES IF NOT ESCAPED
+        if not self.auto_reset_escaped:
+            output += "".join(self.ansi_resets)
+
+        return output
+
+    def is_valid_color(self, color: str) -> bool:
+        """Check whether the given color string is a valid formatting-key color."""
+        return bool((color in ANSI.COLOR_MAP) or Color.is_valid_rgba(color) or Color.is_valid_hexa(color))