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

xulbux/xx_env_path.py

@@ -0,0 +1,113 @@
+"""
+Functions for modifying and checking the systems environment-variables:
+- `EnvPath.paths()`
+- `EnvPath.has_path()`
+- `EnvPath.add_path()`
+- `EnvPath.remove_path()`
+"""
+
+from .xx_path import Path
+
+import os as _os
+import sys as _sys
+
+
+class EnvPath:
+
+    @staticmethod
+    def paths(as_list: bool = False) -> str | list:
+        """Get the PATH environment variable."""
+        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:
+        """Check if a path is present in the PATH environment variable."""
+        if cwd:
+            path = _os.getcwd()
+        elif base_dir:
+            path = Path.get(base_dir=True)
+        elif path is None:
+            raise ValueError("A path must be provided or either 'cwd' or 'base_dir' must be True.")
+        paths = EnvPath.paths(as_list=True)
+        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:
+        """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:
+        """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:
+        """Get and/or normalize the paths.<br>
+        Raise an error if no path is provided and<br>
+        neither `cwd` or `base_dir` is `True`."""
+        if cwd:
+            path = _os.getcwd()
+        elif base_dir:
+            path = Path.get(base_dir=True)
+        elif path is None:
+            raise ValueError("A path must be provided or either 'cwd' or 'base_dir' must be True.")
+        return _os.path.normpath(path)
+
+    @staticmethod
+    def __persistent(path: str, add: bool = False, remove: bool = False) -> None:
+        """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)
+        path = _os.path.normpath(path)
+        if remove:
+            current_paths = [p for p in current_paths if _os.path.normpath(p) != _os.path.normpath(path)]
+        elif add:
+            current_paths.append(path)
+        _os.environ["PATH"] = new_path = _os.pathsep.join(sorted(set(filter(bool, current_paths))))
+        if _sys.platform == "win32":  # Windows
+            try:
+                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, new_path)
+                _winreg.CloseKey(key)
+            except ImportError:
+                print("Warning: 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, "r+") as f:
+                content = f.read()
+                f.seek(0)
+                if remove:
+                    new_content = [line for line in content.splitlines() if not line.endswith(f':{path}"')]
+                    f.write("\n".join(new_content))
+                else:
+                    f.write(f'{content.rstrip()}\n# Added by XulbuX\nexport PATH="{new_path}"\n')
+                f.truncate()
+            _os.system(f"source {shell_rc_file}")

xulbux/xx_file.py

@@ -1,34 +1,11 @@
-from .xx_string import *
-from .xx_path import *
+from .xx_string import String
+from .xx_path import Path
 
 import os as _os
 
 
 class File:
 
-    @staticmethod
-    def _make_path(
-        filename: str,
-        filetype: str,
-        search_in: str | list[str] = None,
-        prefer_base_dir: bool = True,
-        correct_path: bool = False,
-    ) -> str:
-        """Get the path to a file in the cwd, the base-dir, or predefined directories.\n
-        --------------------------------------------------------------------------------------
-        If the `filename` is not found in the above directories, it will be searched<br>
-        in the `search_in` directory/directories. If the file is still not found, it will<br>
-        return the path to the file in the base-dir per default or to the file in the<br>
-        cwd if `prefer_base_dir` is set to `False`."""
-        if not filename.lower().endswith(f".{filetype.lower()}"):
-            filename = f"{filename}.{filetype.lower()}"
-        try:
-            return Path.extend(filename, search_in, True, correct_path)
-        except FileNotFoundError:
-            return (
-                _os.path.join(Path.get(base_dir=True), filename) if prefer_base_dir else _os.path.join(_os.getcwd(), filename)
-            )
-
     @staticmethod
     def rename_extension(file_path: str, new_extension: str) -> str:
         directory, filename_with_ext = _os.path.split(file_path)
@@ -54,3 +31,26 @@ class File:
             f.write(content)
         full_path = _os.path.abspath(file)
         return full_path
+
+    @staticmethod
+    def make_path(
+        filename: str,
+        filetype: str,
+        search_in: str | list[str] = None,
+        prefer_base_dir: bool = True,
+        correct_path: bool = False,
+    ) -> str:
+        """Create the path to a file in the cwd, the base-dir, or predefined directories.\n
+        --------------------------------------------------------------------------------------
+        If the `filename` is not found in the above directories, it will be searched<br>
+        in the `search_in` directory/directories. If the file is still not found, it will<br>
+        return the path to the file in the base-dir per default or to the file in the<br>
+        cwd if `prefer_base_dir` is set to `False`."""
+        if not filename.lower().endswith(f".{filetype.lower()}"):
+            filename = f"{filename}.{filetype.lower()}"
+        try:
+            return Path.extend(filename, search_in, True, correct_path)
+        except FileNotFoundError:
+            return (
+                _os.path.join(Path.get(base_dir=True), filename) if prefer_base_dir else _os.path.join(_os.getcwd(), filename)
+            )

xulbux/xx_format_codes.py

@@ -68,10 +68,9 @@ Per default, you can also use `+` and `-` to get lighter and darker `default_col
 """
 
 from ._consts_ import ANSI
-from .xx_string import *
-from .xx_regex import *
+from .xx_string import String
+from .xx_regex import Regex
 from .xx_color import *
-from .xx_data import *
 
 from functools import lru_cache
 import ctypes as _ctypes
@@ -125,7 +124,8 @@ class FormatCodes:
     def to_ansi(
         string: str, default_color: hexa | rgba = None, brightness_steps: int = 20, _default_start: bool = True
     ) -> str:
-        result = ""
+        result, bg_kwd, color_pref = string, {"bg"}, {"br", "bright"}
+
         if Color.is_valid_rgba(default_color, False):
             use_default = True
         elif Color.is_valid_hexa(default_color, False):
@@ -136,32 +136,48 @@ class FormatCodes:
             string = COMPILED["*"].sub(r"[\1_|default\2]", string)  # REPLACE `[…|*|…]` WITH `[…|_|default|…]`
             string = COMPILED["*color"].sub(r"[\1default\2]", string)  # REPLACE `[…|*color|…]` WITH `[…|default|…]`
 
+        def is_valid_color(color: str) -> bool:
+            return color in ANSI.color_map or Color.is_valid_rgba(color) or Color.is_valid_hexa(color)
+
         def replace_keys(match: _re.Match) -> str:
-            format_keys = match.group(1)
-            esc = match.group(2)
+            formats = match.group(1)
+            escaped = match.group(2)
             auto_reset_txt = match.group(3)
-            if not format_keys:
+            if auto_reset_txt and auto_reset_txt.count("[") > 0 and auto_reset_txt.count("]") > 0:
+                auto_reset_txt = FormatCodes.to_ansi(auto_reset_txt, default_color, brightness_steps, False)
+            if not formats:
                 return match.group(0)
-            format_keys = [k.strip() for k in format_keys.split("|") if k.strip()]
-            ansi_formats = [FormatCodes.__get_replacement(k, default_color, brightness_steps) for k in format_keys]
-            if auto_reset_txt and not esc:
-                reset_keys = [
-                    (
-                        "_color"
-                        if k in ANSI.color_map or Color.is_valid_rgba(k) or Color.is_valid_hexa(k)
-                        else (
-                            "_bg"
-                            if ({"bg", "bright", "br"} & set(k.lower().split(":")))
-                            and len(k.split(":")) <= 3
-                            and any(
-                                k[i:] in ANSI.color_map or Color.is_valid_rgba(k[i:]) or Color.is_valid_hexa(k[i:])
-                                for i in range(len(k))
-                            )
-                            else f"_{k}"
-                        )
-                    )
-                    for k in format_keys
-                ]
+            if formats.count("[") > 0 and formats.count("]") > 0:
+                formats = FormatCodes.to_ansi(formats, default_color, brightness_steps, False)
+            format_keys = [k.strip() for k in formats.split("|") if k.strip()]
+            ansi_formats = [
+                r if (r := FormatCodes.__get_replacement(k, default_color, brightness_steps)) != k else f"[{k}]"
+                for k in format_keys
+            ]
+            if auto_reset_txt and not escaped:
+                reset_keys = []
+                for k in format_keys:
+                    k_lower = k.lower()
+                    k_parts = k_lower.split(":")
+                    k_set = set(k_parts)
+                    if bg_kwd & k_set and len(k_parts) <= 3:
+                        if k_set & color_pref:
+                            for i in range(len(k)):
+                                if is_valid_color(k[i:]):
+                                    reset_keys.extend(["_bg", "_color"])
+                                    break
+                        else:
+                            for i in range(len(k)):
+                                if is_valid_color(k[i:]):
+                                    reset_keys.append("_bg")
+                                    break
+                    elif is_valid_color(k) or any(
+                        k_lower.startswith(pref_colon := f"{prefix}:") and is_valid_color(k[len(pref_colon) :])
+                        for prefix in color_pref
+                    ):
+                        reset_keys.append("_color")
+                    else:
+                        reset_keys.append(f"_{k}")
                 ansi_resets = [
                     r
                     for k in reset_keys
@@ -171,24 +187,27 @@ class FormatCodes:
                 ]
             else:
                 ansi_resets = []
-            if not all(f.startswith(f"{ANSI.char}{ANSI.start}") for f in 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
+            ):
                 return match.group(0)
             return (
                 "".join(ansi_formats)
                 + (
                     f"({FormatCodes.to_ansi(auto_reset_txt, default_color, brightness_steps, False)})"
-                    if esc and auto_reset_txt
+                    if escaped and auto_reset_txt
                     else auto_reset_txt if auto_reset_txt else ""
                 )
-                + ("" if esc else "".join(ansi_resets))
+                + ("" if escaped else "".join(ansi_resets))
             )
 
-        return (
-            (FormatCodes.__get_default_ansi(default_color) if _default_start else "")
-            + (result := "\n".join(COMPILED["format"].sub(replace_keys, line) for line in string.split("\n")))
-            if use_default
-            else result
-        )
+        result = "\n".join(COMPILED["format"].sub(replace_keys, line) for line in string.split("\n"))
+        return (FormatCodes.__get_default_ansi(default_color) if _default_start else "") + result if use_default else result
+
+    @staticmethod
+    def escape_ansi(ansi_string: str, escaped_char: str = ANSI.char_esc) -> str:
+        """Makes the string printable with the ANSI formats visible."""
+        return ansi_string.replace(ANSI.char, escaped_char)
 
     @staticmethod
     @lru_cache(maxsize=64)

xulbux/xx_json.py

@@ -1,5 +1,5 @@
-from .xx_data import *
-from .xx_file import *
+from .xx_data import Data
+from .xx_file import File
 
 import json as _json
 import os as _os
@@ -22,7 +22,7 @@ class Json:
         the the section from `comment_start` to `comment_end` is ignored.<br>
         If `return_original` is set to `True`, the original JSON is returned<br>
         additionally. (returns: `[processed_json, original_json]`)"""
-        file_path = File._make_path(json_file, "json", prefer_base_dir=True)
+        file_path = File.make_path(json_file, "json", prefer_base_dir=True)
         with open(file_path, "r") as f:
             content = f.read()
         try:
@@ -42,7 +42,7 @@ class Json:
         compactness: int = 1,
         force: bool = False,
     ) -> str:
-        file_path = File._make_path(new_file, "json", prefer_base_dir=True)
+        file_path = File.make_path(new_file, "json", prefer_base_dir=True)
         if _os.path.exists(file_path) and not force:
             with open(file_path, "r", encoding="utf-8") as existing_f:
                 existing_content = _json.load(existing_f)

xulbux/xx_regex.py

@@ -22,16 +22,14 @@ class Regex:
         **`quote`** the quote type (single or double)<br>
         **`string`** everything inside the found quote pair\n
         ------------------------------------------------------------------------------------
-        **Attention:** Requires non standard library `regex` not standard library `re`!
-        """
+        **Attention:** Requires non standard library `regex` not standard library `re`!"""
         return r'(?P<quote>[\'"])(?P<string>(?:\\.|(?!\g<quote>).)*?)\g<quote>'
 
     @staticmethod
     def brackets(bracket1: str = "(", bracket2: str = ")", is_group: bool = False) -> str:
         """Matches everything inside brackets, including other nested brackets.\n
         ------------------------------------------------------------------------------------
-        **Attention:** Requires non standard library `regex` not standard library `re`!
-        """
+        **Attention:** Requires non standard library `regex` not standard library `re`!"""
         g, b1, b2 = (
             "" if is_group else "?:",
             _re.escape(bracket1) if len(bracket1) == 1 else bracket1,
@@ -51,10 +49,10 @@ class Regex:
         is_group: bool = False,
     ) -> str:
         """Matches everything except `disallowed_pattern`, unless the `disallowed_pattern` is found inside a string (`'...'` or `"..."`).\n
-        ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-        The `ignore_pattern` is just always ignored. For example if `disallowed_pattern` is `>` and `ignore_pattern` is `->`, the `->`-arrows will be allowed, even though they have `>` in them.<br>
-        If `is_group` is `True`, you will be able to reference the matched content as a group (e.g. <code>match.group(<i>int</i>)</code> or <code>r'\\<i>int</i>'</code>).
-        """
+        ------------------------------------------------------------------------------------------------------------------------------------
+        The `ignore_pattern` is just always ignored. For example if `disallowed_pattern` is `>` and `ignore_pattern` is `->`, the `->`<br>
+        -arrows will be allowed, even though they have `>` in them. If `is_group` is `True`, you will be able to reference the matched<br>
+        content as a group (e.g. <code>match.group(<i>int</i>)</code> or <code>r'\\<i>int</i>'</code>)."""
         return rf'({"" if is_group else "?:"}(?:(?!{ignore_pattern}).)*(?:(?!{Regex.outside_strings(disallowed_pattern)}).)*)'
 
     @staticmethod
@@ -64,12 +62,11 @@ class Regex:
         **`2`** the function's arguments\n
         If no `func_name` is given, it will match any function call.\n
         ------------------------------------------------------------------------------------
-        **Attention:** Requires non standard library `regex` not standard library `re`!
-        """
+        **Attention:** Requires non standard library `regex` not standard library `re`!"""
         return r"(?<=\b)(" + (func_name if func_name else r"[\w_]+") + r")\s*" + Regex.brackets("(", ")", is_group=True)
 
     @staticmethod
-    def rgba_str(fix_sep: str = ",", allow_alpha: bool = False) -> str:
+    def rgba_str(fix_sep: str = ",", allow_alpha: bool = True) -> str:
         """Matches an RGBA color inside a string.\n
         --------------------------------------------------------------------------------
         The RGBA color can be in the formats (for `fix_sep = ','`):<br>
@@ -87,7 +84,7 @@ class Regex:
         `a` 0-1 (float: opacity)\n
         --------------------------------------------------------------------------------
         If the `fix_sep` is set to nothing, any char that is not a letter or number<br>
-        can be used to separate the RGB values, including just a space."""
+        can be used to separate the RGBA values, including just a space."""
         if fix_sep in (None, ""):
             fix_sep = r"[^0-9A-Z]"
         else:
@@ -105,7 +102,7 @@ class Regex:
         )
 
     @staticmethod
-    def hsla_str(fix_sep: str = ",", allow_alpha: bool = False) -> str:
+    def hsla_str(fix_sep: str = ",", allow_alpha: bool = True) -> str:
         """Matches a HSLA color inside a string.\n
         --------------------------------------------------------------------------------
         The HSLA color can be in the formats (for `fix_sep = ','`):<br>
@@ -123,7 +120,7 @@ class Regex:
         `a` 0-1 (float: opacity)\n
         --------------------------------------------------------------------------------
         If the `fix_sep` is set to nothing, any char that is not a letter or number<br>
-        can be used to separate the HSL values, including just a space."""
+        can be used to separate the HSLA values, including just a space."""
         if fix_sep in (None, ""):
             fix_sep = r"[^0-9A-Z]"
         else:
@@ -139,3 +136,21 @@ class Regex:
             if allow_alpha
             else rf"(?ix)(?:hsl|hsla)?\s*(?:\(?\s*{hsl_part}\s*\)?)"
         )
+
+    @staticmethod
+    def hexa_str(allow_alpha: bool = True) -> str:
+        """Matches a HEXA color inside a string.\n
+        --------------------------------------------------------------------------
+        The HEXA color can be in the formats (prefix `#`, `0x` or no prefix):<br>
+        `RGB`<br>
+        `RGBA` (if `allow_alpha=True`)<br>
+        `RRGGBB`<br>
+        `RRGGBBAA` (if `allow_alpha=True`)\n
+        --------------------------------------------------------------------------
+        ### Valid ranges:<br>
+        each channel from 0-9 and A-F (*case insensitive*)"""
+        return (
+            r"(?i)^(?:#|0x)?[0-9A-F]{8}|[0-9A-F]{6}|[0-9A-F]{4}|[0-9A-F]{3}$"
+            if allow_alpha
+            else r"(?i)^(?:#|0x)?[0-9A-F]{6}|[0-9A-F]{3}$"
+        )

xulbux/xx_string.py

@@ -5,36 +5,54 @@ class String:
 
     @staticmethod
     def to_type(string: str) -> any:
-        """Will convert a string to a type."""
-        if string.lower() in ("true", "false"):  # BOOLEAN
+        """Will convert a string to the found type."""
+        string = string.strip()  # Clean up whitespace
+        # BOOLEAN
+        if _re.match(r"(?i)^(true|false)$", string):
             return string.lower() == "true"
-        elif string.lower() in ("none", "null", "undefined"):  # NONE
+        # NONE
+        elif _re.match(r"(?i)^(none|null|undefined)$", string):
             return None
-        elif string.startswith("[") and string.endswith("]"):  # LIST
-            return [String.to_type(item.strip()) for item in string[1:-1].split(",") if item.strip()]
-        elif string.startswith("(") and string.endswith(")"):  # TUPLE
-            return tuple(String.to_type(item.strip()) for item in string[1:-1].split(",") if item.strip())
-        elif string.startswith("{") and string.endswith("}"):  # SET
-            return {String.to_type(item.strip()) for item in string[1:-1].split(",") if item.strip()}
-        elif string.startswith("{") and string.endswith("}") and ":" in string:  # DICTIONARY
+        # INTEGER
+        elif _re.match(r"^-?\d+$", string):
+            return int(string)
+        # FLOAT
+        elif _re.match(r"^-?\d+\.\d+$", string):
+            return float(string)
+        # COMPLEX
+        elif _re.match(r"^(-?\d+(\.\d+)?[+-]\d+(\.\d+)?j)$", string):
+            return complex(string)
+        # QUOTED STRING
+        elif _re.match(r'^["\'](.*)["\']$', string):
+            return string[1:-1]
+        # BYTES
+        elif _re.match(r"^b['\"](.*)['\"]$", string):
+            return bytes(string[2:-1], "utf-8")
+        # LIST
+        elif _re.match(r"^\[(.*)\]$", string):
+            return [
+                String.to_type(item.strip()) for item in _re.findall(r"(?:[^,\[\]]+|\[.*?\]|\(.*?\)|\{.*?\})+", string[1:-1])
+            ]
+        # TUPLE
+        elif _re.match(r"^\((.*)\)$", string):
+            return tuple(
+                String.to_type(item.strip()) for item in _re.findall(r"(?:[^,\(\)]+|\[.*?\]|\(.*?\)|\{.*?\})+", string[1:-1])
+            )
+        # DICTIONARY
+        elif _re.match(r"^\{(.*)\}$", string) and ":" in string:
             return {
                 String.to_type(k.strip()): String.to_type(v.strip())
-                for k, v in (item.split(":") for item in string[1:-1].split(",") if item.strip())
+                for k, v in _re.findall(
+                    r"((?:[^:,{}]+|\[.*?\]|\(.*?\)|\{.*?\})+)\s*:\s*((?:[^:,{}]+|\[.*?\]|\(.*?\)|\{.*?\})+)", string[1:-1]
+                )
             }
-        try:  # NUMBER (INT OR FLOAT)
-            if "." in string or "e" in string.lower():
-                return float(string)
-            else:
-                return int(string)
-        except ValueError:
-            pass
-        if string.startswith(("'", '"')) and string.endswith(("'", '"')):  # STRING (WITH OR WITHOUT QUOTES)
-            return string[1:-1]
-        try:  # COMPLEX
-            return complex(string)
-        except ValueError:
-            pass
-        return string  # IF NOTHING ELSE MATCHES, RETURN AS IS
+        # SET
+        elif _re.match(r"^\{(.*?)\}$", string):
+            return {
+                String.to_type(item.strip()) for item in _re.findall(r"(?:[^,{}]+|\[.*?\]|\(.*?\)|\{.*?\})+", string[1:-1])
+            }
+        # RETURN AS IS (str)
+        return string
 
     @staticmethod
     def normalize_spaces(string: str, tab_spaces: int = 4) -> str:
@@ -55,11 +73,39 @@ class String:
             .replace("\u200A", " ")
         )
 
+    @staticmethod
+    def escape(string: str, str_quotes: str = '"') -> str:
+        """Escapes the special characters and quotes inside a string.\n
+        ----------------------------------------------------------------------------
+        `str_quotes` can be either `"` or `'` and should match the quotes,<br>
+        the string will be put inside of. So if your string will be `"string"`,<br>
+        you should pass `"` to the parameter `str_quotes`.<br>
+        That way, if the string includes the same quotes, they will be escaped."""
+        string = (
+            string.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 == '"':
+            string = string.replace(r"\\'", "'").replace(r'"', r"\"")
+        elif str_quotes == "'":
+            string = string.replace(r'\\"', '"').replace(r"'", r"\'")
+        return string
+
+    @staticmethod
+    def is_empty(string: str, spaces_are_empty: bool = False):
+        """Returns `True` if the string is empty and `False` otherwise.<br>
+        If `spaces_are_empty` is true, it will also return `True` if the string is only spaces."""
+        return (string in (None, "")) or (spaces_are_empty and isinstance(string, str) and not string.strip())
+
     @staticmethod
     def single_char_repeats(string: str, char: str) -> int | bool:
         """If the string consists of only the same `char`, it returns the number of times it is present.<br>
-        If the string doesn't consist of only the same character, it returns `False`.
-        """
+        If the string doesn't consist of only the same character, it returns `False`."""
         if len(string) == len(char) * string.count(char):
             return string.count(char)
         else:
@@ -68,20 +114,27 @@ class String:
     @staticmethod
     def decompose(case_string: str, seps: str = "-_", lower_all: bool = True) -> list[str]:
         """Will decompose the string (*any type of casing, also mixed*) into parts."""
-        return [(part.lower() if lower_all else part) for part in _re.split(rf"(?<=[a-z])(?=[A-Z])|[{seps}]", case_string)]
+        return [
+            (part.lower() if lower_all else part)
+            for part in _re.split(rf"(?<=[a-z])(?=[A-Z])|[{_re.escape(seps)}]", case_string)
+        ]
 
     @staticmethod
-    def to_camel_case(string: str) -> str:
-        """Will convert the string of any type of casing to camel case."""
-        return "".join(part.capitalize() for part in String.decompose(string))
+    def to_camel_case(string: str, upper: bool = True) -> str:
+        """Will convert the string of any type of casing to UpperCamelCase or lowerCamelCase if `upper` is false."""
+        return (
+            (parts := String.decompose(string))[0].lower()
+            if upper
+            else "" + "".join(part.capitalize() for part in (parts[1:] if upper else parts))
+        )
 
     @staticmethod
-    def to_snake_case(string: str, sep: str = "_", screaming: bool = False) -> str:
-        """Will convert the string of any type of casing to snake case."""
-        return sep.join(part.upper() if screaming else part for part in String.decompose(string))
+    def to_delimited_case(string: str, delimiter: str = "_", screaming: bool = False) -> str:
+        """Will convert the string of any type of casing to casing delimited by `delimiter`."""
+        return delimiter.join(part.upper() if screaming else part for part in String.decompose(string))
 
     @staticmethod
-    def get_string_lines(string: str, remove_empty_lines: bool = False) -> list[str]:
+    def get_lines(string: str, remove_empty_lines: bool = False) -> list[str]:
         """Will split the string into lines."""
         if not remove_empty_lines:
             return string.splitlines()
@@ -99,46 +152,10 @@ class String:
         ----------------------------------------------------------------------------------------------
         If `max_consecutive` is `0`, it will remove all consecutive empty lines.<br>
         If `max_consecutive` is bigger than `0`, it will only allow `max_consecutive` consecutive<br>
-        empty lines and everything above it will be cut down to `max_consecutive` empty lines.
-        """
+        empty lines and everything above it will be cut down to `max_consecutive` empty lines."""
         return _re.sub(r"(\n\s*){2,}", r"\1" * (max_consecutive + 1), string)
 
     @staticmethod
     def split_count(string: str, count: int) -> list[str]:
         """Will split the string every `count` characters."""
         return [string[i : i + count] for i in range(0, len(string), count)]
-
-    @staticmethod
-    def multi_strip(string: str, strip_chars: str = " _-") -> str:
-        """Will remove all leading and trailing `strip_chars` from the string."""
-        for char in string:
-            if char in strip_chars:
-                string = string[1:]
-            else:
-                break
-        for char in string[::-1]:
-            if char in strip_chars:
-                string = string[:-1]
-            else:
-                break
-        return string
-
-    @staticmethod
-    def multi_lstrip(string: str, strip_chars: str = " _-") -> str:
-        """Will remove all leading `strip_chars` from the string."""
-        for char in string:
-            if char in strip_chars:
-                string = string[1:]
-            else:
-                break
-        return string
-
-    @staticmethod
-    def multi_rstrip(string: str, strip_chars: str = " _-") -> str:
-        """Will remove all trailing `strip_chars` from the string."""
-        for char in string[::-1]:
-            if char in strip_chars:
-                string = string[:-1]
-            else:
-                break
-        return string