machineconfig 6.82__py3-none-any.whl → 8.51__py3-none-any.whl

machineconfig/scripts/python/{helpers_cloud → helpers/helpers_cloud}/cloud_mount.py

@@ -1,35 +1,31 @@
 """Cloud mount script"""
 
-from machineconfig.utils.options import choose_from_options
-from machineconfig.utils.io import read_ini
-from machineconfig.utils.path_extended import PathExtended
-
-import platform
-from typing import Optional, Annotated
 import typer
-from rich.console import Console
-from rich.panel import Panel
-
-console = Console()
-
-
-DEFAULT_MOUNT = "~/data/rclone"
+from typing import Optional, Annotated
 
 
 def get_rclone_config():
+    from machineconfig.utils.io import read_ini
+    from pathlib import Path
+    import platform
     if platform.system() == "Windows":
-        config = read_ini(PathExtended.home().joinpath("AppData/Roaming/rclone/rclone.conf"))
+        config = read_ini(Path.home().joinpath("AppData/Roaming/rclone/rclone.conf"))
     elif platform.system() in ["Linux", "Darwin"]:
-        config = read_ini(PathExtended.home().joinpath(".config/rclone/rclone.conf"))
+        config = read_ini(Path.home().joinpath(".config/rclone/rclone.conf"))
     else:
         raise ValueError("unsupported platform")
     return config
 
 
 def get_mprocs_mount_txt(cloud: str, rclone_cmd: str, cloud_brand: str):  # cloud_brand = config[cloud]["type"]
+    from machineconfig.utils.path_extended import PathExtended
+    from machineconfig.utils.accessories import randstr
+    import platform
+    DEFAULT_MOUNT = "~/data/rclone"
+
     header = f"{' ' + cloud + ' | ' + cloud_brand + ' '}".center(50, "=")
     if platform.system() == "Windows":
-        sub_text_path = PathExtended.tmpfile(suffix=".ps1")
+        sub_text_path = PathExtended("~/tmp_results/tmp_files").expanduser().joinpath(f"{randstr()}.ps1")
         sub_text_path.parent.mkdir(parents=True, exist_ok=True)
         sub_text_path.write_text(
             f"""
@@ -57,6 +53,13 @@ def mount(
     destination: Annotated[Optional[str], typer.Option(help="destination to mount")] = None,
     network: Annotated[Optional[str], typer.Option(help="mount network drive")] = None,
 ) -> None:
+    from machineconfig.utils.options import choose_from_options
+    from pathlib import Path
+    import platform
+    from rich.console import Console
+    from rich.panel import Panel
+    console = Console()
+    DEFAULT_MOUNT = "~/data/rclone"
 
     # draw header box dynamically
     title = "☁️  Cloud Mount Utility"
@@ -68,14 +71,15 @@ def mount(
         if type(res) is str:
             cloud = res
         else:
-            raise ValueError("no cloud selected")
+            print("❌ Error: No cloud selected")
+            raise typer.Exit(code=1)
         print(f"🌩️  Selected cloud: {cloud}")
 
     if network is None:
         if destination is None:
-            mount_loc = PathExtended(DEFAULT_MOUNT).expanduser().joinpath(cloud)
+            mount_loc = Path(DEFAULT_MOUNT).expanduser().joinpath(cloud)
         else:
-            mount_loc = PathExtended(destination)
+            mount_loc = Path(destination)
 
         mount_info = f"📂 Mount location: {mount_loc}"
         console.print(Panel(mount_info, border_style="blue"))
@@ -95,13 +99,15 @@ def mount(
                 console.print(Panel(f"{warning_line}\n{err_line}", title="Warning", border_style="yellow"))
                 pass
         else:
-            raise ValueError("unsupported platform")
+            print("❌ Error: Unsupported platform")
+            raise typer.Exit(code=1)
 
     elif network and platform.system() == "Windows":
         mount_loc = "X: --network-mode"
         print(f"🔌 Setting up network mount at {mount_loc}")
     else:
-        raise ValueError("network mount only supported on windows")
+        print("❌ Error: Network mount only supported on Windows")
+        raise typer.Exit(code=1)
 
     mount_cmd = f"rclone mount {cloud}: {mount_loc} --vfs-cache-mode full --file-perms=0777"
     console.print(Panel(f"🚀 Preparing mount command:\n{mount_cmd}", border_style="blue"))
@@ -146,7 +152,8 @@ zellij run --in-place --cwd $HOME/data/rclone/{cloud} -- bash
 zellij action move-focus up
 """
     else:
-        raise ValueError("unsupported platform")
+        print("❌ Error: Unsupported platform")
+        raise typer.Exit(code=1)
     # print(f"running command: \n{txt}")
     # PROGRAM_PATH.write_text(txt, encoding="utf-8")
     import subprocess

machineconfig/scripts/python/{helpers_cloud → helpers/helpers_cloud}/cloud_sync.py

@@ -2,16 +2,9 @@
 TODO: use typer or typed-argument-parser to parse args
 """
 
-from machineconfig.scripts.python.helpers_cloud.helpers2 import parse_cloud_source_target
-from machineconfig.scripts.python.helpers_cloud.cloud_helpers import Args
-from machineconfig.scripts.python.helpers_cloud.cloud_mount import get_mprocs_mount_txt
 
 from typing import Annotated, Optional
 import typer
-from rich.console import Console
-from rich.panel import Panel
-
-console = Console()
 
 
 def main(
@@ -27,6 +20,14 @@ def main(
     delete: Annotated[bool, typer.Option("--delete", "-D", help="Delete files in remote that are not in local.")] = False,
     verbose: Annotated[bool, typer.Option("--verbose", "-v", help="Verbosity of mprocs to show details of syncing.")] = False,
 ) -> None:
+
+    from machineconfig.scripts.python.helpers.helpers_cloud.helpers2 import parse_cloud_source_target
+    from machineconfig.scripts.python.helpers.helpers_cloud.cloud_helpers import Args
+    from machineconfig.scripts.python.helpers.helpers_cloud.cloud_mount import get_mprocs_mount_txt
+    from rich.console import Console
+    from rich.panel import Panel
+    console = Console()
+
     title = "☁️  Cloud Sync Utility"
     console.print(Panel(title, title_align="left", border_style="blue"))
 
@@ -76,5 +77,5 @@ def main(
     # import subprocess
     # subprocess.run(txt, shell=True, check=True)
     from machineconfig.utils.code import run_shell_script
-    run_shell_script(txt)
+    run_shell_script(txt, display_script=True, clean_env=False)
 

machineconfig/scripts/python/{helpers_cloud → helpers/helpers_cloud}/helpers2.py

@@ -1,4 +1,4 @@
-from machineconfig.scripts.python.helpers_cloud.cloud_helpers import Args, ArgsDefaults, absolute, find_cloud_config, get_secure_share_cloud_config
+from machineconfig.scripts.python.helpers.helpers_cloud.cloud_helpers import Args, ArgsDefaults, absolute, find_cloud_config, get_secure_share_cloud_config
 from machineconfig.utils.io import read_ini
 from machineconfig.utils.source_of_truth import DEFAULTS_PATH
 from machineconfig.utils.accessories import pprint

machineconfig/scripts/python/{helpers_croshell → helpers/helpers_croshell}/crosh.py

@@ -1,6 +1,6 @@
 
 
-def code(path: str, title: str):
+def get_read_python_file_pycode(path: str, title: str):
     from pathlib import Path
     print("Reading code from path:", path)
     pycode = Path(path).read_text(encoding="utf-8")
@@ -20,9 +20,9 @@ def get_read_data_pycode(path: str):
     from rich.panel import Panel
     from rich.text import Text
     from rich.console import Console
-    from machineconfig.utils.path_extended import PathExtended
+    from pathlib import Path
     console = Console()
-    p = PathExtended(path).absolute()
+    p = Path(path).absolute()
     try:
         from machineconfig.utils.files.read import Read
         from machineconfig.utils.accessories import pprint

machineconfig/scripts/python/helpers/helpers_croshell/croshell_impl.py

@@ -0,0 +1,225 @@
+"""Pure Python implementation for croshell command - no typer dependencies."""
+
+from typing import Optional
+from pathlib import Path
+
+
+def croshell(
+    path: Optional[str],
+    project_path: Optional[str],
+    uv_with: Optional[str],
+    marimo: bool,
+    jupyter: bool,
+    vscode: bool,
+    visidata: bool,
+    python: bool,
+    profile: Optional[str],
+) -> None:
+    """Cross-shell command execution."""
+    interactivity = "-i"
+    interpreter = "python" if python else "ipython"
+    if uv_with is not None:
+        match interpreter:
+            case "ipython":
+                user_uv_with_line = f"--with {uv_with},ipython"
+            case "python":
+                user_uv_with_line = f"--with {uv_with}"
+    else:
+        match interpreter:
+            case "ipython":
+                user_uv_with_line = "--with ipython"
+            case "python":
+                user_uv_with_line = ""
+
+    if project_path is not None:
+        uv_project_line = f'--project {project_path}'
+        uv_python_line = ""
+    else:
+        uv_project_line = ""
+        uv_python_line = "--python 3.14"
+
+    from machineconfig.scripts.python.helpers.helpers_croshell.crosh import get_read_python_file_pycode, get_read_data_pycode
+    from machineconfig.utils.meta import lambda_to_python_script
+    from machineconfig.utils.accessories import randstr
+    from machineconfig.utils.ve import get_ve_path_and_ipython_profile
+    import json
+    from rich.console import Console
+    from rich.panel import Panel
+    console = Console()
+
+    ipython_profile: Optional[str] = profile
+    file_obj = Path.cwd()
+    if path is not None:
+        from machineconfig.utils.path_helper import get_choice_file
+        choice_file = get_choice_file(path=path, suffixes={".*"})
+        if project_path is None:
+            ve_path, _ = get_ve_path_and_ipython_profile(choice_file)
+            if ve_path is not None:
+                ve_path_obj = Path(ve_path)
+                uv_project_line = f'--project {ve_path_obj.parent}'
+                uv_python_line = ""
+        if choice_file.suffix == ".py":
+            program = choice_file.read_text(encoding="utf-8")
+            text = f"📄 Selected file: {choice_file.name}"
+            console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
+        else:
+            program = lambda_to_python_script(
+                lambda: get_read_data_pycode(path=str(choice_file)),
+                in_global=True, import_module=False
+            )
+            text = f"📄 Reading data from: {file_obj.name}"
+            console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
+    else:
+        program = ""
+
+    if Path.home().joinpath("code/machineconfig").exists() and uv_project_line == "":
+        uv_project_line = f'--project "{str(Path.home().joinpath("code/machineconfig"))}"'
+
+    preprogram = _build_preprogram()
+
+    pyfile = Path.home().joinpath(f"tmp_results/tmp_scripts/python/croshell/{randstr()}/script.py")
+    pyfile.parent.mkdir(parents=True, exist_ok=True)
+    title = "Reading Data"
+    def_code = lambda_to_python_script(
+        lambda: get_read_python_file_pycode(path=str(pyfile), title=title),
+        in_global=False, import_module=False
+    )
+    python_program = preprogram + "\n\n" + def_code + program
+    pyfile.write_text(python_program, encoding="utf-8")
+    ipython_profile = ipython_profile if ipython_profile is not None else "default"
+
+    nb_target = pyfile.with_suffix(".ipynb")
+    if jupyter:
+        try:
+            nb_path = pyfile.with_suffix(".ipynb")
+            nb_content = {
+                "cells": [
+                    {
+                        "cell_type": "code",
+                        "metadata": {"language": "python"},
+                        "source": [python_program],
+                        "outputs": [],
+                        "execution_count": None,
+                    }
+                ],
+                "metadata": {},
+                "nbformat": 4,
+                "nbformat_minor": 5,
+            }
+            nb_path.write_text(json.dumps(nb_content), encoding="utf-8")
+            nb_target = nb_path
+        except Exception:
+            pass
+
+    fire_line = _build_fire_line(
+        file_obj=file_obj,
+        pyfile=pyfile,
+        nb_target=nb_target,
+        visidata=visidata,
+        marimo=marimo,
+        jupyter=jupyter,
+        vscode=vscode,
+        interpreter=interpreter,
+        interactivity=interactivity,
+        ipython_profile=ipython_profile,
+        uv_python_line=uv_python_line,
+        uv_project_line=uv_project_line,
+        user_uv_with_line=user_uv_with_line,
+        uv_with=uv_with,
+    )
+
+    from machineconfig.utils.code import exit_then_run_shell_script
+    exit_then_run_shell_script(fire_line, strict=False)
+
+
+def _build_preprogram() -> str:
+    """Build the preprogram code for croshell."""
+    import inspect
+    import textwrap
+    from types import FunctionType
+
+    def get_body_simple_function_no_args(f: FunctionType) -> str:
+        return textwrap.dedent("\n".join(inspect.getsource(f).splitlines()[1:]))
+
+    preprogram = """
+#%%
+"""
+
+    def preprogram_func() -> None:
+        try:
+            from machineconfig.utils.files.headers import print_header, print_logo
+            print_header()
+            print_logo("Machineconfig")
+            from machineconfig.utils.path_extended import PathExtended
+            _ = PathExtended
+        except ImportError:
+            print("machineconfig is not installed in the current environment.")
+            pass
+        from pathlib import Path
+        _ = Path
+
+    preprogram += get_body_simple_function_no_args(preprogram_func)
+    return preprogram
+
+
+def _build_fire_line(
+    file_obj: Path,
+    pyfile: Path,
+    nb_target: Path,
+    visidata: bool,
+    marimo: bool,
+    jupyter: bool,
+    vscode: bool,
+    interpreter: str,
+    interactivity: str,
+    ipython_profile: str,
+    uv_python_line: str,
+    uv_project_line: str,
+    user_uv_with_line: str,
+    uv_with: Optional[str],
+) -> str:
+    """Build the fire line command for croshell."""
+    if visidata:
+        if file_obj.suffix == ".json":
+            fire_line = f"uv run {uv_python_line} {user_uv_with_line} {uv_project_line} --with visidata vd {str(file_obj)}"
+        else:
+            fire_line = f"uv run {uv_python_line} {user_uv_with_line} {uv_project_line} --with visidata,pyarrow vd {str(file_obj)}"
+    elif marimo:
+        if Path.home().joinpath("code/machineconfig").exists():
+            requirements = f"""{user_uv_with_line} {uv_project_line} --with marimo,sqlglot  """
+        else:
+            requirements = f"""{uv_python_line} {user_uv_with_line} {uv_project_line} --with "marimo,sqlglot,cowsay,machineconfig[plot]>=8.51" """
+        fire_line = f"""
+cd {str(pyfile.parent)}
+uv run {uv_python_line} --with "marimo" marimo convert {pyfile.name} -o marimo_nb.py
+uv run {requirements} marimo edit --host 0.0.0.0 marimo_nb.py
+"""
+    elif jupyter:
+        if Path.home().joinpath("code/machineconfig").exists():
+            requirements = f"""{user_uv_with_line}  {uv_project_line}  --with jupyterlab """
+        else:
+            requirements = f"""{user_uv_with_line} {uv_project_line} --with "cowsay,machineconfig[plot]>=8.51" """
+        fire_line = f"uv run {requirements} {uv_project_line}  jupyter-lab {str(nb_target)}"
+    elif vscode:
+        user_uv_add = f"uv add {uv_with}" if uv_with is not None else ""
+        fire_line = f"""
+cd {str(pyfile.parent)}
+uv init {uv_python_line}
+uv venv
+uv add "cowsay,machineconfig[plot]>=8.51"
+uv add {user_uv_add}
+# code serve-web
+code --new-window {str(pyfile)}
+"""
+    else:
+        if interpreter == "ipython":
+            profile = f" --profile {ipython_profile} --no-banner"
+        else:
+            profile = ""
+        if Path.home().joinpath("code/machineconfig").exists():
+            ve_line = f"""{user_uv_with_line}  {uv_project_line} """
+        else:
+            ve_line = f"""{uv_python_line} {user_uv_with_line} {uv_project_line} --with "cowsay,machineconfig[plot]>=8.51" """
+        fire_line = f"uv run {ve_line} {interpreter} {interactivity} {profile} {str(pyfile)}"
+
+    return fire_line

machineconfig/scripts/python/{helpers_croshell → helpers/helpers_croshell}/scheduler.py

@@ -26,11 +26,11 @@
 
 #     print(f"\n✅ Running tasks in {root}\n")
 
-#     if args.report:
-#         print("📊 Generating report...")
-#         reports: list[Report] = [Report.from_path(read_task_from_dir(x).report_path) for x in PathExtended(root).search("*").filter(lambda path: path.joinpath("task.py").exists())]
+    # if args.report:
+    #     print("📊 Generating report...")
+    #     reports: list[Report] = [Report.from_path(read_task_from_dir(x).report_path) for x in PathExtended(root).glob("*")]
 
-#         # Format as markdown table
+        # Format as markdown table
 #         report_data = [r.__dict__ for r in reports]
 #         if report_data:
 #             # Get keys from first report

machineconfig/scripts/python/{helpers_croshell → helpers/helpers_croshell}/start_slidev.py

@@ -83,32 +83,32 @@ def main(
 
     md_file = report_dir.joinpath("slides.md")
     if not md_file.exists():
-        res = report_dir.search("*.md")
+        res = list(report_dir.glob("*.md"))
         if len(res) == 1:
             md_file = res[0]
         else:
-            raise FileNotFoundError(f"❌ slides.md not found in {report_dir}")
+            print(f"❌ Error: slides.md not found in {report_dir}")
+            raise typer.Exit(code=1)
 
     print("📂 Copying files to Slidev repository...")
-    for item in report_dir.search():
-        item.copy(folder=SLIDEV_REPO, overwrite=True)
+    for item in report_dir.glob("*"):
+        PathExtended(item).copy(folder=SLIDEV_REPO, overwrite=True)
     if md_file.name != "slides.md":
         SLIDEV_REPO.joinpath(md_file.name).with_name(name="slides.md", inplace=True, overwrite=True)
 
-    import socket
-
-    try:
-        local_ip_v4 = socket.gethostbyname(socket.gethostname() + ".local")
-    except Exception:
-        print("⚠️ Warning: Could not get local_ip_v4. This might be due to running in a WSL instance.")
-        local_ip_v4 = socket.gethostbyname(socket.gethostname())
+    import machineconfig.scripts.python.helpers.helpers_network.address as helper
+    res = helper.select_lan_ipv4(prefer_vpn=False)
+    if res is None:
+        print("❌ Error: Could not determine local LAN IPv4 address for presentation.")
+        raise typer.Exit(code=1)
+    local_ip_v4 = res
 
     print("🌐 Presentation will be served at:")
     print(f"   - http://{platform.node()}:{port}")
     print(f"   - http://localhost:{port}")
     print(f"   - http://{local_ip_v4}:{port}\n")
 
-    program = "npm run dev slides.md -- --remote"
+    program = "bun run dev slides.md -- --remote"
     # PROGRAM_PATH.write_text(program, encoding="utf-8")
     import subprocess
 

machineconfig/scripts/python/helpers/helpers_devops/backup_config.py

@@ -0,0 +1,149 @@
+"""Backup configuration types, parsing, and reading utilities."""
+
+from collections.abc import Mapping
+from typing import TypedDict
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+import tomllib
+
+from machineconfig.utils.source_of_truth import LIBRARY_ROOT
+from machineconfig.profile.create_links_export import REPO_LOOSE
+
+LIBRARY_BACKUP_PATH = LIBRARY_ROOT.joinpath("profile/mapper_data.toml")
+USER_BACKUP_PATH = Path.home().joinpath("dotfiles/machineconfig/mapper_data.toml")
+DEFAULT_BACKUP_HEADER = "# User-defined backup configuration\n# Created by `devops data register`\n"
+VALID_OS = {"any", "windows", "linux", "darwin"}
+
+
+class BackupItem(TypedDict):
+    path_local: str
+    path_cloud: str | None
+    zip: bool
+    encrypt: bool
+    rel2home: bool
+    os: set[str]
+
+
+BackupGroup = dict[str, BackupItem]
+BackupConfig = dict[str, BackupGroup]
+
+
+def normalize_os_name(value: str) -> str:
+    return value.strip().lower()
+
+
+def _parse_os_field(os_field: object, item_name: str) -> set[str]:
+    if os_field is None:
+        raise ValueError(f"Backup entry '{item_name}' must define a non-empty 'os'.")
+    if isinstance(os_field, list):
+        raw_values = [str(item) for item in os_field]
+    elif isinstance(os_field, str):
+        raw_values = os_field.split(",")
+    else:
+        raise ValueError(f"Backup entry '{item_name}' has an invalid 'os' value: {os_field!r}.")
+    values: set[str] = set()
+    for raw in raw_values:
+        token = normalize_os_name(raw)
+        if not token:
+            continue
+        if token in {"any", "all", "*"}:
+            return {"any"}
+        if token not in VALID_OS:
+            raise ValueError(f"Backup entry '{item_name}' has an invalid 'os' value: {os_field!r}.")
+        values.add(token)
+    if not values:
+        raise ValueError(f"Backup entry '{item_name}' must define a non-empty 'os'.")
+    return values
+
+
+def os_applies(os_values: set[str], system_name: str) -> bool:
+    return "any" in os_values or system_name in os_values
+
+
+def _parse_bool(value: object, field: str, item_name: str) -> bool:
+    if isinstance(value, bool):
+        return value
+    raise ValueError(f"Backup entry '{item_name}' has an invalid '{field}' value.")
+
+
+def _require_mapping(value: object, item_name: str) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        raise ValueError(f"Backup entry '{item_name}' must be a table.")
+    return value
+
+
+def _require_str_field(raw: Mapping[str, object], field: str, item_name: str) -> str:
+    value = raw.get(field)
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError(f"Backup entry '{item_name}' must define a non-empty '{field}'.")
+    return value.strip()
+
+
+def _optional_str_field(raw: Mapping[str, object], field: str, item_name: str) -> str | None:
+    if field not in raw:
+        return None
+    value = raw.get(field)
+    if not isinstance(value, str):
+        raise ValueError(f"Backup entry '{item_name}' has a non-string '{field}'.")
+    token = value.strip()
+    if not token:
+        raise ValueError(f"Backup entry '{item_name}' has an empty '{field}'.")
+    return token
+
+
+def _require_bool_field(raw: Mapping[str, object], field: str, item_name: str) -> bool:
+    if field not in raw:
+        raise ValueError(f"Backup entry '{item_name}' must define '{field}'.")
+    return _parse_bool(raw[field], field=field, item_name=item_name)
+
+
+def _parse_backup_config(raw: Mapping[str, object]) -> BackupConfig:
+    config: BackupConfig = {}
+    for group_name, group_value in raw.items():
+        group = _require_mapping(group_value, group_name)
+        group_items: dict[str, BackupItem] = {}
+        for item_name, value in group.items():
+            item_key = f"{group_name}.{item_name}"
+            item = _require_mapping(value, item_key)
+            if "path" in item:
+                raise ValueError(f"Backup entry '{item_key}' uses 'path'; use 'path_local' instead.")
+            if "path_remote" in item:
+                raise ValueError(f"Backup entry '{item_key}' uses 'path_remote'; use 'path_cloud' instead.")
+            if "os_specific" in item:
+                raise ValueError(f"Backup entry '{item_key}' uses 'os_specific'; use 'os' only.")
+            group_items[item_name] = {
+                "path_local": _require_str_field(item, "path_local", item_key),
+                "path_cloud": _optional_str_field(item, "path_cloud", item_key),
+                "zip": _require_bool_field(item, "zip", item_key),
+                "encrypt": _require_bool_field(item, "encrypt", item_key),
+                "rel2home": _require_bool_field(item, "rel2home", item_key),
+                "os": _parse_os_field(item.get("os"), item_key),
+            }
+        if group_items:
+            config[group_name] = group_items
+    return config
+
+
+def read_backup_config(repo: REPO_LOOSE) -> BackupConfig:
+    match repo:
+        case "library" | "l":
+            path = LIBRARY_BACKUP_PATH
+            raw_config: dict[str, object] = tomllib.loads(path.read_text(encoding="utf-8"))
+            bu_file = _parse_backup_config(raw_config)
+        case "user" | "u":
+            path = USER_BACKUP_PATH
+            raw_config = tomllib.loads(path.read_text(encoding="utf-8"))
+            bu_file = _parse_backup_config(raw_config)
+        case "all" | "a":
+            console = Console()
+            console.print(Panel(f"🧰 LOADING LIBRARY BACKUP CONFIGURATION\n📄 File: {LIBRARY_BACKUP_PATH}", title="[bold blue]Backup Configuration[/bold blue]", border_style="blue"))
+            raw_library: dict[str, object] = tomllib.loads(LIBRARY_BACKUP_PATH.read_text(encoding="utf-8"))
+            bu_library = _parse_backup_config(raw_library)
+            console.print(Panel(f"🧰 LOADING USER BACKUP CONFIGURATION\n📄 File: {USER_BACKUP_PATH}", title="[bold blue]Backup Configuration[/bold blue]", border_style="blue"))
+            raw_user: dict[str, object] = tomllib.loads(USER_BACKUP_PATH.read_text(encoding="utf-8"))
+            bu_user = _parse_backup_config(raw_user)
+            bu_file = {**bu_library, **bu_user}
+        case _:
+            raise ValueError(f"Invalid which_backup value: {repo!r}.")
+    return bu_file