machineconfig 2.1__py3-none-any.whl → 2.3__py3-none-any.whl

machineconfig/scripts/python/devops_backup_retrieve.py

@@ -1,10 +1,11 @@
-"""BR: Backup and Retrieve
-"""
+"""BR: Backup and Retrieve"""
 
 # import subprocess
 from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from machineconfig.utils.utils2 import read_ini, read_toml
-from machineconfig.utils.utils import LIBRARY_ROOT, DEFAULTS_PATH, print_code, choose_cloud_interactively, choose_multiple_options
+from machineconfig.utils.source_of_truth import LIBRARY_ROOT, DEFAULTS_PATH
+from machineconfig.utils.code import print_code
+from machineconfig.utils.options import choose_cloud_interactively, choose_multiple_options
 from machineconfig.scripts.python.helpers.helpers2 import ES
 from platform import system
 from typing import Any, Literal, Optional
@@ -19,7 +20,7 @@ def main_backup_retrieve(direction: OPTIONS, which: Optional[str] = None):
     console = Console()
 
     try:
-        cloud: str = read_ini(DEFAULTS_PATH)['general']['rclone_config_name']
+        cloud: str = read_ini(DEFAULTS_PATH)["general"]["rclone_config_name"]
         console.print(Panel(f"⚠️  DEFAULT CLOUD CONFIGURATION\n🌥️  Using default cloud: {cloud}", title="[bold blue]Cloud Configuration[/bold blue]", border_style="blue"))
     except (FileNotFoundError, KeyError, IndexError):
         console.print(Panel("🔍 DEFAULT CLOUD NOT FOUND\n🔄 Please select a cloud configuration from the options below", title="[bold red]Error: Cloud Not Found[/bold red]", border_style="red"))
@@ -38,7 +39,7 @@ def main_backup_retrieve(direction: OPTIONS, which: Optional[str] = None):
 
     if which is None:
         console.print(Panel(f"🔍 SELECT {direction} ITEMS\n📋 Choose which configuration entries to process", title="[bold blue]Select Items[/bold blue]", border_style="blue"))
-        choices = choose_multiple_options(msg=f"WHICH FILE of the following do you want to {direction}?", options=['all'] + list(bu_file.keys()))
+        choices = choose_multiple_options(msg=f"WHICH FILE of the following do you want to {direction}?", options=["all"] + list(bu_file.keys()))
     else:
         choices = which.split(",") if which else []
         console.print(Panel(f"🔖 PRE-SELECTED ITEMS\n📝 Using: {', '.join(choices)}", title="[bold blue]Pre-selected Items[/bold blue]", border_style="blue"))
@@ -52,19 +53,20 @@ def main_backup_retrieve(direction: OPTIONS, which: Optional[str] = None):
     program = f"""$cloud = "{cloud}:{ES}" \n """ if system() == "Windows" else f"""cloud="{cloud}:{ES}" \n """
     console.print(Panel(f"🚀 GENERATING {direction} SCRIPT\n🌥️  Cloud: {cloud}\n🗂️  Items: {len(items)}", title="[bold blue]Script Generation[/bold blue]", border_style="blue"))
     for item_name, item in items.items():
-        flags = ''
-        flags += 'z' if item['zip'] == 'True' else ''
-        flags += 'e' if item['encrypt'] == 'True' else ''
-        flags += 'r' if item['rel2home'] == 'True' else ''
-        flags += 'o' if system().lower() in item_name else ''
+        flags = ""
+        flags += "z" if item["zip"] == "True" else ""
+        flags += "e" if item["encrypt"] == "True" else ""
+        flags += "r" if item["rel2home"] == "True" else ""
+        flags += "o" if system().lower() in item_name else ""
         console.print(Panel(f"📦 PROCESSING: {item_name}\n📂 Path: {PathExtended(item['path']).as_posix()}\n🏳️  Flags: {flags or 'None'}", title=f"[bold blue]Processing Item: {item_name}[/bold blue]", border_style="blue"))
-        if flags: flags = "-" + flags
+        if flags:
+            flags = "-" + flags
         if direction == "BACKUP":
-            program += f"""\ncloud_copy "{PathExtended(item['path']).as_posix()}" $cloud {flags}\n"""
+            program += f"""\ncloud_copy "{PathExtended(item["path"]).as_posix()}" $cloud {flags}\n"""
         elif direction == "RETRIEVE":
-            program += f"""\ncloud_copy $cloud "{PathExtended(item['path']).as_posix()}" {flags}\n"""
+            program += f"""\ncloud_copy $cloud "{PathExtended(item["path"]).as_posix()}" {flags}\n"""
         else:
-            console.print(Panel("❌ ERROR: INVALID DIRECTION\n⚠️  Direction must be either \"BACKUP\" or \"RETRIEVE\"", title="[bold red]Error: Invalid Direction[/bold red]", border_style="red"))
+            console.print(Panel('❌ ERROR: INVALID DIRECTION\n⚠️  Direction must be either "BACKUP" or "RETRIEVE"', title="[bold red]Error: Invalid Direction[/bold red]", border_style="red"))
             raise RuntimeError(f"Unknown direction: {direction}")
         if item_name == "dotfiles" and system() == "Linux":
             program += """\nchmod 700 ~/.ssh/*\n"""
@@ -80,7 +82,7 @@ def main(direction: OPTIONS, which: Optional[str] = None):
     console.print(Panel(f"🔄 {direction} OPERATION STARTED\n⏱️  {'-' * 58}", title="[bold blue]Operation Initiated[/bold blue]", border_style="blue"))
 
     code = main_backup_retrieve(direction=direction, which=which)
-    from machineconfig.utils.utils import write_shell_script_to_default_program_path
+    from machineconfig.utils.code import write_shell_script_to_default_program_path
 
     console.print(Panel("💾 GENERATING SHELL SCRIPT\n📄 Filename: backup_retrieve.sh", title="[bold blue]Shell Script Generation[/bold blue]", border_style="blue"))
 

machineconfig/scripts/python/devops_devapps_install.py

@@ -1,10 +1,10 @@
-"""Devops Devapps Install
-"""
+"""Devops Devapps Install"""
 
 # import subprocess
 from machineconfig.utils.installer_utils.installer_class import Installer
 from tqdm import tqdm
-from machineconfig.utils.utils import LIBRARY_ROOT, choose_multiple_options
+from machineconfig.utils.source_of_truth import LIBRARY_ROOT
+from machineconfig.utils.options import choose_multiple_options
 from machineconfig.utils.installer import get_installers, install_all, get_all_dicts
 from platform import system
 from typing import Any, Optional, Literal, TypeAlias, get_args
@@ -14,13 +14,12 @@ WHICH_CAT: TypeAlias = Literal["AllEssentials", "EssentialsAndOthers", "SystemIn
 
 
 def main(which: Optional[WHICH_CAT | str] = None):
-
     if which is not None and which in get_args(WHICH_CAT):  # install by category
         return get_programs_by_category(program_name=which)  # type: ignore
 
     if which is not None:  # install by name
         program_total = ""
-        for a_which in (which.split(",") if type(which) == str else which):
+        for a_which in which.split(",") if type(which) == str else which:
             kv = {}
             for _category, v in get_all_dicts(system=system()).items():
                 kv.update(v)
@@ -40,6 +39,7 @@ def main(which: Optional[WHICH_CAT | str] = None):
     # interactive installation
     installers = [Installer.from_dict(d=vd, name=name) for __kat, vds in get_all_dicts(system=system()).items() for name, vd in vds.items()]
     options = [x.get_description() for x in tqdm(installers, desc="✅ Checking installed programs")] + list(get_args(WHICH_CAT))
+    # print("s"*1000)
     program_names = choose_multiple_options(msg="", options=options, header="🚀 CHOOSE DEV APP", default="AllEssentials")
 
     total_program = ""
@@ -70,12 +70,14 @@ def get_programs_by_category(program_name: WHICH_CAT):
             program = ""
 
         case "SystemInstallers":
-            if system() == "Windows": options_system = parse_apps_installer_windows(LIBRARY_ROOT.joinpath("setup_windows/apps.ps1").read_text(encoding="utf-8"))
+            if system() == "Windows":
+                options_system = parse_apps_installer_windows(LIBRARY_ROOT.joinpath("setup_windows/apps.ps1").read_text(encoding="utf-8"))
             elif system() == "Linux":
                 options_system_1 = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps_dev.sh").read_text(encoding="utf-8"))
                 options_system_2 = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps.sh").read_text(encoding="utf-8"))
                 options_system = {**options_system_1, **options_system_2}
-            else: raise NotImplementedError(f"❌ System {system()} not supported")
+            else:
+                raise NotImplementedError(f"❌ System {system()} not supported")
             program_names = choose_multiple_options(msg="", options=sorted(list(options_system.keys())), header="🚀 CHOOSE DEV APP")
             program = ""
             for name in program_names:
@@ -84,7 +86,8 @@ def get_programs_by_category(program_name: WHICH_CAT):
 │ ⚙️  Installing: {name}
 └────────────────────────────────────────────────────""")
                 sub_program = options_system[name]
-                if sub_program.startswith("#winget"): sub_program = sub_program[1:]
+                if sub_program.startswith("#winget"):
+                    sub_program = sub_program[1:]
                 program += "\n" + sub_program
 
         # case "OtherDevApps":
@@ -105,7 +108,7 @@ def get_programs_by_category(program_name: WHICH_CAT):
         #         print(f"Installing {name}")
         #         sub_program = installers[idx].install_robust(version=None)  # finish the task
 
-        case  "PrecheckedCloudInstaller":
+        case "PrecheckedCloudInstaller":
             # from machineconfig.jobs.python.check_installations import PrecheckedCloudInstaller
             # ci = PrecheckedCloudInstaller()
             # ci.download_safe_apps(name="AllEssentials")
@@ -119,15 +122,15 @@ def parse_apps_installer_linux(txt: str) -> dict[str, Any]:
     res = {}
     for chunk in txts[1:]:
         try:
-            k = chunk.split('----')[0].rstrip().lstrip()
+            k = chunk.split("----")[0].rstrip().lstrip()
             v = "\n".join(chunk.split("\n")[1:])
             res[k] = v
         except IndexError as e:
             print(f"""
 ❌ Error parsing chunk:
-{'-' * 50}
+{"-" * 50}
 {chunk}
-{'-' * 50}""")
+{"-" * 50}""")
             raise e
     return res
 
@@ -135,28 +138,31 @@ def parse_apps_installer_linux(txt: str) -> dict[str, Any]:
 def parse_apps_installer_windows(txt: str) -> dict[str, Any]:
     chunks: list[str] = []
     for idx, item in enumerate(txt.split(sep="winget install")):
-        if idx == 0: continue
-        if idx == 1: chunks.append(item)
-        else: chunks.append("winget install" + item)
+        if idx == 0:
+            continue
+        if idx == 1:
+            chunks.append(item)
+        else:
+            chunks.append("winget install" + item)
     # progs = L(txt.splitlines()).filter(lambda x: x.startswith("winget ") or x.startswith("#winget"))
     res: dict[str, str] = {}
     for a_chunk in chunks:
         try:
-            name = a_chunk.split('--name ')[1]
+            name = a_chunk.split("--name ")[1]
             if "--Id" not in name:
                 print(f"⚠️  Warning: {name} does not have an Id, skipping")
                 continue
-            name = name.split(' --Id ', maxsplit=1)[0].strip('"').strip('"')
+            name = name.split(" --Id ", maxsplit=1)[0].strip('"').strip('"')
             res[name] = a_chunk
         except IndexError as e:
             print(f"""
 ❌ Error parsing chunk:
-{'-' * 50}
+{"-" * 50}
 {a_chunk}
-{'-' * 50}""")
+{"-" * 50}""")
             raise e
     return res
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     pass

machineconfig/scripts/python/devops_update_repos.py

@@ -1,26 +1,26 @@
-"""Update repositories with fancy output
-"""
+"""Update repositories with fancy output"""
+
 import git
 import subprocess
 import hashlib
 from pathlib import Path
 from machineconfig.utils.path_reduced import PathExtended as PathExtended
-from machineconfig.utils.utils import DEFAULTS_PATH
+from machineconfig.utils.source_of_truth import DEFAULTS_PATH
 from machineconfig.utils.utils2 import read_ini
 
 
-def _get_file_hash(file_path: Path) -> str | None:
+def get_file_hash(file_path: Path) -> str | None:
     """Get SHA256 hash of a file, return None if file doesn't exist."""
     if not file_path.exists():
         return None
     return hashlib.sha256(file_path.read_bytes()).hexdigest()
 
 
-def _set_permissions_recursive(path: Path, executable: bool = True) -> None:
+def set_permissions_recursive(path: Path, executable: bool = True) -> None:
     """Set permissions recursively for a directory."""
     if not path.exists():
         return
-    
+
     if path.is_file():
         if executable:
             path.chmod(0o755)
@@ -28,107 +28,192 @@ def _set_permissions_recursive(path: Path, executable: bool = True) -> None:
             path.chmod(0o644)
     elif path.is_dir():
         path.chmod(0o755)
-        for item in path.rglob('*'):
-            _set_permissions_recursive(item, executable)
+        for item in path.rglob("*"):
+            set_permissions_recursive(item, executable)
 
 
-def _run_uv_sync(repo_path: Path) -> None:
-    """Run uv sync in the given repository path."""
+def run_uv_sync(repo_path: Path) -> bool:
+    """Run uv sync in the given repository path. Returns True if successful."""
     try:
         print(f"🔄 Running uv sync in {repo_path}")
-        result = subprocess.run(
-            ["uv", "sync"],
-            cwd=repo_path,
-            capture_output=True,
-            text=True,
-            check=True
-        )
+        result = subprocess.run(["uv", "sync"], cwd=repo_path, capture_output=True, text=True, check=True)
         print("✅ uv sync completed successfully")
         if result.stdout:
             print(f"📝 Output: {result.stdout}")
+        return True
     except subprocess.CalledProcessError as e:
         print(f"❌ uv sync failed: {e}")
         if e.stderr:
             print(f"📝 Error: {e.stderr}")
+        return False
     except FileNotFoundError:
         print("⚠️  uv command not found. Please install uv first.")
+        return False
 
 
-def _update_repository(repo: git.Repo) -> bool:
+def update_repository(repo: git.Repo, auto_sync: bool = True, allow_password_prompt: bool = False) -> bool:
     """Update a single repository and return True if pyproject.toml or uv.lock changed."""
     repo_path = Path(repo.working_dir)
     print(f"🔄 {'Updating ' + str(repo_path):.^80}")
-    
+
     # Check if this repo has pyproject.toml or uv.lock
     pyproject_path = repo_path / "pyproject.toml"
     uv_lock_path = repo_path / "uv.lock"
-    
+
     # Get hashes before pull
-    pyproject_hash_before = _get_file_hash(pyproject_path)
-    uv_lock_hash_before = _get_file_hash(uv_lock_path)
-    
+    pyproject_hash_before = get_file_hash(pyproject_path)
+    uv_lock_hash_before = get_file_hash(uv_lock_path)
+
+    # Get current commit hash before pull
+    commit_before = repo.head.commit.hexsha
+
     try:
-        # Perform git pull for each remote
+        # Use subprocess for git pull to get better output control
         dependencies_changed = False
-        for remote in repo.remotes:
+
+        # Get list of remotes
+        remotes = list(repo.remotes)
+        if not remotes:
+            print("⚠️  No remotes configured for this repository")
+            return False
+
+        for remote in remotes:
             try:
-                print(f"📥 Pulling from {remote.name} {repo.active_branch.name}")
-                pull_info = remote.pull(repo.active_branch.name)
-                for info in pull_info:
-                    if info.flags & info.FAST_FORWARD:
-                        print("✅ Fast-forward pull completed")
-                    elif info.flags & info.NEW_HEAD:
-                        print("✅ Repository updated")
+                print(f"📥 Fetching from {remote.name}...")
+
+                # Set up environment for git commands
+                env = None
+                if not allow_password_prompt:
+                    # Disable interactive prompts
+                    import os
+
+                    env = os.environ.copy()
+                    env["GIT_TERMINAL_PROMPT"] = "0"
+                    env["GIT_ASKPASS"] = "echo"  # Returns empty string for any credential request
+
+                # First fetch to see what's available
+                fetch_result = subprocess.run(
+                    ["git", "fetch", remote.name, "--verbose"],
+                    cwd=repo_path,
+                    capture_output=True,
+                    text=True,
+                    env=env,
+                    timeout=30,  # Add timeout to prevent hanging
+                )
+
+                # Check if fetch failed due to authentication
+                if fetch_result.returncode != 0 and not allow_password_prompt:
+                    auth_error_indicators = [
+                        "Authentication failed",
+                        "Password for",
+                        "Username for",
+                        "could not read Username",
+                        "could not read Password",
+                        "fatal: Authentication failed",
+                        "fatal: could not read Username",
+                        "fatal: could not read Password",
+                    ]
+
+                    error_output = (fetch_result.stderr or "") + (fetch_result.stdout or "")
+                    if any(indicator in error_output for indicator in auth_error_indicators):
+                        print(f"⚠️  Skipping {remote.name} - authentication required but password prompts are disabled")
+                        continue
+
+                if fetch_result.stdout:
+                    print(f"📡 Fetch output: {fetch_result.stdout.strip()}")
+                if fetch_result.stderr:
+                    print(f"📡 Fetch info: {fetch_result.stderr.strip()}")
+
+                # Now pull with verbose output
+                print(f"📥 Pulling from {remote.name}/{repo.active_branch.name}...")
+                pull_result = subprocess.run(["git", "pull", remote.name, repo.active_branch.name, "--verbose"], cwd=repo_path, capture_output=True, text=True, env=env, timeout=30)
+
+                # Check if pull failed due to authentication
+                if pull_result.returncode != 0 and not allow_password_prompt:
+                    auth_error_indicators = [
+                        "Authentication failed",
+                        "Password for",
+                        "Username for",
+                        "could not read Username",
+                        "could not read Password",
+                        "fatal: Authentication failed",
+                        "fatal: could not read Username",
+                        "fatal: could not read Password",
+                    ]
+
+                    error_output = (pull_result.stderr or "") + (pull_result.stdout or "")
+                    if any(indicator in error_output for indicator in auth_error_indicators):
+                        print(f"⚠️  Skipping pull from {remote.name} - authentication required but password prompts are disabled")
+                        continue
+
+                if pull_result.stdout:
+                    print(f"📦 Pull output: {pull_result.stdout.strip()}")
+                if pull_result.stderr:
+                    print(f"📦 Pull info: {pull_result.stderr.strip()}")
+
+                # Check if pull was successful
+                if pull_result.returncode == 0:
+                    # Check if commits changed
+                    commit_after = repo.head.commit.hexsha
+                    if commit_before != commit_after:
+                        print(f"✅ Repository updated: {commit_before[:8]} → {commit_after[:8]}")
                     else:
-                        print(f"✅ Pull completed: {info.flags}")
+                        print("✅ Already up to date")
+                else:
+                    print(f"❌ Pull failed with return code {pull_result.returncode}")
+
             except Exception as e:
                 print(f"⚠️  Failed to pull from {remote.name}: {e}")
                 continue
-        
+
         # Check if pyproject.toml or uv.lock changed after pull
-        pyproject_hash_after = _get_file_hash(pyproject_path)
-        uv_lock_hash_after = _get_file_hash(uv_lock_path)
-        
+        pyproject_hash_after = get_file_hash(pyproject_path)
+        uv_lock_hash_after = get_file_hash(uv_lock_path)
+
         if pyproject_hash_before != pyproject_hash_after:
             print("📋 pyproject.toml has changed")
             dependencies_changed = True
-            
+
         if uv_lock_hash_before != uv_lock_hash_after:
             print("🔒 uv.lock has changed")
             dependencies_changed = True
-        
+
         # Special handling for machineconfig repository
         if "machineconfig" in str(repo_path):
             print("🛠  Special handling for machineconfig repository...")
             scripts_path = Path.home() / "scripts"
             if scripts_path.exists():
-                _set_permissions_recursive(scripts_path)
+                set_permissions_recursive(scripts_path)
                 print(f"✅ Set permissions for {scripts_path}")
-            
+
             linux_jobs_path = repo_path / "src" / "machineconfig" / "jobs" / "linux"
             if linux_jobs_path.exists():
-                _set_permissions_recursive(linux_jobs_path)
+                set_permissions_recursive(linux_jobs_path)
                 print(f"✅ Set permissions for {linux_jobs_path}")
-            
+
             lf_exe_path = repo_path / "src" / "machineconfig" / "settings" / "lf" / "linux" / "exe"
             if lf_exe_path.exists():
-                _set_permissions_recursive(lf_exe_path)
+                set_permissions_recursive(lf_exe_path)
                 print(f"✅ Set permissions for {lf_exe_path}")
-        
+
+        # Run uv sync if dependencies changed and auto_sync is enabled
+        if dependencies_changed and auto_sync:
+            run_uv_sync(repo_path)
+
         return dependencies_changed
-        
+
     except Exception as e:
         print(f"❌ Error updating repository {repo_path}: {e}")
         return False
 
 
-def main(verbose: bool = True) -> str:
+def main(verbose: bool = True, allow_password_prompt: bool = False) -> str:
     """Main function to update all configured repositories."""
     _ = verbose
-    repos: list[str] = ["~/code/machineconfig", "~/code/machineconfig", ]
+    repos: list[str] = ["~/code/machineconfig", "~/code/crocodile"]
     try:
-        tmp = read_ini(DEFAULTS_PATH)['general']['repos'].split(",")
-        if tmp[-1] == "": 
+        tmp = read_ini(DEFAULTS_PATH)["general"]["repos"].split(",")
+        if tmp[-1] == "":
             tmp = tmp[:-1]
         repos += tmp
     except (FileNotFoundError, KeyError, IndexError):
@@ -154,25 +239,25 @@ def main(verbose: bool = True) -> str:
         try:
             expanded_path = PathExtended(a_package_path).expanduser()
             repo = git.Repo(str(expanded_path), search_parent_directories=True)
-            
+
             # Update repository and check if dependencies changed
-            dependencies_changed = _update_repository(repo)
-            
+            dependencies_changed = update_repository(repo, allow_password_prompt=allow_password_prompt)
+
             if dependencies_changed:
                 repos_with_changes.append(Path(repo.working_dir))
-                
+
         except Exception as ex:
             print(f"""❌ Repository Error: Path: {a_package_path}
 Exception: {ex}
-{'-' * 50}""")
+{"-" * 50}""")
 
     # Run uv sync for repositories where pyproject.toml or uv.lock changed
     for repo_path in repos_with_changes:
-        _run_uv_sync(repo_path)
+        run_uv_sync(repo_path)
 
     # print("\n🎉 All repositories updated successfully!")
     return """echo "🎉 All repositories updated successfully!" """
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

machineconfig/scripts/python/dotfile.py

@@ -1,15 +1,13 @@
-"""Like yadm and dotter.
-"""
-
+"""Like yadm and dotter."""
 
 from machineconfig.utils.path_reduced import PathExtended as PathExtended
-from machineconfig.profile.create import symlink_func
-from machineconfig.utils.utils import LIBRARY_ROOT, REPO_ROOT
+from machineconfig.utils.links import symlink_func
+from machineconfig.utils.source_of_truth import LIBRARY_ROOT, REPO_ROOT
 import argparse
 
 
 def main():
-    parser = argparse.ArgumentParser(description='FTP client')
+    parser = argparse.ArgumentParser(description="FTP client")
 
     parser.add_argument("file", help="file/folder path.", default="")
     # FLAGS
@@ -20,11 +18,15 @@ def main():
     args = parser.parse_args()
     orig_path = PathExtended(args.file).expanduser().absolute()
     if args.dest == "":
-        if "Local" in str(orig_path): junction = orig_path.split(at="Local", sep=-1)[1]
-        elif "Roaming" in str(orig_path): junction = orig_path.split(at="Roaming", sep=-1)[1]
-        elif ".config" in str(orig_path): junction = orig_path.split(at=".config", sep=-1)[1]
-        else: junction = orig_path.rel2home()
-        new_path = REPO_ROOT.joinpath(junction)
+        if "Local" in str(orig_path):
+            junction = orig_path.split(at="Local", sep=-1)[1]
+        elif "Roaming" in str(orig_path):
+            junction = orig_path.split(at="Roaming", sep=-1)[1]
+        elif ".config" in str(orig_path):
+            junction = orig_path.split(at=".config", sep=-1)[1]
+        else:
+            junction = orig_path.rel2home()
+        new_path = PathExtended(REPO_ROOT).joinpath(junction)
     else:
         dest_path = PathExtended(args.dest).expanduser().absolute()
         dest_path.mkdir(parents=True, exist_ok=True)
@@ -39,12 +41,12 @@ def main():
 ┃ 🔄 To enshrine this mapping, add the following to mapper.toml:
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
     print(f"""
-📝 Edit configuration file: nano {LIBRARY_ROOT}/symlinks/mapper.toml
+📝 Edit configuration file: nano {PathExtended(LIBRARY_ROOT)}/symlinks/mapper.toml
 
 [{new_path.parent.name}]
-{orig_path.name.split('.')[0]} = {{ this = '{orig_path.collapseuser().as_posix()}', to_this = '{new_path.collapseuser().as_posix()}' }}
+{orig_path.name.split(".")[0]} = {{ this = '{orig_path.collapseuser().as_posix()}', to_this = '{new_path.collapseuser().as_posix()}' }}
 """)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()