xulbux 1.5.5__py3-none-any.whl → 1.5.7__py3-none-any.whl

xulbux/xx_data.py

@@ -2,19 +2,17 @@ import math as _math
 import re as _re
 
 
-
-
 class Data:
 
     @staticmethod
-    def chars_count(data:list|tuple|set|frozenset|dict) -> int:
+    def chars_count(data: list | tuple | set | frozenset | dict) -> int:
         """The sum of all the characters including the keys in dictionaries."""
         if isinstance(data, dict):
             return sum(len(str(k)) + len(str(v)) for k, v in data.items())
         return sum(len(str(item)) for item in data)
 
     @staticmethod
-    def strip(data:list|tuple|dict) -> list|tuple|dict:
+    def strip(data: list | tuple | dict) -> list | tuple | dict:
         if isinstance(data, dict):
             return {k: v.strip() if isinstance(v, str) else Data.strip(v) for k, v in data.items()}
         elif isinstance(data, (list, tuple)):
@@ -23,7 +21,7 @@ class Data:
         return data.strip() if isinstance(data, str) else data
 
     @staticmethod
-    def remove(data:list|tuple|dict, items:list[str]) -> list|tuple|dict:
+    def remove(data: list | tuple | dict, items: list[str]) -> list | tuple | dict:
         """Remove multiple items from lists and tuples or keys from dictionaries."""
         if isinstance(data, (list, tuple)):
             result = [k for k in data if k not in items]
@@ -32,14 +30,17 @@ class Data:
             return {k: v for k, v in data.items() if k not in items}
 
     @staticmethod
-    def remove_empty_items(data:list|tuple|dict, spaces_are_empty:bool = False) -> list|tuple|dict:
+    def remove_empty_items(data: list | tuple | dict, spaces_are_empty: bool = False) -> list | tuple | dict:
         if isinstance(data, dict):
             filtered_dict = {}
             for key, value in data.items():
                 if isinstance(value, (list, tuple, dict)):
                     filtered_value = Data.remove_empty_items(value, spaces_are_empty)
-                    if filtered_value: filtered_dict[key] = filtered_value
-                elif value not in (None, '') and not ((spaces_are_empty and isinstance(value, str)) and value.strip() in (None, '')):
+                    if filtered_value:
+                        filtered_dict[key] = filtered_value
+                elif value not in (None, "") and not (
+                    (spaces_are_empty and isinstance(value, str)) and value.strip() in (None, "")
+                ):
                     filtered_dict[key] = value
             return filtered_dict
         filtered = []
@@ -50,12 +51,12 @@ class Data:
                     if isinstance(item, tuple):
                         deduped_item = tuple(deduped_item)
                     filtered.append(deduped_item)
-            elif item not in (None, '') and not ((spaces_are_empty and isinstance(item, str)) and item.strip() in (None, '')):
+            elif item not in (None, "") and not ((spaces_are_empty and isinstance(item, str)) and item.strip() in (None, "")):
                 filtered.append(item)
         return tuple(filtered) if isinstance(data, tuple) else filtered
 
     @staticmethod
-    def remove_duplicates(data:list|tuple|dict) -> list|tuple|dict:
+    def remove_duplicates(data: list | tuple | dict) -> list | tuple | dict:
         if isinstance(data, dict):
             return {k: Data.remove_duplicates(v) for k, v in data.items()}
         elif isinstance(data, (list, tuple)):
@@ -71,7 +72,12 @@ class Data:
         return data
 
     @staticmethod
-    def remove_comments(data:list|tuple|dict, comment_start:str = '>>', comment_end:str = '<<', comment_sep:str = '') -> list|tuple|dict:
+    def remove_comments(
+        data: list | tuple | dict,
+        comment_start: str = ">>",
+        comment_end: str = "<<",
+        comment_sep: str = "",
+    ) -> list | tuple | dict:
         """Remove comments from a list, tuple or dictionary.\n
         -----------------------------------------------------------------------------------------------------------------
         The `data` parameter is your list, tuple or dictionary, where the comments should get removed from.<br>
@@ -109,8 +115,12 @@ class Data:
          `value3` The comment is removed and the parts left and right are joined through `comment_sep`.<br>
          `value4` The whole value is removed, since the whole value was a comment.<br>
         For `key2`, the key, including its whole values will be removed.<br>
-        For `key3`, since all its values are just comments, the key will still exist, but with a value of `None`."""
-        def process_item(item:dict|list|tuple|str) -> dict|list|tuple|str|None:
+        For `key3`, since all its values are just comments, the key will still exist, but with a value of `None`.
+        """
+
+        def process_item(
+            item: dict | list | tuple | str,
+        ) -> dict | list | tuple | str | None:
             if isinstance(item, dict):
                 processed_dict = {}
                 for key, val in item.items():
@@ -118,7 +128,8 @@ class Data:
                     if processed_key is not None:
                         processed_val = process_item(val)
                         if isinstance(val, (list, tuple, dict)):
-                            if processed_val: processed_dict[processed_key] = processed_val
+                            if processed_val:
+                                processed_dict[processed_key] = processed_val
                         elif processed_val is not None:
                             processed_dict[processed_key] = processed_val
                         else:
@@ -130,17 +141,28 @@ class Data:
                 return tuple(v for v in (process_item(val) for val in item) if v is not None)
             elif isinstance(item, str):
                 if comment_end:
-                    no_comments = _re.sub(rf'^((?:(?!{_re.escape(comment_start)}).)*){_re.escape(comment_start)}(?:(?:(?!{_re.escape(comment_end)}).)*)(?:{_re.escape(comment_end)})?(.*?)$',
-                        lambda m: f'{m.group(1).strip()}{comment_sep if (m.group(1).strip() not in ["", None]) and (m.group(2).strip() not in ["", None]) else ""}{m.group(2).strip()}', item)
+                    no_comments = _re.sub(
+                        rf"^((?:(?!{_re.escape(comment_start)}).)*){_re.escape(comment_start)}(?:(?:(?!{_re.escape(comment_end)}).)*)(?:{_re.escape(comment_end)})?(.*?)$",
+                        lambda m: f'{m.group(1).strip()}{comment_sep if (m.group(1).strip() not in (None, "")) and (m.group(2).strip() not in (None, "")) else ""}{m.group(2).strip()}',
+                        item,
+                    )
                 else:
                     no_comments = None if item.lstrip().startswith(comment_start) else item
-                return no_comments.strip() if no_comments and no_comments.strip() != '' else None
+                return no_comments.strip() if no_comments and no_comments.strip() != "" else None
             else:
                 return item
+
         return process_item(data)
 
     @staticmethod
-    def is_equal(data1:list|tuple|dict, data2:list|tuple|dict, ignore_paths:str|list[str] = '', comment_start:str = '>>', comment_end:str = '<<', sep:str = '->') -> bool:
+    def is_equal(
+        data1: list | tuple | dict,
+        data2: list | tuple | dict,
+        ignore_paths: str | list[str] = "",
+        comment_start: str = ">>",
+        comment_end: str = "<<",
+        sep: str = "->",
+    ) -> bool:
         """Compares two structures and returns `True` if they are equal and `False` otherwise.\n
         ⇾ **Will not detect, if a key-name has changed, only if removed or added.**\n
         ------------------------------------------------------------------------------------------------
@@ -149,13 +171,25 @@ class Data:
         ------------------------------------------------------------------------------------------------
         The paths from `ignore_paths` work exactly the same way as the paths from `value_paths`<br>
         in the function `Data.get_path_id()`, just like the `sep` parameter. For more detailed<br>
-        explanation, see the documentation of the function `Data.get_path_id()`."""
-        def process_ignore_paths(ignore_paths:str|list[str]) -> list[list[str]]:
+        explanation, see the documentation of the function `Data.get_path_id()`.
+        """
+
+        def process_ignore_paths(
+            ignore_paths: str | list[str],
+        ) -> list[list[str]]:
             if isinstance(ignore_paths, str):
                 ignore_paths = [ignore_paths]
             return [path.split(sep) for path in ignore_paths if path]
-        def compare(d1:dict|list|tuple, d2:dict|list|tuple, ignore_paths:list[list[str]], current_path:list = []) -> bool:
-            if ignore_paths and any(current_path == path[:len(current_path)] and len(current_path) == len(path) for path in ignore_paths):
+
+        def compare(
+            d1: dict | list | tuple,
+            d2: dict | list | tuple,
+            ignore_paths: list[list[str]],
+            current_path: list = [],
+        ) -> bool:
+            if ignore_paths and any(
+                current_path == path[: len(current_path)] and len(current_path) == len(path) for path in ignore_paths
+            ):
                 return True
             if isinstance(d1, dict) and isinstance(d2, dict):
                 if set(d1.keys()) != set(d2.keys()):
@@ -164,13 +198,23 @@ class Data:
             elif isinstance(d1, (list, tuple)) and isinstance(d2, (list, tuple)):
                 if len(d1) != len(d2):
                     return False
-                return all(compare(item1, item2, ignore_paths, current_path + [str(i)]) for i, (item1, item2) in enumerate(zip(d1, d2)))
+                return all(
+                    compare(item1, item2, ignore_paths, current_path + [str(i)])
+                    for i, (item1, item2) in enumerate(zip(d1, d2))
+                )
             else:
                 return d1 == d2
-        return compare(Data.remove_comments(data1, comment_start, comment_end), Data.remove_comments(data2, comment_start, comment_end), process_ignore_paths(ignore_paths))
+
+        return compare(
+            Data.remove_comments(data1, comment_start, comment_end),
+            Data.remove_comments(data2, comment_start, comment_end),
+            process_ignore_paths(ignore_paths),
+        )
 
     @staticmethod
-    def get_fingerprint(data:list|tuple|dict) -> list|tuple|dict|None:
+    def get_fingerprint(
+        data: list | tuple | dict,
+    ) -> list | tuple | dict | None:
         if isinstance(data, dict):
             return {i: type(v).__name__ for i, v in enumerate(data.values())}
         elif isinstance(data, (list, tuple)):
@@ -178,7 +222,12 @@ class Data:
         return None
 
     @staticmethod
-    def get_path_id(data:list|tuple|dict, value_paths:str|list[str], sep:str = '->', ignore_not_found:bool = False) -> str|list[str]:
+    def get_path_id(
+        data: list | tuple | dict,
+        value_paths: str | list[str],
+        sep: str = "->",
+        ignore_not_found: bool = False,
+    ) -> str | list[str]:
         """Generates a unique ID based on the path to a specific value within a nested data structure.\n
         -------------------------------------------------------------------------------------------------
         The `data` parameter is the list, tuple, or dictionary, which the id should be generated for.\n
@@ -200,16 +249,17 @@ class Data:
         -------------------------------------------------------------------------------------------------
         If `ignore_not_found` is `True`, the function will return `None` if the value is not<br>
         found instead of raising an error."""
-        if isinstance(value_paths, str): value_paths = [value_paths]
+        if isinstance(value_paths, str):
+            value_paths = [value_paths]
         path_ids = []
         for path in value_paths:
-            keys = [k.strip() for k in path.split(str(sep).strip()) if k.strip() != '']
+            keys = [k.strip() for k in path.split(str(sep).strip()) if k.strip() != ""]
             id_part_len, _path_ids, _obj = 0, [], data
             try:
                 for k in keys:
                     if isinstance(_obj, dict):
                         if k.isdigit():
-                            raise TypeError(f'Key \'{k}\' is invalid for a dict type.')
+                            raise TypeError(f"Key '{k}' is invalid for a dict type.")
                         try:
                             idx = list(_obj.keys()).index(k)
                             _path_ids.append(idx)
@@ -218,7 +268,7 @@ class Data:
                             if ignore_not_found:
                                 _path_ids = None
                                 break
-                            raise KeyError(f'Key \'{k}\' not found in dict.')
+                            raise KeyError(f"Key '{k}' not found in dict.")
                     elif isinstance(_obj, (list, tuple)):
                         try:
                             idx = int(k)
@@ -233,7 +283,7 @@ class Data:
                                 if ignore_not_found:
                                     _path_ids = None
                                     break
-                                raise ValueError(f'Value \'{k}\' not found in list/tuple.')
+                                raise ValueError(f"Value '{k}' not found in list/tuple.")
                     else:
                         break
                     if _path_ids:
@@ -245,11 +295,12 @@ class Data:
             except (KeyError, ValueError, TypeError) as e:
                 if ignore_not_found:
                     path_ids.append(None)
-                else: raise e
+                else:
+                    raise e
         return path_ids if len(path_ids) > 1 else path_ids[0] if len(path_ids) == 1 else None
 
     @staticmethod
-    def get_value_by_path_id(data:list|tuple|dict, path_id:str, get_key:bool = False) -> any:
+    def get_value_by_path_id(data: list | tuple | dict, path_id: str, get_key: bool = False) -> any:
         """Retrieves the value from `data` using the provided `path_id`.\n
         ------------------------------------------------------------------------------------
         Input a list, tuple or dict as `data`, along with `path_id`, which is a path-id<br>
@@ -257,8 +308,10 @@ class Data:
         and the final item is in a dict, it returns the key instead of the value.\n
         ------------------------------------------------------------------------------------
         The function will return the value (or key) from the path-id location, as long as<br>
-        the structure of `data` hasn't changed since creating the path-id to that value."""
-        def get_nested(data:list|tuple|dict, path:list[int], get_key:bool) -> any:
+        the structure of `data` hasn't changed since creating the path-id to that value.
+        """
+
+        def get_nested(data: list | tuple | dict, path: list[int], get_key: bool) -> any:
             parent = None
             for i, idx in enumerate(path):
                 if isinstance(data, dict):
@@ -270,18 +323,23 @@ class Data:
                 elif isinstance(data, (list, tuple)):
                     if i == len(path) - 1 and get_key:
                         if parent is None or not isinstance(parent, dict):
-                            raise ValueError('Cannot get key from list or tuple without a parent dictionary')
+                            raise ValueError("Cannot get key from list or tuple without a parent dictionary")
                         return next(key for key, value in parent.items() if value is data)
                     parent = data
                     data = data[idx]
                 else:
-                    raise TypeError(f'Unsupported type {type(data)} at path {path[:i+1]}')
+                    raise TypeError(f"Unsupported type {type(data)} at path {path[:i+1]}")
             return data
+
         path = Data._sep_path_id(path_id)
         return get_nested(data, path, get_key)
 
     @staticmethod
-    def set_value_by_path_id(data:list|tuple|dict, update_values:str|list[str], sep:str = '::') -> list|tuple|dict:
+    def set_value_by_path_id(
+        data: list | tuple | dict,
+        update_values: str | list[str],
+        sep: str = "::",
+    ) -> list | tuple | dict:
         """Updates the value/s from `update_values` in the `data`.\n
         --------------------------------------------------------------------------------
         Input a list, tuple or dict as `data`, along with `update_values`, which is<br>
@@ -290,8 +348,10 @@ class Data:
         and the new value are separated by `sep`, which per default is `::`.\n
         --------------------------------------------------------------------------------
         The value from path-id will be changed to the new value, as long as the<br>
-        structure of `data` hasn't changed since creating the path-id to that value."""
-        def update_nested(data:list|tuple|dict, path:list[int], value:any) -> list|tuple|dict:
+        structure of `data` hasn't changed since creating the path-id to that value.
+        """
+
+        def update_nested(data: list | tuple | dict, path: list[int], value: any) -> list | tuple | dict:
             if len(path) == 1:
                 if isinstance(data, dict):
                     keys = list(data.keys())
@@ -309,33 +369,58 @@ class Data:
                 data[path[0]] = update_nested(data[path[0]], path[1:], value)
                 data = type(data)(data)
             return data
+
         if isinstance(update_values, str):
             update_values = [update_values]
-        valid_entries = [(parts[0].strip(), parts[1]) for update_value in update_values if len(parts := update_value.split(str(sep).strip())) == 2]
+        valid_entries = [
+            (parts[0].strip(), parts[1])
+            for update_value in update_values
+            if len(parts := update_value.split(str(sep).strip())) == 2
+        ]
         if not valid_entries:
-            raise ValueError(f'No valid update_values found: {update_values}')
-        path, new_values = (zip(*valid_entries) if valid_entries else ([], []))
+            raise ValueError(f"No valid update_values found: {update_values}")
+        path, new_values = zip(*valid_entries) if valid_entries else ([], [])
         for path_id, new_val in zip(path, new_values):
             path = Data._sep_path_id(path_id)
             data = update_nested(data, path, new_val)
         return data
 
     @staticmethod
-    def print(data:list|tuple|dict, indent:int = 2, compactness:int = 1, sep:str = ', ', max_width:int = 140, as_json:bool = False, end:str = '\n') -> None:
-      """Print nicely formatted data structures.\n
-      ------------------------------------------------------------------------------------
-      The indentation spaces-amount can be set with with `indent`.<br>
-      There are three different levels of `compactness`:<br>
-      `0` expands everything possible<br>
-      `1` only expands if there's other lists, tuples or dicts inside of data or,<br>
-       ⠀if the data's content is longer than `max_width`<br>
-      `2` keeps everything collapsed (all on one line)\n
-      ------------------------------------------------------------------------------------
-      If `as_json` is set to `True`, the output will be in valid JSON format."""
-      print(Data.to_str(data, indent, compactness, sep, max_width, as_json), end=end, flush=True)
+    def print(
+        data: list | tuple | dict,
+        indent: int = 2,
+        compactness: int = 1,
+        sep: str = ", ",
+        max_width: int = 140,
+        as_json: bool = False,
+        end: str = "\n",
+    ) -> None:
+        """Print nicely formatted data structures.\n
+        ------------------------------------------------------------------------------------
+        The indentation spaces-amount can be set with with `indent`.<br>
+        There are three different levels of `compactness`:<br>
+        `0` expands everything possible<br>
+        `1` only expands if there's other lists, tuples or dicts inside of data or,<br>
+         ⠀if the data's content is longer than `max_width`<br>
+        `2` keeps everything collapsed (all on one line)\n
+        ------------------------------------------------------------------------------------
+        If `as_json` is set to `True`, the output will be in valid JSON format.
+        """
+        print(
+            Data.to_str(data, indent, compactness, sep, max_width, as_json),
+            end=end,
+            flush=True,
+        )
 
     @staticmethod
-    def to_str(data:list|tuple|dict, indent:int = 2, compactness:int = 1, sep:str = ', ', max_width:int = 140, as_json:bool = False) -> str:
+    def to_str(
+        data: list | tuple | dict,
+        indent: int = 2,
+        compactness: int = 1,
+        sep: str = ", ",
+        max_width: int = 140,
+        as_json: bool = False,
+    ) -> str:
         """Get nicely formatted data structure-strings.\n
         ------------------------------------------------------------------------------------
         The indentation spaces-amount can be set with with `indent`.<br>
@@ -345,68 +430,105 @@ class Data:
          ⠀if the data's content is longer than `max_width`<br>
         `2` keeps everything collapsed (all on one line)\n
         ------------------------------------------------------------------------------------
-        If `as_json` is set to `True`, the output will be in valid JSON format."""
-        def escape_string(s:str, str_quotes:str = '"') -> str:
-            s = s.replace('\\', r'\\').replace('\n', r'\n').replace('\r', r'\r').replace('\t', r'\t').replace('\b', r'\b').replace('\f', r'\f').replace('\a', r'\a')
-            if str_quotes == '"': s = s.replace(r"\\'", "'").replace(r'"', r'\"')
-            elif str_quotes == "'": s = s.replace(r'\\"', '"').replace(r"'", r"\'")
+        If `as_json` is set to `True`, the output will be in valid JSON format.
+        """
+
+        def escape_string(s: str, str_quotes: str = '"') -> str:
+            s = (
+                s.replace("\\", r"\\")
+                .replace("\n", r"\n")
+                .replace("\r", r"\r")
+                .replace("\t", r"\t")
+                .replace("\b", r"\b")
+                .replace("\f", r"\f")
+                .replace("\a", r"\a")
+            )
+            if str_quotes == '"':
+                s = s.replace(r"\\'", "'").replace(r'"', r"\"")
+            elif str_quotes == "'":
+                s = s.replace(r'\\"', '"').replace(r"'", r"\'")
             return s
-        def format_value(value:any, current_indent:int) -> str:
+
+        def format_value(value: any, current_indent: int) -> str:
             if isinstance(value, dict):
                 return format_dict(value, current_indent + indent)
-            elif hasattr(value, '__dict__'):
+            elif hasattr(value, "__dict__"):
                 return format_dict(value.__dict__, current_indent + indent)
             elif isinstance(value, (list, tuple, set, frozenset)):
                 return format_sequence(value, current_indent + indent)
             elif isinstance(value, bool):
                 return str(value).lower() if as_json else str(value)
             elif isinstance(value, (int, float)):
-                return 'null' if as_json and (_math.isinf(value) or _math.isnan(value)) else str(value)
+                return "null" if as_json and (_math.isinf(value) or _math.isnan(value)) else str(value)
             elif isinstance(value, complex):
-                return f'[{value.real}, {value.imag}]' if as_json else str(value)
+                return f"[{value.real}, {value.imag}]" if as_json else str(value)
             elif value is None:
-                return 'null' if as_json else 'None'
+                return "null" if as_json else "None"
             else:
                 return '"' + escape_string(str(value), '"') + '"' if as_json else "'" + escape_string(str(value), "'") + "'"
-        def should_expand(seq:list|tuple|dict) -> bool:
-            if compactness == 0: return True
-            if compactness == 2: return False
+
+        def should_expand(seq: list | tuple | dict) -> bool:
+            if compactness == 0:
+                return True
+            if compactness == 2:
+                return False
             complex_items = sum(1 for item in seq if isinstance(item, (list, tuple, dict, set, frozenset)))
-            return complex_items > 1 or (complex_items == 1 and len(seq) > 1) or Data.chars_count(seq) + (len(seq) * len(sep)) > max_width
-        def format_key(k:any) -> str:
-            return '"' + escape_string(str(k), '"') + '"' if as_json else "'" + escape_string(str(k), "'") + "'" if isinstance(k, str) else str(k)
-        def format_dict(d:dict, current_indent:int) -> str:
+            return (
+                complex_items > 1
+                or (complex_items == 1 and len(seq) > 1)
+                or Data.chars_count(seq) + (len(seq) * len(sep)) > max_width
+            )
+
+        def format_key(k: any) -> str:
+            return (
+                '"' + escape_string(str(k), '"') + '"'
+                if as_json
+                else ("'" + escape_string(str(k), "'") + "'" if isinstance(k, str) else str(k))
+            )
+
+        def format_dict(d: dict, current_indent: int) -> str:
             if not d or compactness == 2:
-                return '{' + sep.join(f'{format_key(k)}: {format_value(v, current_indent)}' for k, v in d.items()) + '}'
+                return "{" + sep.join(f"{format_key(k)}: {format_value(v, current_indent)}" for k, v in d.items()) + "}"
             if not should_expand(d.values()):
-                return '{' + sep.join(f'{format_key(k)}: {format_value(v, current_indent)}' for k, v in d.items()) + '}'
+                return "{" + sep.join(f"{format_key(k)}: {format_value(v, current_indent)}" for k, v in d.items()) + "}"
             items = []
             for key, value in d.items():
                 formatted_value = format_value(value, current_indent)
                 items.append(f'{" " * (current_indent + indent)}{format_key(key)}: {formatted_value}')
-            return '{\n' + ',\n'.join(items) + f'\n{" " * current_indent}}}'
-        def format_sequence(seq, current_indent:int) -> str:
+            return "{\n" + ",\n".join(items) + f'\n{" " * current_indent}}}'
+
+        def format_sequence(seq, current_indent: int) -> str:
             if as_json:
                 seq = list(seq)
             if not seq or compactness == 2:
-                return '[' + sep.join(format_value(item, current_indent) for item in seq) + ']' if isinstance(seq, list) else '(' + sep.join(format_value(item, current_indent) for item in seq) + ')'
+                return (
+                    "[" + sep.join(format_value(item, current_indent) for item in seq) + "]"
+                    if isinstance(seq, list)
+                    else "(" + sep.join(format_value(item, current_indent) for item in seq) + ")"
+                )
             if not should_expand(seq):
-                return '[' + sep.join(format_value(item, current_indent) for item in seq) + ']' if isinstance(seq, list) else '(' + sep.join(format_value(item, current_indent) for item in seq) + ')'
+                return (
+                    "[" + sep.join(format_value(item, current_indent) for item in seq) + "]"
+                    if isinstance(seq, list)
+                    else "(" + sep.join(format_value(item, current_indent) for item in seq) + ")"
+                )
             items = [format_value(item, current_indent) for item in seq]
-            formatted_items = ',\n'.join(f'{" " * (current_indent + indent)}{item}' for item in items)
+            formatted_items = ",\n".join(f'{" " * (current_indent + indent)}{item}' for item in items)
             if isinstance(seq, list):
-                return '[\n' + formatted_items + f'\n{" " * current_indent}]'
+                return "[\n" + formatted_items + f'\n{" " * current_indent}]'
             else:
-                return '(\n' + formatted_items + f'\n{" " * current_indent})'
+                return "(\n" + formatted_items + f'\n{" " * current_indent})'
+
         return format_dict(data, 0) if isinstance(data, dict) else format_sequence(data, 0)
 
     @staticmethod
-    def _is_key(data:list|tuple|dict, path_id:str) -> bool:
+    def _is_key(data: list | tuple | dict, path_id: str) -> bool:
         """Returns `True` if the path-id points to a key in `data` and `False` otherwise.\n
         ------------------------------------------------------------------------------------
         Input a list, tuple or dict as `data`, along with `path_id`, which is a path-id<br>
         that was created before using `Object.get_path_id()`."""
-        def check_nested(data:list|tuple|dict, path:list[int]) -> bool:
+
+        def check_nested(data: list | tuple | dict, path: list[int]) -> bool:
             for i, idx in enumerate(path):
                 if isinstance(data, dict):
                     keys = list(data.keys())
@@ -416,16 +538,18 @@ class Data:
                 elif isinstance(data, (list, tuple)):
                     return False
                 else:
-                    raise TypeError(f'Unsupported type {type(data)} at path {path[:i+1]}')
+                    raise TypeError(f"Unsupported type {type(data)} at path {path[:i+1]}")
             return False
+
         if isinstance(data, (list, tuple)):
             return False
         path = Data._sep_path_id(path_id)
         return check_nested(data, path)
 
     @staticmethod
-    def _sep_path_id(path_id:str) -> list[int]:
-        if path_id.count('>') != 1:
-            raise ValueError(f'Invalid path-id: {path_id}')
-        id_part_len, path_ids_str = int(path_id.split('>')[0]), path_id.split('>')[1]
-        return [int(path_ids_str[i:i+id_part_len]) for i in range(0, len(path_ids_str), id_part_len)]
+    def _sep_path_id(path_id: str) -> list[int]:
+        if path_id.count(">") != 1:
+            raise ValueError(f"Invalid path-id: {path_id}")
+        id_part_len = int(path_id.split(">")[0])
+        path_ids_str = path_id.split(">")[1]
+        return [int(path_ids_str[i : i + id_part_len]) for i in range(0, len(path_ids_str), id_part_len)]

xulbux/xx_env_vars.py

@@ -5,56 +5,69 @@ Functions for modifying and checking the systems environment-variables:
 - `EnvVars.add_path()`
 """
 
-
 from .xx_data import *
 from .xx_path import *
 
 import os as _os
 
 
-
-
 class EnvVars:
 
     @staticmethod
-    def get_paths(as_list:bool = False) -> str|list:
-        paths = _os.environ.get('PATH')
+    def get_paths(as_list: bool = False) -> str | list:
+        paths = _os.environ.get("PATH")
         return paths.split(_os.pathsep) if as_list else paths
 
     @staticmethod
-    def has_path(path:str = None, cwd:bool = False, base_dir:bool = False) -> bool:
-        if cwd: path = _os.getcwd()
-        if base_dir: path = Path.get(base_dir=True)
+    def has_path(path: str = None, cwd: bool = False, base_dir: bool = False) -> bool:
+        if cwd:
+            path = _os.getcwd()
+        if base_dir:
+            path = Path.get(base_dir=True)
         paths = EnvVars.get_paths()
         return path in paths
 
     @staticmethod
-    def __add_sort_paths(add_path:str, current_paths:str) -> str:
-        final_paths = Data.remove_empty_items(Data.remove_duplicates(f'{add_path};{current_paths}'.split(_os.pathsep)))
+    def __add_sort_paths(add_path: str, current_paths: str) -> str:
+        final_paths = Data.remove_empty_items(Data.remove_duplicates(f"{add_path};{current_paths}".split(_os.pathsep)))
         final_paths.sort()
-        return f'{_os.pathsep.join(final_paths)};'
+        return f"{_os.pathsep.join(final_paths)};"
 
     @staticmethod
-    def add_path(add_path:str = None, cwd:bool = False, base_dir:bool = False, persistent:bool = True) -> None:
+    def add_path(
+        add_path: str = None,
+        cwd: bool = False,
+        base_dir: bool = False,
+        persistent: bool = True,
+    ) -> None:
         if cwd:
             add_path = _os.getcwd()
         if base_dir:
             add_path = Path.get(base_dir=True)
         if not EnvVars.has_path(add_path):
             final_paths = EnvVars.__add_sort_paths(add_path, EnvVars.get_paths())
-            _os.environ['PATH'] = final_paths
+            _os.environ["PATH"] = final_paths
             if persistent:
-                if _os.name == 'nt':  # Windows
+                if _os.name == "nt":  # Windows
                     try:
-                        import winreg
-                        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, 'Environment', 0, winreg.KEY_ALL_ACCESS)
-                        winreg.SetValueEx(key, 'PATH', 0, winreg.REG_EXPAND_SZ, final_paths)
-                        winreg.CloseKey(key)
-                    except ImportError: raise ImportError('Unable to make persistent changes on Windows.')
+                        import winreg as _winreg
+
+                        key = _winreg.OpenKey(
+                            _winreg.HKEY_CURRENT_USER,
+                            "Environment",
+                            0,
+                            _winreg.KEY_ALL_ACCESS,
+                        )
+                        _winreg.SetValueEx(key, "PATH", 0, _winreg.REG_EXPAND_SZ, final_paths)
+                        _winreg.CloseKey(key)
+                    except ImportError:
+                        raise ImportError("Unable to make persistent changes on Windows.")
                 else:  # UNIX-LIKE (Linux/macOS)
-                    shell_rc_file = _os.path.expanduser('~/.bashrc' if _os.path.exists(_os.path.expanduser('~/.bashrc')) else '~/.zshrc')
-                    with open(shell_rc_file, 'a') as f:
+                    shell_rc_file = _os.path.expanduser(
+                        "~/.bashrc" if _os.path.exists(_os.path.expanduser("~/.bashrc")) else "~/.zshrc"
+                    )
+                    with open(shell_rc_file, "a") as f:
                         f.write(f'\n# Added by XulbuX\nexport PATH="$PATH:{add_path}"\n')
-                    _os.system(f'source {shell_rc_file}')
+                    _os.system(f"source {shell_rc_file}")
         else:
-            raise ValueError(f'{add_path} is already in PATH.')
+            raise ValueError(f"{add_path} is already in PATH.")