xulbux 1.6.8__py3-none-any.whl → 1.7.0__py3-none-any.whl

xulbux/xx_data.py

@@ -2,13 +2,14 @@ from ._consts_ import COLOR
 from .xx_format_codes import FormatCodes
 from .xx_string import String
 
-from typing import TypeAlias, Optional, Union
+from typing import TypeAlias, Optional, Union, Any
 import base64 as _base64
 import math as _math
 import re as _re
 
 
 DataStructure: TypeAlias = Union[list, tuple, set, frozenset, dict]
+IndexIterable: TypeAlias = Union[list, tuple, set, frozenset]
 
 
 class Data:
@@ -42,16 +43,23 @@ class Data:
     @staticmethod
     def chars_count(data: DataStructure) -> int:
         """The sum of all the characters amount including the keys in dictionaries."""
+        chars_count = 0
         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)
+            for k, v in data.items():
+                chars_count += len(str(k)) + (Data.chars_count(v) if isinstance(v, DataStructure) else len(str(v)))
+        elif isinstance(data, IndexIterable):
+            for item in data:
+                chars_count += Data.chars_count(item) if isinstance(item, DataStructure) else len(str(item))
+        return chars_count
 
     @staticmethod
     def strip(data: DataStructure) -> DataStructure:
         """Removes leading and trailing whitespaces from the data structure's items."""
         if isinstance(data, dict):
-            return {k: Data.strip(v) for k, v in data.items()}
-        return type(data)(map(Data.strip, data))
+            return {k.strip(): Data.strip(v) if isinstance(v, DataStructure) else v.strip() for k, v in data.items()}
+        if isinstance(data, IndexIterable):
+            return type(data)(Data.strip(item) if isinstance(item, DataStructure) else item.strip() for item in data)
+        return data
 
     @staticmethod
     def remove_empty_items(data: DataStructure, spaces_are_empty: bool = False) -> DataStructure:
@@ -59,18 +67,15 @@ class Data:
         If `spaces_are_empty` is true, it will count items with only spaces as empty."""
         if isinstance(data, dict):
             return {
-                k: (
-                    v if not isinstance(v,
-                                        (list, tuple, set, frozenset, dict)) else Data.remove_empty_items(v, spaces_are_empty)
-                )
+                k: (v if not isinstance(v, DataStructure) else Data.remove_empty_items(v, spaces_are_empty))
                 for k, v in data.items() if not String.is_empty(v, spaces_are_empty)
             }
-        if isinstance(data, (list, tuple, set, frozenset)):
+        if isinstance(data, IndexIterable):
             return type(data)(
-                item for item in ((
-                    item if not isinstance(item, (list, tuple, set, frozenset,
-                                                  dict)) else Data.remove_empty_items(item, spaces_are_empty)
-                ) for item in data if not String.is_empty(item, spaces_are_empty)) if item not in ((), {}, set(), frozenset())
+                item for item in
+                ((item if not isinstance(item, DataStructure) else Data.remove_empty_items(item, spaces_are_empty))
+                 for item in data if not String.is_empty(item, spaces_are_empty))
+                if item not in ([], (), {}, set(), frozenset())
             )
         return data
 
@@ -78,17 +83,25 @@ class Data:
     def remove_duplicates(data: DataStructure) -> DataStructure:
         """Removes all duplicates from the data structure."""
         if isinstance(data, dict):
-            return {k: Data.remove_duplicates(v) for k, v in data.items()}
+            return {k: Data.remove_duplicates(v) if isinstance(v, DataStructure) else v for k, v in data.items()}
         if isinstance(data, (list, tuple)):
-            return type(data)(
-                Data.remove_duplicates(item) if isinstance(item, (list, tuple, set, frozenset, dict)) else item
-                for item in dict.fromkeys(data)
-            )
+            result = []
+            for item in data:
+                processed_item = Data.remove_duplicates(item) if isinstance(item, DataStructure) else item
+                is_duplicate = False
+                for existing_item in result:
+                    if processed_item == existing_item:
+                        is_duplicate = True
+                        break
+                if not is_duplicate:
+                    result.append(processed_item)
+            return type(data)(result)
         if isinstance(data, (set, frozenset)):
-            return type(data)(
-                Data.remove_duplicates(item) if isinstance(item, (list, tuple, set, frozenset, dict)) else item
-                for item in data
-            )
+            processed_elements = set()
+            for item in data:
+                processed_item = Data.remove_duplicates(item) if isinstance(item, DataStructure) else item
+                processed_elements.add(processed_item)
+            return type(data)(processed_elements)
         return data
 
     @staticmethod
@@ -153,7 +166,7 @@ class Data:
 
         def process_string(s: str) -> Optional[str]:
             if comment_end:
-                match = pattern.match(s)
+                match = pattern.match(s)  # type: ignore[unbound]
                 if match:
                     start, end = match.group(1).strip(), match.group(2).strip()
                     return f"{start}{comment_sep if start and end else ''}{end}" or None
@@ -161,13 +174,13 @@ class Data:
             else:
                 return None if s.lstrip().startswith(comment_start) else s.strip() or None
 
-        def process_item(item: any) -> any:
+        def process_item(item: Any) -> Any:
             if isinstance(item, dict):
                 return {
                     k: v
                     for k, v in ((process_item(key), process_item(value)) for key, value in item.items()) if k is not None
                 }
-            if isinstance(item, (list, tuple, set, frozenset)):
+            if isinstance(item, IndexIterable):
                 processed = (v for v in map(process_item, item) if v is not None)
                 return type(item)(processed)
             if isinstance(item, str):
@@ -210,7 +223,7 @@ class Data:
                 return True
             if type(d1) is not type(d2):
                 return False
-            if isinstance(d1, dict):
+            if isinstance(d1, dict) and isinstance(d2, dict):
                 if set(d1.keys()) != set(d2.keys()):
                     return False
                 return all(compare(d1[key], d2[key], ignore_paths, current_path + [key]) for key in d1)
@@ -238,7 +251,7 @@ class Data:
         comment_start: str = ">>",
         comment_end: str = "<<",
         ignore_not_found: bool = False,
-    ) -> str | list[str]:
+    ) -> Optional[str | list[Optional[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
@@ -283,7 +296,7 @@ class Data:
                         if ignore_not_found:
                             return None
                         raise KeyError(f"Key '{key}' not found in dict.")
-                elif isinstance(data_obj, (list, tuple, set, frozenset)):
+                elif isinstance(data_obj, IndexIterable):
                     try:
                         idx = int(key)
                         data_obj = list(data_obj)[idx]  # CONVERT TO LIST FOR INDEXING
@@ -310,7 +323,7 @@ class Data:
         return results if len(results) > 1 else results[0] if results else None
 
     @staticmethod
-    def get_value_by_path_id(data: DataStructure, path_id: str, get_key: bool = False) -> any:
+    def get_value_by_path_id(data: DataStructure, path_id: str, get_key: bool = False) -> Any:
         """Retrieves the value from `data` using the provided `path_id`.\n
         -------------------------------------------------------------------------------------------------
         Input your `data` along with a `path_id` that was created before using `Data.get_path_id()`.
@@ -319,7 +332,7 @@ class Data:
         The function will return the value (or key) from the path ID location, as long as the structure
         of `data` hasn't changed since creating the path ID to that value."""
 
-        def get_nested(data: DataStructure, path: list[int], get_key: bool) -> any:
+        def get_nested(data: DataStructure, path: list[int], get_key: bool) -> Any:
             parent = None
             for i, idx in enumerate(path):
                 if isinstance(data, dict):
@@ -328,7 +341,7 @@ class Data:
                         return keys[idx]
                     parent = data
                     data = data[keys[idx]]
-                elif isinstance(data, (list, tuple, set, frozenset)):
+                elif isinstance(data, IndexIterable):
                     if i == len(path) - 1 and get_key:
                         if parent is None or not isinstance(parent, dict):
                             raise ValueError("Cannot get key from a non-dict parent")
@@ -342,45 +355,39 @@ class Data:
         return get_nested(data, Data.__sep_path_id(path_id), get_key)
 
     @staticmethod
-    def set_value_by_path_id(data: DataStructure, update_values: str | list[str], sep: str = "::") -> list | tuple | dict:
+    def set_value_by_path_id(data: DataStructure, update_values: dict[str, Any]) -> DataStructure:
         """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 a
-        path ID that was created before using `Data.get_path_id()`, together with the
-        new value to be inserted where the path ID points to. The path ID and the new
-        value are separated by `sep`, which per default is `::`.\n
+        dictionary where keys are path IDs and values are the new values to insert:
+           { "1>012": "new value", "1>31": ["new value 1", "new value 2"], ... }
+        The path IDs should have been created using `Data.get_path_id()`.\n
         --------------------------------------------------------------------------------
         The value from path ID will be changed to the new value, as long as the
         structure of `data` hasn't changed since creating the path ID to that value."""
 
-        def update_nested(data: DataStructure, path: list[int], value: any) -> DataStructure:
+        def update_nested(data: DataStructure, path: list[int], value: Any) -> DataStructure:
             if len(path) == 1:
                 if isinstance(data, dict):
-                    keys = list(data.keys())
-                    data = dict(data)
+                    keys, data = list(data.keys()), dict(data)
                     data[keys[path[0]]] = value
-                elif isinstance(data, (list, tuple, set, frozenset)):
-                    data = list(data)
+                elif isinstance(data, IndexIterable):
+                    was_t, data = type(data), list(data)
                     data[path[0]] = value
-                    data = type(data)(data)
+                    data = was_t(data)
             else:
                 if isinstance(data, dict):
-                    keys = list(data.keys())
-                    key = keys[path[0]]
-                    data = dict(data)
-                    data[key] = update_nested(data[key], path[1:], value)
-                elif isinstance(data, (list, tuple, set, frozenset)):
-                    data = list(data)
+                    keys, data = list(data.keys()), dict(data)
+                    data[keys[path[0]]] = update_nested(data[keys[path[0]]], path[1:], value)
+                elif isinstance(data, IndexIterable):
+                    was_t, data = type(data), list(data)
                     data[path[0]] = update_nested(data[path[0]], path[1:], value)
-                    data = type(data)(data)
+                    data = was_t(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 = [(path_id, new_val) for path_id, new_val in update_values.items()]
         if not valid_entries:
-            raise ValueError(f"No valid update_values found: {update_values}")
+            raise ValueError(f"No valid update_values found in dictionary: {update_values}")
         for path_id, new_val in valid_entries:
             path = Data.__sep_path_id(path_id)
             data = update_nested(data, path, new_val)
@@ -406,7 +413,8 @@ class Data:
         - `2` keeps everything collapsed (all on one line)\n
         ------------------------------------------------------------------------------
         If `as_json` is set to `True`, the output will be in valid JSON format."""
-        if syntax_hl := _syntax_highlighting not in (None, False):
+        _syntax_hl = {}
+        if do_syntax_hl := _syntax_highlighting not in (None, False):
             if _syntax_highlighting is True:
                 _syntax_highlighting = {}
             elif not isinstance(_syntax_highlighting, dict):
@@ -419,62 +427,62 @@ class Data:
                 "punctuation": (f"[{COLOR.darkgray}]", "[_c]"),
             }
             _syntax_hl.update({
-                k: [f"[{v}]", "[_]"] if k in _syntax_hl and v not in ("", None) else ["", ""]
+                k: (f"[{v}]", "[_]") if k in _syntax_hl and v not in ("", None) else ("", "")
                 for k, v in _syntax_highlighting.items()
             })
             sep = f"{_syntax_hl['punctuation'][0]}{sep}{_syntax_hl['punctuation'][1]}"
         punct_map = {"(": ("/(", "("), **{char: char for char in "'\":)[]{}"}}
         punct = {
-            k: ((f"{_syntax_hl['punctuation'][0]}{v[0]}{_syntax_hl['punctuation'][1]}" if syntax_hl else v[1])
+            k: ((f"{_syntax_hl['punctuation'][0]}{v[0]}{_syntax_hl['punctuation'][1]}" if do_syntax_hl else v[1])
                 if isinstance(v, (list, tuple)) else
-                (f"{_syntax_hl['punctuation'][0]}{v}{_syntax_hl['punctuation'][1]}" if syntax_hl else v))
+                (f"{_syntax_hl['punctuation'][0]}{v}{_syntax_hl['punctuation'][1]}" if do_syntax_hl else v))
             for k, v in punct_map.items()
         }
 
-        def format_value(value: any, current_indent: int = None) -> str:
+        def format_value(value: Any, current_indent: Optional[int] = None) -> str:
             if current_indent is not None and isinstance(value, dict):
                 return format_dict(value, current_indent + indent)
             elif current_indent is not None and hasattr(value, "__dict__"):
                 return format_dict(value.__dict__, current_indent + indent)
-            elif current_indent is not None and isinstance(value, (list, tuple, set, frozenset)):
+            elif current_indent is not None and isinstance(value, IndexIterable):
                 return format_sequence(value, current_indent + indent)
-            elif isinstance(value, (bytes, bytearray)):
+            elif current_indent is not None and isinstance(value, (bytes, bytearray)):
                 obj_dict = Data.serialize_bytes(value)
                 return (
                     format_dict(obj_dict, current_indent + indent) if as_json else (
                         f"{_syntax_hl['type'][0]}{(k := next(iter(obj_dict)))}{_syntax_hl['type'][1]}"
-                        + format_sequence((obj_dict[k], obj_dict["encoding"]), current_indent + indent) if syntax_hl else
+                        + format_sequence((obj_dict[k], obj_dict["encoding"]), current_indent + indent) if do_syntax_hl else
                         (k := next(iter(obj_dict)))
                         + format_sequence((obj_dict[k], obj_dict["encoding"]), current_indent + indent)
                     )
                 )
             elif isinstance(value, bool):
                 val = str(value).lower() if as_json else str(value)
-                return f"{_syntax_hl['literal'][0]}{val}{_syntax_hl['literal'][1]}" if syntax_hl else val
+                return f"{_syntax_hl['literal'][0]}{val}{_syntax_hl['literal'][1]}" if do_syntax_hl else val
             elif isinstance(value, (int, float)):
                 val = "null" if as_json and (_math.isinf(value) or _math.isnan(value)) else str(value)
-                return f"{_syntax_hl['number'][0]}{val}{_syntax_hl['number'][1]}" if syntax_hl else val
-            elif isinstance(value, complex):
+                return f"{_syntax_hl['number'][0]}{val}{_syntax_hl['number'][1]}" if do_syntax_hl else val
+            elif current_indent is not None and isinstance(value, complex):
                 return (
                     format_value(str(value).strip("()")) if as_json else (
                         f"{_syntax_hl['type'][0]}complex{_syntax_hl['type'][1]}"
                         + format_sequence((value.real, value.imag), current_indent + indent)
-                        if syntax_hl else f"complex{format_sequence((value.real, value.imag), current_indent + indent)}"
+                        if do_syntax_hl else f"complex{format_sequence((value.real, value.imag), current_indent + indent)}"
                     )
                 )
             elif value is None:
                 val = "null" if as_json else "None"
-                return f"{_syntax_hl['literal'][0]}{val}{_syntax_hl['literal'][1]}" if syntax_hl else val
+                return f"{_syntax_hl['literal'][0]}{val}{_syntax_hl['literal'][1]}" if do_syntax_hl else val
             else:
                 return ((
                     punct['"'] + _syntax_hl["str"][0] + String.escape(str(value), '"') + _syntax_hl["str"][1]
-                    + punct['"'] if syntax_hl else punct['"'] + String.escape(str(value), '"') + punct['"']
+                    + punct['"'] if do_syntax_hl else punct['"'] + String.escape(str(value), '"') + punct['"']
                 ) if as_json else (
                     punct["'"] + _syntax_hl["str"][0] + String.escape(str(value), "'") + _syntax_hl["str"][1]
-                    + punct["'"] if syntax_hl else punct["'"] + String.escape(str(value), "'") + punct["'"]
+                    + punct["'"] if do_syntax_hl else punct["'"] + String.escape(str(value), "'") + punct["'"]
                 ))
 
-        def should_expand(seq: list | tuple | dict) -> bool:
+        def should_expand(seq: IndexIterable) -> bool:
             if compactness == 0:
                 return True
             if compactness == 2:
@@ -493,7 +501,7 @@ class Data:
                     + sep.join(f"{format_value(k)}{punct[':']} {format_value(v, current_indent)}"
                                for k, v in d.items()) + punct["}"]
                 )
-            if not should_expand(d.values()):
+            if not should_expand(list(d.values())):
                 return (
                     punct["{"]
                     + sep.join(f"{format_value(k)}{punct[':']} {format_value(v, current_indent)}"

xulbux/xx_env_path.py

@@ -1,9 +1,6 @@
-"""
-Functions for modifying and checking the systems environment-variables (especially the PATH object).
-"""
-
 from .xx_path import Path
 
+from typing import Optional
 import sys as _sys
 import os as _os
 
@@ -17,7 +14,7 @@ class EnvPath:
         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:
+    def has_path(path: Optional[str] = None, cwd: bool = False, base_dir: bool = False) -> bool:
         """Check if a path is present in the PATH environment variable."""
         if cwd:
             path = _os.getcwd()
@@ -29,21 +26,21 @@ class EnvPath:
         return _os.path.normpath(path) in [_os.path.normpath(p) for p in paths]
 
     @staticmethod
-    def add_path(path: str = None, cwd: bool = False, base_dir: bool = False) -> None:
+    def add_path(path: Optional[str] = None, cwd: bool = False, base_dir: bool = False) -> None:
         """Add a path to the PATH environment variable."""
         path = EnvPath.__get(path, cwd, base_dir)
         if not EnvPath.has_path(path):
             EnvPath.__persistent(path, add=True)
 
     @staticmethod
-    def remove_path(path: str = None, cwd: bool = False, base_dir: bool = False) -> None:
+    def remove_path(path: Optional[str] = None, cwd: bool = False, base_dir: bool = False) -> None:
         """Remove a path from the PATH environment variable."""
         path = EnvPath.__get(path, cwd, base_dir)
         if EnvPath.has_path(path):
             EnvPath.__persistent(path, remove=True)
 
     @staticmethod
-    def __get(path: str = None, cwd: bool = False, base_dir: bool = False) -> list:
+    def __get(path: Optional[str] = None, cwd: bool = False, base_dir: bool = False) -> str:
         """Get and/or normalize the paths.\n
         ------------------------------------------------------------------------------------
         Raise an error if no path is provided and neither `cwd` or `base_dir` is `True`."""
@@ -60,7 +57,7 @@ class EnvPath:
         """Add or remove a path from PATH persistently across sessions as well as the current session."""
         if add == remove:
             raise ValueError("Either add or remove must be True, but not both.")
-        current_paths = EnvPath.paths(as_list=True)
+        current_paths = list(EnvPath.paths(as_list=True))
         path = _os.path.normpath(path)
         if remove:
             current_paths = [p for p in current_paths if _os.path.normpath(p) != _os.path.normpath(path)]

xulbux/xx_file.py

@@ -1,25 +1,42 @@
 from .xx_string import String
-from .xx_path import Path
 
 import os as _os
 
 
 class SameContentFileExistsError(FileExistsError):
-    pass
+    ...
 
 
 class File:
 
     @staticmethod
-    def rename_extension(file: str, new_extension: str, camel_case_filename: bool = False) -> str:
+    def rename_extension(
+        file: str,
+        new_extension: str,
+        full_extension: bool = False,
+        camel_case_filename: bool = False,
+    ) -> str:
         """Rename the extension of a file.\n
         --------------------------------------------------------------------------
+        If `full_extension` is true, everything after the first dot in the
+        filename will be treated as the extension to replace (e.g. `.tar.gz`).
+        Otherwise, only the part after the last dot is replaced (e.g. `.gz`).\n
         If the `camel_case_filename` parameter is true, the filename will be made
         CamelCase in addition to changing the files extension."""
-        directory, filename_with_ext = _os.path.split(file)
-        filename = filename_with_ext.split(".")[0]
+        normalized_file = _os.path.normpath(file)
+        directory, filename_with_ext = _os.path.split(normalized_file)
+        if full_extension:
+            try:
+                first_dot_index = filename_with_ext.index('.')
+                filename = filename_with_ext[:first_dot_index]
+            except ValueError:
+                filename = filename_with_ext
+        else:
+            filename, _ = _os.path.splitext(filename_with_ext)
         if camel_case_filename:
             filename = String.to_camel_case(filename)
+        if new_extension and not new_extension.startswith('.'):
+            new_extension = '.' + new_extension
         return _os.path.join(directory, f"{filename}{new_extension}")
 
     @staticmethod
@@ -40,24 +57,3 @@ class File:
             f.write(content)
         full_path = _os.path.abspath(file)
         return full_path
-
-    @staticmethod
-    def extend_or_make_path(
-        file: str,
-        search_in: str | list[str] = None,
-        prefer_base_dir: bool = True,
-        correct_paths: bool = False,
-    ) -> str:
-        """Tries to find the file and extend the path to be absolute and if the file was not found:\n
-        Generate the absolute path to the file in the CWD or the running program's base-directory.\n
-        ----------------------------------------------------------------------------------------------
-        If the `file` is not found in predefined directories, it will be searched in the `search_in`
-        directory/directories. If the file is still not found, it will return the path to the file in
-        the base-dir per default or to the file in the CWD if `prefer_base_dir` is set to `False`.\n
-        ----------------------------------------------------------------------------------------------
-        If `correct_paths` is true, it is possible to have typos in the `search_in` path/s and it
-        will still find the file if it is under one of those paths."""
-        try:
-            return Path.extend(file, search_in, raise_error=True, correct_path=correct_paths)
-        except FileNotFoundError:
-            return _os.path.join(Path.script_dir, file) if prefer_base_dir else _os.path.join(_os.getcwd(), file)