alptools 2.6.1__tar.gz

alptools-2.6.1/.gitignore

@@ -0,0 +1,8 @@
+tests/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+dist/

alptools-2.6.1/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AhAlpha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

alptools-2.6.1/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: alptools
+Version: 2.6.1
+Summary: simple tools for alpha projects
+Author: AhAlpha
+License-Expression: MIT
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Provides-Extra: full
+Requires-Dist: pyyaml>=6; extra == 'full'
+Description-Content-Type: text/markdown
+
+# alpha_tools
+simple tools for alpha projects

alptools-2.6.1/README.md

@@ -0,0 +1,2 @@
+# alpha_tools
+simple tools for alpha projects

alptools-2.6.1/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "alptools"
+dynamic = ["version"]
+description = 'simple tools for alpha projects'
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+keywords = []
+authors = [{ name = "AhAlpha" }]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+dependencies = []
+
+[project.optional-dependencies]
+full = ["PyYAML>=6"]
+
+[tool.hatch.version]
+path = "src/atools/__about__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/atools"]

alptools-2.6.1/src/atools/__about__.py

@@ -0,0 +1 @@
+__version__ = "2.6.1"

alptools-2.6.1/src/atools/__init__.py

@@ -0,0 +1,20 @@
+from .__about__ import __version__
+
+from .base_tools import path_join as APATH
+from .base_tools import check_dir as ADIR
+
+from .base_tools import read_file as ARF
+from .base_tools import write_file as AWF
+from .base_tools import move_file as AMF
+from .base_tools import copy_file as ACF
+from .base_tools import delete_file as ADF
+
+from .base_tools import object_get as AGET
+from .base_tools import object_set as ASET
+from .base_tools import object_split as ASPLIT
+
+from .base_tools import append_unique as ADUQ
+
+# from .base_tools import connect_str_main as AJOIN
+from .base_tools import str_add_num as ASAN
+from .base_tools import is_number as ASNUM

alptools-2.6.1/src/atools/base_tools/__init__.py

@@ -0,0 +1,17 @@
+from .object.append_unique import append_unique
+from .object.object_get import object_get
+from .object.object_set import object_set
+from .object.object_split import object_split
+
+from .file.copy_file import copy_file
+from .file.delete_file import delete_file
+from .file.move_file import move_file
+from .file.read_file import read_file
+from .file.write_file import write_file
+
+from .path.check_dir import check_dir
+from .path.path_join import path_join
+
+# from .string.connect_str import connect_str
+from .string.is_number import is_number
+from .string.str_add_num import str_add_num

alptools-2.6.1/src/atools/base_tools/__logger.py

@@ -0,0 +1,24 @@
+import inspect
+
+
+def info(*message, level=2) -> None:
+    """
+    Print the current stack trace as a formatted string.
+
+    Returns:
+    - None
+    """
+    frame = inspect.stack()[level]
+    print(f" \033[32m[INF]\033[0m", f"\033[35m{frame.code_context[0].split("(")[0].strip()}()\033[0m:", *message)
+
+
+
+def warn(*message, level=2) -> None:
+    """
+    Print the current stack trace as a formatted string.
+
+    Returns:
+    - None
+    """
+    frame = inspect.stack()[level]
+    print(f" \033[33m[WRN]\033[0m", f"\033[35m{frame.code_context[0].split("(")[0].strip()}()\033[0m:", *message, f'File \033[35m"{frame.filename}"\033[0m, line \033[35m{frame.lineno}\033[0m')

alptools-2.6.1/src/atools/base_tools/file/copy_file.py

@@ -0,0 +1,43 @@
+import os
+import shutil
+
+from ..__logger import warn
+from ..path.check_dir import check_dir
+
+
+def copy_file(bfile: str, afile: str, show_warn: bool = True) -> int:
+    """
+    Copies a file or directory from one location to another.
+
+    Parameters:
+    - bfile (str): The source file or directory path to copy.
+    - afile (str): The destination file or directory path.
+    - show_warn (bool): If True, prints warnings when the operation fails. Defaults to True.
+
+    Returns:
+    - int: Status code indicating the result of the operation.
+        0: Success.
+        1: Source file or directory not found.
+        2: Permission denied.
+        3: Other errors occurred.
+    """
+    try:
+        if os.path.isfile(bfile):
+            check_dir(afile, is_filename=True, logger_level=3)
+            shutil.copy(bfile, afile)
+        elif os.path.isdir(bfile):
+            check_dir(afile, logger_level=3)
+            shutil.copytree(bfile, afile, dirs_exist_ok=True)
+        else:
+            if show_warn:
+                warn(f'FileNotFoundError: Item "{bfile}" not found.')
+            return -1
+        return 0
+    except PermissionError:
+        if show_warn:
+            warn(f'PermissionError: Permission denied to copy "{bfile}".')
+        return -2
+    except Exception as e:
+        if show_warn:
+            warn(f'{e} "{bfile}".')
+        return -3

alptools-2.6.1/src/atools/base_tools/file/delete_file.py

@@ -0,0 +1,39 @@
+import os
+import shutil
+
+from ..__logger import warn
+
+
+def delete_file(file_path: str, show_warn: bool = True) -> int:
+    """
+    Deletes a file or directory.
+
+    Parameters:
+    - file_path (str): The path to the file or directory to delete.
+    - show_warn (bool): If True, prints warnings when the operation fails. Defaults to True.
+
+    Returns:
+    - int: Status code indicating the result of the operation.
+        0: Success.
+        1: File or directory not found.
+        2: Permission denied.
+        3: Other errors occurred.
+    """
+    try:
+        if os.path.isfile(file_path):
+            os.remove(file_path)
+        elif os.path.isdir(file_path):
+            shutil.rmtree(file_path)
+        else:
+            if show_warn:
+                warn(f'FileNotFoundError: Item "{file_path}" not found.')
+            return -1
+        return 0
+    except PermissionError:
+        if show_warn:
+            warn(f'PermissionError: Permission denied to delete "{file_path}".')
+        return -2
+    except Exception as e:
+        if show_warn:
+            warn(f'{e} File "{file_path}".')
+        return -3

alptools-2.6.1/src/atools/base_tools/file/move_file.py

@@ -0,0 +1,43 @@
+import os
+import shutil
+
+from ..__logger import warn
+from ..path.check_dir import check_dir
+
+
+def move_file(bfile: str, afile: str, show_warn: bool = True):
+    """
+    Moves a file or directory from one location to another.
+
+    Parameters:
+    - bfile (str): The source file or directory path to move.
+    - afile (str): The destination file or directory path.
+    - show_warn (bool): If True, prints warnings when the operation fails. Defaults to True.
+
+    Returns:
+    - int: Status code indicating the result of the operation.
+        0: Success.
+        1: Source file or directory not found.
+        2: Permission denied.
+        3: Other errors occurred.
+    """
+    try:
+        if os.path.isfile(bfile):
+            check_dir(afile, is_filename=True, logger_level=3)
+            shutil.move(bfile, afile)
+        elif os.path.isdir(bfile):
+            check_dir(afile, is_filename=True, logger_level=3)
+            shutil.move(bfile, afile)
+        else:
+            if show_warn:
+                warn(f'Item "{bfile}" not found.')
+            return -1
+        return 0
+    except PermissionError:
+        if show_warn:
+            warn(f'PermissionError: Permission denied to move "{bfile}".')
+        return -2
+    except Exception as e:
+        if show_warn:
+            warn(f'{e} File "{bfile}".')
+        return -3

alptools-2.6.1/src/atools/base_tools/file/read_file.py

@@ -0,0 +1,37 @@
+import os
+import json
+from typing import Any
+
+from ..__logger import warn
+
+
+def read_file(file_path: str, encoding: str = "utf-8", with_json: bool = False, with_bytes: bool = False, default: Any = None, show_warn: bool = True):
+    """
+    Reads the content of a file with optional JSON parsing or byte reading.
+
+    Parameters:
+    - file_path (str): The path to the file to be read.
+    - with_json (bool): If True, attempts to parse the file content as JSON.
+    - with_bytes (bool): If True, reads the file in binary mode.
+    - default (any): The default value to return if the file does not exist or an error occurs.
+    - show_warn (bool): If True, prints a warning message when the file is not found or cannot be read.
+
+    Returns:
+    - any: The content of the file, parsed JSON object, or the default `default` value.
+    """
+    if not os.path.exists(file_path):
+        if show_warn:
+            warn(f'FileNotFoundError: File "{file_path}" not found.')
+        return default
+    if with_bytes:
+        with open(file_path, "rb") as f:
+            return f.read()
+    with open(file_path, "r", encoding=encoding) as f:
+        if with_json:
+            try:
+                return json.load(f)
+            except Exception as e:
+                if show_warn:
+                    warn(f'JSONDecodeError: File "{file_path}" is not a valid JSON file ({e}).')
+                return default
+        return f.read()

alptools-2.6.1/src/atools/base_tools/file/write_file.py

@@ -0,0 +1,45 @@
+import os
+import json
+from typing import Any, Literal
+
+from ..path.check_dir import check_dir
+
+
+class BytesEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, bytes):
+            return " ".join(f"{byte:02X}" for byte in obj)
+        return super().default(obj)
+
+
+def write_file(file_path: str, content: Any = "", encoding: str = "utf-8", as_json: bool | int | Literal["no-format"] = False, as_bytes: bool = False):
+    """
+    Writes content to a file with optional JSON formatting or binary mode.
+
+    Parameters:
+    - file_path (str): The path to the file to be written.
+    - content (any): The content to write to the file. Can be a string, JSON-serializable object, or bytes.
+    - encoding (str): The encoding to use when writing text content. Defaults to "utf-8".
+    - as_json (bool): If True, serializes the content as JSON before writing.
+    - as_bytes (bool): If True, writes the content in binary mode.
+
+    Returns:
+    - None
+    """
+    if os.path.dirname(file_path) != "":
+        check_dir(os.path.dirname(file_path), logger_level=3)
+    if as_bytes or isinstance(content, bytes) or isinstance(content, bytearray):
+        with open(file_path, "wb") as f:
+            f.write(content)
+        return
+    if as_json == 2 or as_json == "no-format":
+        with open(file_path, "w", encoding=encoding) as f:
+            json.dump(content, f, ensure_ascii=False, cls=BytesEncoder)
+        return
+    if as_json or isinstance(content, dict) or isinstance(content, list):
+        with open(file_path, "w", encoding=encoding) as f:
+            json.dump(content, f, ensure_ascii=False, indent=2, separators=(",", ": "), cls=BytesEncoder)
+        return
+    with open(file_path, "w", encoding=encoding) as f:
+        f.write(content)
+    return

alptools-2.6.1/src/atools/base_tools/object/append_unique.py

@@ -0,0 +1,25 @@
+from typing import Any, Optional, Callable
+
+
+def append_unique(target_list: list, value: Any, filter_func: Optional[Callable[[Any], bool]] = None, mapper_func: Optional[Callable[[Any], Any]] = None) -> list:
+    """
+    Append an item to a list if it is unique, with optional filtering and mapping.
+
+    Parameters:
+    - target_list (list): The list to which the item will be appended.
+    - value (Any): The item to append. Can be a single item or an iterable (list, tuple, set, or dict).
+    - filter_func (Callable[[Any], bool], optional): A function to filter items. Only items passing the filter will be appended.
+    - mapper_func (Callable[[Any], Any], optional): A function to transform the item before appending.
+
+    Returns:
+    - list: The updated list with the unique item(s) appended.
+    """
+    if isinstance(value, (list, tuple, set, dict)):
+        for item in value:
+            append_unique(target_list, item, filter_func, mapper_func)
+    else:
+        item = mapper_func(value) if mapper_func else value
+        if item not in target_list:
+            if not filter_func or filter_func(item):
+                target_list.append(item)
+    return target_list

alptools-2.6.1/src/atools/base_tools/object/object_get.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+
+def object_get(base_object: dict | list, pos: str | tuple | list, default: Any = None) -> Any:
+    """
+    Retrieve a value from a nested dictionary or list using a key or sequence of keys.
+
+    Parameters:
+    - base_object (dict | list): The dictionary or list to retrieve the value from.
+    - pos (str | tuple | list): The key or sequence of keys to locate the value.
+    - default (any, optional): The default value to return if the key is not found. Defaults to None.
+
+    Returns:
+    - any: The value found at the specified position, or the default value if not found.
+    """
+    if isinstance(pos, str):
+        pos = (pos,)
+    _value = base_object
+    for _key in pos:
+        if (isinstance(_value, dict) and _key in _value) or (isinstance(_value, (list, tuple)) and _key < len(_value)):
+            _value = _value[_key]
+        else:
+            return default
+    return _value

alptools-2.6.1/src/atools/base_tools/object/object_set.py

@@ -0,0 +1,70 @@
+from typing import List, Tuple, Any, Union, Literal
+
+from ..__logger import warn
+
+
+def object_set(
+    base_object: dict,
+    pos: Union[str, List[str], Tuple[str, ...]],
+    value: Any = None,
+    target_type: Literal["default", "str", "number", "list", "dict"] = "default",
+    unique: bool = False,
+) -> dict:
+    """
+    A function to set or update a value in a dictionary, supporting nested keys and various data types.
+
+    Parameters:
+    - object (dict): The dictionary to modify.
+    - pos (str | list | tuple): The key or nested keys where the value should be set.
+    - value (Any, optional): The value to set or update. Defaults to None.
+    - target_type (str, optional): The type of operation to perform. Options include:
+        - "default" or None: Directly set the value.
+        - "str" or "": Concatenate the value to an existing string.
+        - "number" or 0: Add the value to an existing number.
+        - "list" or []: Append the value to a list, optionally ensuring uniqueness.
+        - "dict" or {}: Update the value as a dictionary.
+    - unique (bool, optional): If True, ensures the value is unique when appending to a list. Defaults to False.
+
+    Returns:
+    - dict: The updated dictionary.
+    """
+    # Handle nested keys if `pos` is a tuple or list
+    if isinstance(pos, (list, tuple)):
+        if len(pos) == 0:
+            warn(f"Empty dict name received: {pos}.")
+            return base_object
+        elif len(pos) == 1:
+            pos = pos[0]
+        else:
+            curr_key, pos = pos[0], pos[1:]
+            if curr_key not in base_object or not isinstance(base_object[curr_key], dict):
+                base_object[curr_key] = {}
+            object_set(base_object[curr_key], pos, value, target_type, unique)
+            return base_object
+
+    # Create or update the value based on the `target_type` parameter
+    if target_type in ("default", None):
+        base_object[pos] = value
+    elif target_type in ("str", ""):
+        if pos not in base_object:  # Init
+            base_object[pos] = ""
+        if value is not None:
+            base_object[pos] += value
+    elif target_type in ("number", 0):
+        if pos not in base_object:  # Init
+            base_object[pos] = 0
+        if value is not None:
+            base_object[pos] += value
+    elif target_type in ("list", []):
+        if pos not in base_object:  # Init
+            base_object[pos] = []
+        if value is not None and (not unique or value not in base_object[pos]):
+            base_object[pos].append(value)
+    elif target_type in ("dict", {}):
+        if pos not in base_object:  # Init
+            base_object[pos] = {}
+        if value is not None:
+            base_object[pos].update(value)
+    else:
+        warn(f"Unknown type provided: {target_type}.")
+    return base_object

alptools-2.6.1/src/atools/base_tools/object/object_split.py

@@ -0,0 +1,21 @@
+import math
+
+
+def object_split(object: dict | list, num: int) -> list:
+    """
+    Split a dictionary or list into smaller chunks.
+
+    Parameters:
+    - object (dict | list): The dictionary or list to be split.
+    - num (int): The number of items per chunk for a dictionary, or the number of chunks for a list.
+
+    Returns:
+    - list: A list of smaller dictionaries or lists, depending on the input type.
+    """
+    if isinstance(object, dict):
+        keys = list(object.keys())
+        return [{k: object[k] for k in keys[i : i + num]} for i in range(0, len(keys), num)]
+    if isinstance(object, list):
+        n = math.ceil(len(object) / num)
+        return [object[i : i + n] for i in range(0, len(object), n)]
+    return []

alptools-2.6.1/src/atools/base_tools/path/check_dir.py

@@ -0,0 +1,35 @@
+import os
+
+from ..__logger import info, warn
+
+
+def check_dir(dir_path: str, is_filename: bool = False, show_info: bool = True, show_warn: bool = True, logger_level: int = 2) -> int:
+    """
+    Ensures the existence of a directory, creating it if necessary.
+
+    Parameters:
+    - dir_path (str): The directory path to check or create.
+    - is_filename (bool): If True, treats `dir_` as a file path and checks its parent directory.
+
+    Returns:
+    - int:
+        0 if the directory already exists,
+        1 if the directory was successfully created,
+        2 if the input directory path is empty,
+        3 if the directory creation failed.
+    """
+    if is_filename:
+        dir_path = os.path.dirname(dir_path)
+    if dir_path == "":
+        return -1
+    if os.path.isdir(dir_path):
+        return 0
+    os.makedirs(dir_path, exist_ok=True)
+    if os.path.isdir(dir_path):
+        if show_info:
+            info(f'Auto created the "{dir_path}" folder.', level=logger_level)
+        return 1
+    else:
+        if show_warn:
+            warn(f'OSError: Fail to created the "{dir_path}" folder.', level=logger_level)
+        return -2

alptools-2.6.1/src/atools/base_tools/path/path_join.py

@@ -0,0 +1,33 @@
+import os
+
+MAIN_PATH = os.getcwd().split("\\")
+
+
+
+def path_join(*pos: str, auto_path: bool = True) -> str:
+
+    """
+    Joins multiple path components into a single path string.
+
+    Parameters:
+    - pos (str): One or more path components to join.
+    - auto_path (bool): If True, prepends the MAIN_PATH to the resulting path.
+
+    Returns:
+    - str: The joined path as a string.
+    """
+    return_path = []
+    for _i, _p in enumerate(pos):
+        _p = _p.replace("\\", "/").split("/")
+        if len(_p[0]) == 2 and _p[0][1] == ":":
+            return_path.clear()
+        elif _i == 0 and auto_path:
+            return_path = list(MAIN_PATH)
+        for _x_ in _p:
+            if _x_ in ".":
+                continue
+            elif _x_ == "..":
+                return_path.pop()
+            elif _x_ != "":
+                return_path.append(_x_)
+    return "/".join(return_path)

alptools-2.6.1/src/atools/base_tools/string/connect_str.py

@@ -0,0 +1,35 @@
+def connect_str(str_first, str_join, str_append, *str_more, _ignore=[""]):
+    connect_str_cache = ""
+    if isinstance(str_append, list):
+        connect_str_cache = str_first
+        for append_str_cache in str_append:
+            connect_str_cache = connect_str(connect_str_cache, str_join, append_str_cache, _ignore)
+            del str_append[0]
+    else:
+        if str_first not in _ignore and str_append not in _ignore:
+            connect_str_cache = f"{str_first}{str_join}{str_append}"
+        elif str_first not in _ignore:
+            connect_str_cache = f"{str_first}"
+        elif str_append not in _ignore:
+            connect_str_cache = f"{str_append}"
+        else:
+            connect_str_cache = f""
+    if str_more:
+        if len(str_more) >= 2:
+            connect_str_cache = connect_str(connect_str_cache, *str_more, _ignore=_ignore)
+        elif len(str_more) == 1:
+            print(f" [WARN] connect_str: ({connect_str_cache}, {str_more[0]}, ...) append args not Double.")
+    return connect_str_cache
+
+
+def connect_str_main(*str_args, _ignore=[""], _igmode="None"):
+    if _igmode in ["None", "n"]:
+        return connect_str(*str_args, _ignore=_ignore)
+    elif _igmode in ["Head", "h"]:
+        return connect_str(" ", *str_args, _ignore=_ignore)[1:]
+    elif _igmode in ["Tail", "t"]:
+        return connect_str(*str_args, " ", _ignore=_ignore)[:-1]
+    elif _igmode in ["Head_and_Tail", "ht", "th"]:
+        connect_str_main_cache = connect_str_main(*str_args[:-1], _ignore=_ignore, _igmode="Head")
+        connect_str_main_cache = connect_str_main(connect_str_main_cache, str_args[-1], _ignore=_ignore, _igmode="Tail")
+        return connect_str_main_cache

alptools-2.6.1/src/atools/base_tools/string/is_number.py

@@ -0,0 +1,18 @@
+import unicodedata
+
+
+def is_number(str_: str) -> bool:
+    """
+    Check if a string represents a number.
+
+    Args:
+    - str_ (str): The input string to check.
+
+    Returns:
+    - bool: True if the string represents a number, False otherwise.
+    """
+    try:
+        float(str_) or unicodedata.numeric(str_)
+        return True
+    except (ValueError, TypeError):
+        return False

alptools-2.6.1/src/atools/base_tools/string/str_add_num.py

@@ -0,0 +1,22 @@
+import re
+
+
+def str_add_num(str_: str, sep_: str = "_", fill_: int = 0, start_: int = 1) -> str:
+    """
+    Increment the numeric suffix of a string, or add one if it doesn't exist.
+
+    Args:
+    - base_string (str): The input string to modify.
+    - sep_ (str): The separator between the string and the number. Default is "_".
+    - fill_ (int): The zero-padding width for the number. Default is 0 (no padding).
+    - start_ (int): The starting number to append if no numeric suffix exists. Default is 1.
+
+    Returns:
+    - str: The modified string with an incremented or newly added numeric suffix.
+    """
+    match = re.search(rf"{sep_}(\d+)$", str_)
+    if match:
+        str_ = re.sub(rf"{sep_}\d+$", f"{sep_}{(int(match.group(1)) + 1):0{fill_}}", str_)
+    else:
+        str_ = f"{str_}{sep_}{start_}"
+    return str_