xulbux 1.5.5__py3-none-any.whl

xulbux/xx_format_codes.py

@@ -0,0 +1,212 @@
+"""
+Functions to be able to use special (easy) formatting codes directly inside some message (string).<br>
+These codes, when used within following functions, will change the look of log within the console:
+- `FormatCodes.print()` (*print a special format-codes containing string*)
+- `FormatCodes.input()` (*input with a special format-codes containing prompt*)
+- `FormatCodes.to_ansi()` (*transform all special format-codes into ANSI codes in a string*)\n
+--------------------------------------------------------------------------------------------------------------------
+How to change the text format and color?<br>
+**Example string with formatting codes:**<br>
+> `[bold]This is bold text, [#F08]which is pink now [black|BG:#FF0088] and now it changed`<br>
+> `to black with a pink background. [_]And this is the boring text, where everything is reset.`\n
+⇾ **Instead of writing the formats all separate** `[…][…][…]` **you can join them like this** `[…|…|…]`\n
+--------------------------------------------------------------------------------------------------------------------
+You can also automatically reset a certain format, behind text like shown in the following example:<br>
+> `This is normal text [b](which is bold now) but now it was automatically reset to normal.`\n
+This will only reset formats, that have a reset listed below. Colors and BG-colors won't be reset.<br>
+This is what will happen, if you use it with a color-format:<br>
+> `[cyan]This is cyan text [b](which is bold now.) Now it's not bold any more but still cyan.`\n
+If you want to ignore the `()` brackets you can put a `\\` or `/` between:<br>
+> `[cyan]This is cyan text [b]/(which is bold now.) And now it is still bold and cyan.`\n
+⇾ **To see these examples in action, you can put them into the** `FormatCodes.print()` **function.**\n
+--------------------------------------------------------------------------------------------------------------------
+**All possible formatting codes:**
+- HEX colors:  `[#F08]` or `[#FF0088]` (*with or without leading #*)
+- RGB colors:  `[rgb(255, 0, 136)]`
+- bright colors:  `[bright:#F08]`
+- background colors:  `[BG:#F08]`
+- standard cmd colors:
+    - `[black]`
+    - `[red]`
+    - `[green]`
+    - `[yellow]`
+    - `[blue]`
+    - `[magenta]`
+    - `[cyan]`
+    - `[white]`
+- bright cmd colors: `[bright:black]` or `[br:black]`, `[bright:red]` or `[br:red]`, ...
+- background cmd colors: `[BG:black]`, `[BG:red]`, ...
+- bright background cmd colors: `[BG:bright:black]` or `[BG:br:black]`, `[BG:bright:red]` or `[BG:br:red]`, ...<br>
+    ⇾ **The order of** `BG:` **and** `bright:` or `br:` **does not matter.**
+- text formats:
+    - `[bold]` or `[b]`
+    - `[dim]`
+    - `[italic]` or `[i]`
+    - `[underline]` or `[u]`
+    - `[inverse]`, `[invert]` or `[in]`
+    - `[hidden]`, `[hide]` or `[h]`
+    - `[strikethrough]` or `[s]`
+    - `[double-underline]` or `[du]`
+- specific reset:  `[_bold]` or `[_b]`, `[_dim]`, ... or `[_color]` or `[_c]`, `[_background]` or `[_bg]`
+- total reset: `[_]` (only if no `default_color` is set, otherwise see **↓** )
+--------------------------------------------------------------------------------------------------------------------
+**Special formatting when param `default_color` is set to a color:**
+- `[*]` will reset everything, just like `[_]`, but the text-color will remain in `default_color`
+- `[*color]` will reset the text-color, just like `[_color]`, but then also make it `default_color`
+- `[default]` will just color the text in `default_color`,
+- `[BG:default]` will color the background in `default_color`\n
+Unlike the standard cmd colors, the default color can be changed by using the following modifiers:
+- `[l]` will lighten the `default_color` text by `brightness_steps`%
+- `[ll]` will lighten the `default_color` text by `2 × brightness_steps`%
+- `[lll]` will lighten the `default_color` text by `3 × brightness_steps`%
+- ... etc. Same thing for darkening:
+- `[d]` will darken the `default_color` text by `brightness_steps`%
+- `[dd]` will darken the `default_color` text by `2 × brightness_steps`%
+- `[ddd]` will darken the `default_color` text by `3 × brightness_steps`%
+- ... etc.\n
+Per default, you can also use `+` and `-` to get lighter and darker `default_color` versions.<br>
+This can also be changed by changing the param `_modifiers = ('+l', '-d')`.
+"""
+
+
+from ._consts_ import ANSI
+from .xx_string import *
+from .xx_regex import *
+from .xx_color import *
+from .xx_data import *
+
+import ctypes as _ctypes
+import regex as _rx
+import sys as _sys
+import re as _re
+
+
+
+
+class FormatCodes:
+
+    @staticmethod
+    def print(*values:object, default_color:hexa|rgba = None, brightness_steps:int = 20, sep:str = ' ', end:str = '\n') -> None:
+        FormatCodes.__config_console()
+        _sys.stdout.write(FormatCodes.to_ansi(sep.join(map(str, values)), default_color, brightness_steps) + end)
+        _sys.stdout.flush()
+
+    @staticmethod
+    def input(prompt:object = '', default_color:hexa|rgba = None, brightness_steps:int = 20) -> str:
+        FormatCodes.__config_console()
+        return input(FormatCodes.to_ansi(prompt, default_color, brightness_steps))
+
+    @staticmethod
+    def to_ansi(string:str, default_color:hexa|rgba = None, brightness_steps:int = 20, _default_start:bool = True) -> str:
+        result, use_default = '', default_color and (Color.is_valid_rgba(default_color, False) or Color.is_valid_hexa(default_color, False))
+        if use_default:
+            string = _re.sub(r'\[\s*([^]_]*?)\s*\*\s*([^]_]*?)\]', r'[\1_|default\2]', string)  # REPLACE `[…|*|…]` WITH `[…|_|default|…]`
+            string = _re.sub(r'\[\s*([^]_]*?)\s*\*color\s*([^]_]*?)\]', r'[\1default\2]', string)  # REPLACE `[…|*color|…]` WITH `[…|default|…]`
+        def replace_keys(match:_rx.Match) -> str:
+            format_keys, esc, auto_reset_txt = match.group(1), match.group(2), match.group(3)
+            if not format_keys:
+                return match.group(0)
+            else:
+                format_keys = [k.replace(' ', '') for k in format_keys.split('|') if k.replace(' ', '')]
+                ansi_resets, 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 Color.is_valid(k) or k in ANSI.color_map
+                        else '_bg' if (set(k.lower().split(':')) & {'bg', 'bright', 'br'} and len(k.split(':')) <= 3 and any(Color.is_valid(k[i:]) or k[i:] in ANSI.color_map for i in range(len(k))))
+                        else f'_{k}' for k in format_keys]
+                    ansi_resets = [r for k in reset_keys if (r := FormatCodes.__get_replacement(k, default_color, brightness_steps)).startswith(f'{ANSI.char}{ANSI.start}')]
+            if 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 else auto_reset_txt) if auto_reset_txt else '') + ('' if esc else ''.join(ansi_resets))
+        result = '\n'.join(_rx.sub(Regex.brackets('[', ']', is_group=True) + r'(?:\s*([/\\]?)\s*' + Regex.brackets('(', ')', is_group=True) + r')?', replace_keys, line) for line in string.splitlines())
+        return (FormatCodes.__get_default_ansi(default_color) if _default_start else '') + result if use_default else result
+
+    @staticmethod
+    def __config_console() -> None:
+        _sys.stdout.flush()
+        kernel32 = _ctypes.windll.kernel32
+        h = kernel32.GetStdHandle(-11)
+        mode = _ctypes.c_ulong()
+        kernel32.GetConsoleMode(h, _ctypes.byref(mode))
+        kernel32.SetConsoleMode(h, mode.value | 0x0004)  # ENABLE VIRTUAL TERMINAL PROCESSING
+
+    @staticmethod
+    def __get_default_ansi(default_color:hexa|rgba, format_key:str = None, brightness_steps:int = None, _modifiers:tuple[str,str] = ('+l', '-d')) -> str|None:
+        if Color.is_valid_hexa(default_color, False):
+            default_color = Color.to_rgba(default_color)
+        if not brightness_steps or (format_key and _re.search(r'(?i)((?:BG\s*:)?)\s*default', format_key)):
+            if format_key and _re.search(r'(?i)BG\s*:\s*default', format_key):
+                return ANSI.seq_bg_color.format(default_color[0], default_color[1], default_color[2])
+            return ANSI.seq_color.format(default_color[0], default_color[1], default_color[2])
+        match = _re.match(rf'(?i)((?:BG\s*:)?)\s*({"|".join([f"{_re.escape(m)}+" for m in _modifiers[0] + _modifiers[1]])})$', format_key)
+        if not match or not match.group(2):
+            return None
+        is_bg, modifier = match.group(1), match.group(2)
+        new_rgb, lighten, darken = None, None, None
+        for mod in _modifiers[0]:
+            lighten = String.get_repeated_symbol(modifier, mod)
+            if lighten and lighten > 0:
+                new_rgb = Color.adjust_lightness(default_color, (brightness_steps / 100) * lighten)
+                break
+        if not new_rgb:
+            for mod in _modifiers[1]:
+                darken = String.get_repeated_symbol(modifier, mod)
+                if darken and darken > 0:
+                    new_rgb = Color.adjust_lightness(default_color, -(brightness_steps / 100) * darken)
+                    break
+        if new_rgb:
+            return ANSI.seq_bg_color.format(new_rgb[0], new_rgb[1], new_rgb[2]) if is_bg else ANSI.seq_color.format(new_rgb[0], new_rgb[1], new_rgb[2])
+
+    @staticmethod
+    def __get_replacement(format_key:str, default_color:hexa|rgba = None, brightness_steps:int = 20, _modifiers:tuple[str, str] = ('+l', '-d')) -> str:
+        """Gives you the corresponding ANSI code for the given format key.<br>
+        If `default_color` is not `None`, the text color will be `default_color` if all formats<br>
+        are reset or you can get lighter or darker version of `default_color` (also as BG) by<br>
+        using one or more `_modifiers` symbols as a format key ()"""
+        def key_exists(key:str) -> bool:
+            for map_key in ANSI.codes_map:
+                if isinstance(map_key, tuple) and key in map_key:
+                    return True
+                elif key == map_key:
+                    return True
+            return False
+        def get_value(key:str) -> any:
+            for map_key in ANSI.codes_map:
+                if isinstance(map_key, tuple) and key in map_key:
+                    return ANSI.codes_map[map_key]
+                elif key == map_key:
+                    return ANSI.codes_map[map_key]
+            return None
+        use_default = default_color and (Color.is_valid_rgba(default_color, False) or Color.is_valid_hexa(default_color, False))
+        _format_key, format_key = format_key, FormatCodes.__normalize(format_key)
+        if use_default:
+            new_default_color = FormatCodes.__get_default_ansi(default_color, format_key, brightness_steps, _modifiers)
+            if new_default_color:
+                return new_default_color
+        if key_exists(format_key):
+            return ANSI.seq().format(get_value(format_key))
+        rgb_match = _re.match(r'(?i)\s*(BG\s*:)?\s*(?:rgb|rgba)?\s*\(?\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)?\s*', format_key)
+        hex_match = _re.match(r'(?i)\s*(BG\s*:)?\s*(?:#|0x)?([0-9A-F]{8}|[0-9A-F]{6}|[0-9A-F]{4}|[0-9A-F]{3})\s*', format_key)
+        try:
+            if rgb_match:
+                is_bg = rgb_match.group(1)
+                r, g, b = map(int, rgb_match.groups()[1:])
+                if Color.is_valid_rgba((r, g, b)):
+                    return ANSI.seq_bg_color.format(r, g, b) if is_bg else ANSI.seq_color.format(r, g, b)
+            elif hex_match:
+                is_bg = hex_match.group(1)
+                rgb = Color.to_rgba(hex_match.group(2))
+                return ANSI.seq_bg_color.format(rgb[0], rgb[1], rgb[2]) if is_bg else ANSI.seq_color.format(rgb[0], rgb[1], rgb[2])
+        except Exception: pass
+        return _format_key
+
+    @staticmethod
+    def __normalize(format_key:str) -> str:
+        """Put the given format key in the correct format:<br>
+        `1` put `BG:` as first key-part<br>
+        `2` put `bright:` or `br:` as second key-part<br>
+        `3` put everything else behind<br>
+        `4` everything in lower case"""
+        format_key = format_key.replace(' ', '').lower().strip()
+        if ':' in format_key:
+            key_parts = format_key.split(':')
+            format_key = ('bg:' if 'bg' in key_parts else '') + ('bright:' if 'bright' in key_parts or 'br' in key_parts else '') + ''.join(Data.remove(key_parts, ['bg', 'bright', 'br']))
+        return format_key

xulbux/xx_json.py

@@ -0,0 +1,81 @@
+from .xx_data import *
+from .xx_file import *
+
+import json as _json
+import os as _os
+
+
+
+
+class Json:
+
+    @staticmethod
+    def read(json_file:str, comment_start:str = '>>', comment_end:str = '<<', return_original:bool = False) -> dict|tuple[dict,dict]:
+        """Read JSON files, ignoring comments.\n
+        -------------------------------------------------------------------------
+        If only `comment_start` is found at the beginning of an item,<br>
+        the whole item is counted as a comment and therefore ignored.<br>
+        If `comment_start` and `comment_end` are found inside an item,<br>
+        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)
+        with open(file_path, 'r') as f:
+            content = f.read()
+        try:
+            data = _json.loads(content)
+        except _json.JSONDecodeError as e:
+            raise ValueError(f"Error parsing JSON in '{file_path}':  {str(e)}")
+        processed_data = Data.remove_comments(data, comment_start, comment_end)
+        if not processed_data:
+            raise ValueError(f"The JSON file '{file_path}' is empty or contains only comments.")
+        return (processed_data, data) if return_original else processed_data
+
+    @staticmethod
+    def create(content:dict, new_file:str = 'config', indent:int = 2, compactness:int = 1, force:bool = False) -> str:
+        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)
+                if existing_content == content:
+                    raise FileExistsError(f'Already created this file. (nothing changed)')
+            raise FileExistsError('File already exists.')
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(Data.to_str(content, indent, compactness, as_json=True))
+        full_path = _os.path.abspath(file_path)
+        return full_path
+
+    @staticmethod
+    def update(json_file:str, update_values:str|list[str], comment_start:str = '>>', comment_end:str = '<<', sep:tuple[str,str] = ('->', '::')) -> None:
+        """Function to easily update single/multiple values inside JSON files.\n
+        --------------------------------------------------------------------------------------------------------
+        The param `json_file` is the path to the JSON file or just the name of the JSON file to be updated.\n
+        --------------------------------------------------------------------------------------------------------
+        The param `update_values` is a sort of path (or a list of paths) to the value/s to be updated, with<br>
+        the new value at the end of the path.<br>
+        In this example:
+        ```\n {
+          'healthy': {
+            'fruit': ['apples', 'bananas', 'oranges'],
+            'vegetables': ['carrots', 'broccoli', 'celery']
+          }
+        }\n```
+        ... if you want to change the value of `'apples'` to `'strawberries'`, `update_values` would<br>
+        be `healthy->fruit->apples::strawberries` or if you don't know that the value to update<br>
+        is `apples` you can also use the position of the value, so `healthy->fruit->0::strawberries`.\n
+        ⇾ **If the path from `update_values` doesn't exist, it will be created.**\n
+        --------------------------------------------------------------------------------------------------------
+        If only `comment_start` is found at the beginning of an item, the whole item is counted<br>
+        as a comment and therefore ignored. If `comment_start` and `comment_end` are found<br>
+        inside an item, the the section from `comment_start` to `comment_end` is ignored."""
+        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[1]).strip())) == 2]
+        value_paths, new_values = (zip(*valid_entries) if valid_entries else ([], []))
+        processed_data, data = Json.read(json_file, comment_start, comment_end, return_original=True)
+        update = []
+        for value_path, new_value in zip(value_paths, new_values):
+            path_id = Data.get_path_id(processed_data, value_path)
+            update.append(f'{path_id}::{new_value}')
+        updated = Data.set_value_by_path_id(data, update)
+        Json.create(updated, json_file, force=True)

xulbux/xx_path.py

@@ -0,0 +1,97 @@
+import tempfile as _tempfile
+import difflib as _difflib
+import shutil as _shutil
+import sys as _sys
+import os as _os
+
+
+
+
+class Path:
+
+    @staticmethod
+    def get(cwd:bool = False, base_dir:bool = False) -> str|list:
+        paths = []
+        if cwd:
+            paths.append(_os.getcwd())
+        if base_dir:
+            if getattr(_sys, 'frozen', False):
+                base_path = _os.path.dirname(_sys.executable)
+            else:
+                main_module = _sys.modules['__main__']
+                if hasattr(main_module, '__file__'):
+                    base_path = _os.path.dirname(_os.path.abspath(main_module.__file__))
+                elif hasattr(main_module, '__spec__') and main_module.__spec__ and getattr(main_module.__spec__, 'origin', None):
+                    base_path = _os.path.dirname(_os.path.abspath(main_module.__spec__.origin))
+                else:
+                    raise RuntimeError('Can only get base directory if ran from a file.')
+            paths.append(base_path)
+        return paths[0] if len(paths) == 1 else paths
+
+    @staticmethod
+    def extend(path:str, search_in:str|list[str] = None, raise_error:bool = False, correct_path:bool = False) -> str:
+        if path in (None, ''):
+            return path
+        def get_closest_match(dir:str, part:str) -> str|None:
+            try:
+                files_and_dirs = _os.listdir(dir)
+                matches = _difflib.get_close_matches(part, files_and_dirs, n=1, cutoff=0.6)
+                return matches[0] if matches else None
+            except:
+                return None
+        def find_path(start:str, parts:list[str]) -> str|None:
+            current = start
+            for part in parts:
+                if _os.path.isfile(current):
+                    return current
+                closest_match = get_closest_match(current, part) if correct_path else part
+                current = _os.path.join(current, closest_match) if closest_match else None
+                if current is None:
+                    return None
+            return current if _os.path.exists(current) and current != start else None
+        def expand_env_path(p:str) -> str:
+            if not '%' in p:
+                return p
+            parts = p.split('%')
+            for i in range(1, len(parts), 2):
+                if parts[i].upper() in _os.environ:
+                    parts[i] = _os.environ[parts[i].upper()]
+            return ''.join(parts)
+        path = _os.path.normpath(expand_env_path(path))
+        if _os.path.isabs(path):
+            drive, rel_path = _os.path.splitdrive(path)
+            rel_path = rel_path.lstrip(_os.sep)
+            search_dirs = [drive + _os.sep] if drive else [_os.sep]
+        else:
+            rel_path = path.lstrip(_os.sep)
+            base_dir = Path.get(base_dir=True)
+            search_dirs = [_os.getcwd(), base_dir, _os.path.expanduser('~'), _tempfile.gettempdir()]
+        if search_in:
+            search_dirs.extend([search_in] if isinstance(search_in, str) else search_in)
+        path_parts = rel_path.split(_os.sep)
+        for search_dir in search_dirs:
+            full_path = _os.path.join(search_dir, rel_path)
+            if _os.path.exists(full_path):
+                return full_path
+            match = find_path(search_dir, path_parts) if correct_path else None
+            if match: return match
+        if raise_error:
+            raise FileNotFoundError(f'Path \'{path}\' not found in specified directories.')
+        return _os.path.join(search_dirs[0], rel_path)
+
+    @staticmethod
+    def remove(path:str, only_content:bool = False) -> None:
+        if not _os.path.exists(path):
+            return None
+        if not only_content:
+            _shutil.rmtree(path)
+        elif _os.path.isdir(path):
+            for filename in _os.listdir(path):
+                file_path = _os.path.join(path, filename)
+                try:
+                    if _os.path.isfile(file_path) or _os.path.islink(file_path):
+                        _os.unlink(file_path)
+                    elif _os.path.isdir(file_path):
+                        _shutil.rmtree(file_path)
+                except Exception as e:
+                    raise Exception(f'Failed to delete {file_path}. Reason: {e}')

xulbux/xx_regex.py

@@ -0,0 +1,124 @@
+"""
+Really long regex code presets:<br>
+`quotes` match everything inside quotes<br>
+`brackets` match everything inside brackets<br>
+`outside_strings` match the pattern but not inside strings<br>
+`all_except` match everything except a certain pattern<br>
+`func_call` match a function call<br>
+`rgba_str` match an RGBA color<br>
+`hsla_str` match a HSLA color
+"""
+
+
+import re as _re
+
+
+
+
+class Regex:
+
+    @staticmethod
+    def quotes() -> str:
+        """Matches everything inside quotes. (Strings)\n
+        ------------------------------------------------------------------------------------
+        Will create two named groups:<br>
+        **`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`!"""
+        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`!"""
+        g, b1, b2 = '' if is_group else '?:', _re.escape(bracket1) if len(bracket1) == 1 else bracket1, _re.escape(bracket2) if len(bracket2) == 1 else bracket2
+        return rf'{b1}\s*({g}(?:[^{b1}{b2}"\']|"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\'|{b1}(?:[^{b1}{b2}"\']|"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\'|(?R))*{b2})*)\s*{b2}'
+
+    @staticmethod
+    def outside_strings(pattern:str = r'.*') -> str:
+        """Matches the `pattern` only when it is not found inside a string (`'...'` or `"..."`)."""
+        return rf'(?<!["\'])(?:{pattern})(?!["\'])'
+
+    @staticmethod
+    def all_except(disallowed_pattern:str, ignore_pattern:str = '', 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>)."""
+        return rf'({"" if is_group else "?:"}(?:(?!{ignore_pattern}).)*(?:(?!{Regex.outside_strings(disallowed_pattern)}).)*)'
+
+    @staticmethod
+    def func_call(func_name:str = None) -> str:
+        """Match a function call<br>
+        **`1`** function name<br>
+        **`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`!"""
+        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:
+        """Matches an RGBA color inside a string.\n
+        --------------------------------------------------------------------------------
+        The RGBA color can be in the formats (for `fix_sep = ','`):<br>
+        `rgba(r, g, b)`<br>
+        `rgba(r, g, b, a)` (if `allow_alpha=True`)<br>
+        `(r, g, b)`<br>
+        `(r, g, b, a)` (if `allow_alpha=True`)<br>
+        `r, g, b`<br>
+        `r, g, b, a` (if `allow_alpha=True`)\n
+        --------------------------------------------------------------------------------
+        ### Valid ranges:<br>
+        `r` 0-255 (amount: red)<br>
+        `g` 0-255 (amount: green)<br>
+        `b` 0-255 (amount: blue)<br>
+        `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."""
+        if fix_sep in (None, ''):
+            fix_sep = r'[^0-9A-Z]'
+        else:
+            fix_sep = _re.escape(fix_sep)
+        rgb_part = rf'''((?:0*(?:25[0-5]|2[0-4][0-9]|1?[0-9]{{1,2}})))
+            (?:\s*{fix_sep}\s*)((?:0*(?:25[0-5]|2[0-4][0-9]|1?[0-9]{{1,2}})))
+            (?:\s*{fix_sep}\s*)((?:0*(?:25[0-5]|2[0-4][0-9]|1?[0-9]{{1,2}})))'''
+        return rf'''(?ix)
+            (?:rgb|rgba)?\s*(?:\(?\s*{rgb_part}
+                (?:(?:\s*{fix_sep}\s*)((?:0*(?:0?\.[0-9]+|1\.0+|[0-9]+\.[0-9]+|[0-9]+))))?
+            \s*\)?)''' if allow_alpha else rf'(?ix)(?:rgb|rgba)?\s*(?:\(?\s*{rgb_part}\s*\)?)'
+
+    @staticmethod
+    def hsla_str(fix_sep:str = ',', allow_alpha:bool = False) -> str:
+        """Matches a HSLA color inside a string.\n
+        --------------------------------------------------------------------------------
+        The HSLA color can be in the formats (for `fix_sep = ','`):<br>
+        `hsla(h, s, l)`<br>
+        `hsla(h, s, l, a)` (if `allow_alpha=True`)<br>
+        `(h, s, l)`<br>
+        `(h, s, l, a)` (if `allow_alpha=True`)<br>
+        `h, s, l`<br>
+        `h, s, l, a` (if `allow_alpha=True`)\n
+        --------------------------------------------------------------------------------
+        ### Valid ranges:<br>
+        `h` 0-360 (degrees: hue)<br>
+        `s` 0-100 (percentage: saturation)<br>
+        `l` 0-100 (percentage: lightness)<br>
+        `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."""
+        if fix_sep in (None, ''):
+            fix_sep = r'[^0-9A-Z]'
+        else:
+            fix_sep = _re.escape(fix_sep)
+        hsl_part = rf'''((?:0*(?:360|3[0-5][0-9]|[12][0-9][0-9]|[1-9]?[0-9])))
+            (?:\s*{fix_sep}\s*)((?:0*(?:100|[1-9][0-9]|[0-9])))
+            (?:\s*{fix_sep}\s*)((?:0*(?:100|[1-9][0-9]|[0-9])))'''
+        return rf'''(?ix)
+            (?:hsl|hsla)?\s*(?:\(?\s*{hsl_part}
+                (?:(?:\s*{fix_sep}\s*)((?:0*(?:0?\.[0-9]+|1\.0+|[0-9]+\.[0-9]+|[0-9]+))))?
+            \s*\)?)''' if allow_alpha else rf'(?ix)(?:hsl|hsla)?\s*(?:\(?\s*{hsl_part}\s*\)?)'

xulbux/xx_string.py

@@ -0,0 +1,116 @@
+import re as _re
+
+
+
+
+class String:
+
+    @staticmethod
+    def to_type(value:str) -> any:
+        """Will convert a string to a type."""
+        if value.lower() in ['true', 'false']:  # BOOLEAN
+            return value.lower() == 'true'
+        elif value.lower() in ['none', 'null', 'undefined']:  # NONE
+            return None
+        elif value.startswith('[') and value.endswith(']'):  # LIST
+            return [String.to_type(item.strip()) for item in value[1:-1].split(',') if item.strip()]
+        elif value.startswith('(') and value.endswith(')'):  # TUPLE
+            return tuple(String.to_type(item.strip()) for item in value[1:-1].split(',') if item.strip())
+        elif value.startswith('{') and value.endswith('}'):  # SET
+            return {String.to_type(item.strip()) for item in value[1:-1].split(',') if item.strip()}
+        elif value.startswith('{') and value.endswith('}') and ':' in value:  # DICTIONARY
+            return {String.to_type(k.strip()): String.to_type(v.strip()) for k, v in [item.split(':') for item in value[1:-1].split(',') if item.strip()]}
+        try:  # NUMBER (INT OR FLOAT)
+            if '.' in value or 'e' in value.lower():
+                return float(value)
+            else:
+                return int(value)
+        except ValueError: pass
+        if value.startswith(("'", '"')) and value.endswith(("'", '"')):  # STRING (WITH OR WITHOUT QUOTES)
+            return value[1:-1]
+        try:  # COMPLEX
+            return complex(value)
+        except ValueError: pass
+        return value  # IF NOTHING ELSE MATCHES, RETURN AS IS
+
+    @staticmethod
+    def get_repeated_symbol(string:str, symbol:str) -> int|bool:
+        """If the string consists of one repeating `symbol`, it returns the number of times it is repeated.<br>
+        If the string doesn't consist of one repeating symbol, it returns `False`."""
+        if len(string) == len(symbol) * string.count(symbol):
+            return string.count(symbol)
+        else:
+            return False
+
+    @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)]
+
+    @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))
+
+    @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))
+
+    @staticmethod
+    def get_string_lines(string:str, remove_empty_lines:bool = False) -> list[str]:
+        """Will split the string into lines."""
+        if not remove_empty_lines:
+            return string.splitlines()
+        lines = string.splitlines()
+        if not lines:
+            return []
+        non_empty_lines = [line for line in lines if line.strip()]
+        if not non_empty_lines:
+            return []
+        return non_empty_lines
+
+    @staticmethod
+    def remove_consecutive_empty_lines(string:str, max_consecutive:int = 0) -> str:
+        """Will remove consecutive empty lines from the string.\n
+        ----------------------------------------------------------------------------------------------
+        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."""
+        return _re.sub(r'(\n\s*){2,}', r'\1' * (max_consecutive + 1), string)
+
+    @staticmethod
+    def split_every_chars(string:str, split:int) -> list[str]:
+        """Will split the string every `split` characters."""
+        return [string[i:i + split] for i in range(0, len(string), split)]
+
+    @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