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

machineconfig/utils/installer_utils/installer_class.py

@@ -1,55 +1,68 @@
-
-from machineconfig.utils.path_reduced import P as PathExtended
-from crocodile.meta import Terminal
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from machineconfig.utils.installer_utils.installer_abc import find_move_delete_linux, find_move_delete_windows
 from machineconfig.utils.utils import INSTALL_TMP_DIR, INSTALL_VERSION_ROOT, LIBRARY_ROOT, check_tool_exists
 from machineconfig.utils.utils2 import pprint, read_json
 
 import platform
+import subprocess
 from typing import Any, Optional
 from pathlib import Path
 
 
 class Installer:
-    def __init__(self, repo_url: str, name: str, doc: str,
-                strip_v: bool, exe_name: str,
-                filename_template_windows_amd_64: str,
-                filename_template_linux_amd_64: str,
-                filename_template_windows_arm_64: Optional[str] = None,
-                filename_template_linux_arm_64: Optional[str] = None,
-                filename_template_macos_amd_64: Optional[str] = None,
-                filename_template_macos_arm_64: Optional[str] = None,
-                ):
-        self.repo_url: str=repo_url
-        self.name: str=name
-        self.doc: str=doc
-        self.filename_template_windows_amd_64: str=filename_template_windows_amd_64
-        self.filename_template_linux_amd_64: str=filename_template_linux_amd_64
-        self.filename_template_windows_arm_64: Optional[str]=filename_template_windows_arm_64
-        self.filename_template_linux_arm_64: Optional[str]=filename_template_linux_arm_64
-        self.filename_template_macos_amd_64: Optional[str]=filename_template_macos_amd_64
-        self.filename_template_macos_arm_64: Optional[str]=filename_template_macos_arm_64
-        self.strip_v: bool=strip_v
-        self.exe_name: str=exe_name
-    def __repr__(self) -> str: return f"Installer of {self.repo_url}"
+    def __init__(
+        self,
+        repo_url: str,
+        name: str,
+        doc: str,
+        strip_v: bool,
+        exe_name: str,
+        filename_template_windows_amd_64: str,
+        filename_template_linux_amd_64: str,
+        filename_template_windows_arm_64: Optional[str] = None,
+        filename_template_linux_arm_64: Optional[str] = None,
+        filename_template_macos_amd_64: Optional[str] = None,
+        filename_template_macos_arm_64: Optional[str] = None,
+    ):
+        self.repo_url: str = repo_url
+        self.name: str = name
+        self.doc: str = doc
+        self.filename_template_windows_amd_64: str = filename_template_windows_amd_64
+        self.filename_template_windows_arm_64: Optional[str] = filename_template_windows_arm_64
+        self.filename_template_linux_arm_64: Optional[str] = filename_template_linux_arm_64
+        self.filename_template_linux_amd_64: str = filename_template_linux_amd_64
+        self.filename_template_macos_amd_64: Optional[str] = filename_template_macos_amd_64
+        self.filename_template_macos_arm_64: Optional[str] = filename_template_macos_arm_64
+        self.strip_v: bool = strip_v
+        self.exe_name: str = exe_name
+
+    def __repr__(self) -> str:
+        return f"Installer of {self.exe_name} {self.name} @ {self.repo_url}"
+
     def get_description(self):
         # old_version_cli = Terminal().run(f"{self.exe_name} --version").op.replace("\n", "")
         # old_version_cli = os.system(f"{self.exe_name} --version").replace("\n", "")
-        old_version_cli: bool=check_tool_exists(tool_name=self.exe_name)
+        old_version_cli: bool = check_tool_exists(tool_name=self.exe_name)
         old_version_cli_str = "✅" if old_version_cli else "❌"
         # name_version = f"{self.exe_name} {old_version_cli_str}"
         return f"{self.exe_name:<12} {old_version_cli_str} {self.doc}"
-    def to_dict(self): return self.__dict__
+
+    def to_dict(self):
+        return self.__dict__
+
     @staticmethod
     def from_dict(d: dict[str, Any], name: str):
-        try: return Installer(name=name, **d)
+        try:
+            return Installer(name=name, **d)
         except Exception as ex:
             pprint(d, "Installer Creation Error")
             raise ex
+
     @staticmethod
     def choose_app_and_install():
-        print(f"\n{'='*80}\n🔍 SELECT APPLICATION TO INSTALL 🔍\n{'='*80}")
+        print(f"\n{'=' * 80}\n🔍 SELECT APPLICATION TO INSTALL 🔍\n{'=' * 80}")
         from machineconfig.utils.utils import choose_one_option
+
         print("📂 Searching for configuration files...")
         jobs_dir = Path(LIBRARY_ROOT.joinpath("jobs"))
         config_paths = [Path(p) for p in jobs_dir.rglob("config.json")]
@@ -62,18 +75,20 @@ class Installer:
         installer = Installer.from_dict(d=config[app_name], name=app_name)
         print(f"📦 Selected application: {installer.exe_name}")
         version = input(f"📝 Enter version to install for {installer.exe_name} [latest]: ") or None
-        print(f"\n{'='*80}\n🚀 INSTALLING {installer.exe_name.upper()} 🚀\n{'='*80}")
+        print(f"\n{'=' * 80}\n🚀 INSTALLING {installer.exe_name.upper()} 🚀\n{'=' * 80}")
         installer.install(version=version)
 
     def install_robust(self, version: Optional[str]):
         try:
-            print(f"\n{'='*80}\n🚀 INSTALLING {self.exe_name.upper()} 🚀\n{'='*80}")
-            old_version_cli = Terminal().run(f"{self.exe_name} --version").op.replace("\n", "")
+            print(f"\n{'=' * 80}\n🚀 INSTALLING {self.exe_name.upper()} 🚀\n{'=' * 80}")
+            result_old = subprocess.run(f"{self.exe_name} --version", shell=True, capture_output=True, text=True)
+            old_version_cli = result_old.stdout.strip()
             print(f"📊 Current version: {old_version_cli or 'Not installed'}")
 
             self.install(version=version)
 
-            new_version_cli = Terminal().run(f"{self.exe_name} --version").op.replace("\n", "")
+            result_new = subprocess.run(f"{self.exe_name} --version", shell=True, capture_output=True, text=True)
+            new_version_cli = result_new.stdout.strip()
             print(f"📊 New version: {new_version_cli}")
 
             if old_version_cli == new_version_cli:
@@ -88,10 +103,11 @@ class Installer:
             return f"""echo "📦️ ❌ Failed to install `{self.name}` with error: {ex}" """
 
     def install(self, version: Optional[str]):
-        print(f"\n{'='*80}\n🔧 INSTALLATION PROCESS: {self.exe_name} 🔧\n{'='*80}")
+        print(f"\n{'=' * 80}\n🔧 INSTALLATION PROCESS: {self.exe_name} 🔧\n{'=' * 80}")
         if self.repo_url == "CUSTOM":
             print(f"🧩 Using custom installer for {self.exe_name}")
             import machineconfig.jobs.python_custom_installers as python_custom_installers
+
             installer_path = Path(python_custom_installers.__file__).parent.joinpath(self.exe_name + ".py")
             if not installer_path.exists():
                 installer_path = Path(python_custom_installers.__file__).parent.joinpath("dev", self.exe_name + ".py")
@@ -100,15 +116,25 @@ class Installer:
                 print(f"🔍 Found installer at: {installer_path}")
 
             import runpy
+
             print(f"⚙️  Executing function 'main' from '{installer_path}'...")
-            program: str = runpy.run_path(str(installer_path), run_name=None)['main'](version=version)
+            program: str = runpy.run_path(str(installer_path), run_name=None)["main"](version=version)
             # print(program)
             print("🚀 Running installation script...")
-            Terminal(stdin=None, stdout=None, stderr=None).run_script(script=program, shell="default").print(desc="Running custom installer", capture=True)
-            # import subprocess
-            # subprocess.run(program, shell=True, check=True)
+            if platform.system() == "Linux":
+                script = "#!/bin/bash" + "\n" + program
+            else:
+                script = program
+            script_file = PathExtended.tmpfile(name="tmp_shell_script", suffix=".ps1" if platform.system() == "Windows" else ".sh", folder="tmp_scripts").write_text(script, newline=None if platform.system() == "Windows" else "\n")
+            if platform.system() == "Windows":
+                start_cmd = "powershell"
+                full_command = f"{start_cmd} {script_file}"
+            else:
+                start_cmd = "bash"
+                full_command = f"{start_cmd} {script_file}"
+            subprocess.run(full_command, stdin=None, stdout=None, stderr=None, shell=True, text=True)
             version_to_be_installed = str(version)
-            print(f"✅ Custom installation completed\n{'='*80}")
+            print(f"✅ Custom installation completed\n{'=' * 80}")
 
         elif "npm " in self.repo_url or "pip " in self.repo_url or "winget " in self.repo_url:
             package_manager = self.repo_url.split(" ", maxsplit=1)[0]
@@ -116,8 +142,16 @@ class Installer:
             desc = package_manager + " installation"
             version_to_be_installed = package_manager + "Latest"
             print(f"🚀 Running: {self.repo_url}")
-            Terminal().run(self.repo_url, shell="default").capture().print_if_unsuccessful(desc=desc, strict_err=True, strict_returncode=True)
-            print(f"✅ Package manager installation completed\n{'='*80}")
+            result = subprocess.run(self.repo_url, shell=True, capture_output=True, text=True)
+            success = result.returncode == 0 and result.stderr == ""
+            if not success:
+                print(f"❌ {desc} failed")
+                if result.stdout:
+                    print(f"STDOUT: {result.stdout}")
+                if result.stderr:
+                    print(f"STDERR: {result.stderr}")
+                print(f"Return code: {result.returncode}")
+            print(f"✅ Package manager installation completed\n{'=' * 80}")
 
         else:
             print("📥 Downloading from repository...")
@@ -125,10 +159,19 @@ class Installer:
             if str(downloaded).endswith(".deb"):
                 print(f"📦 Installing .deb package: {downloaded}")
                 assert platform.system() == "Linux"
-                Terminal().run(f"sudo nala install -y {downloaded}").capture().print_if_unsuccessful(desc="Installing .deb", strict_err=True, strict_returncode=True)
+                result = subprocess.run(f"sudo nala install -y {downloaded}", shell=True, capture_output=True, text=True)
+                success = result.returncode == 0 and result.stderr == ""
+                if not success:
+                    desc = "Installing .deb"
+                    print(f"❌ {desc} failed")
+                    if result.stdout:
+                        print(f"STDOUT: {result.stdout}")
+                    if result.stderr:
+                        print(f"STDERR: {result.stderr}")
+                    print(f"Return code: {result.returncode}")
                 print("🗑️  Cleaning up .deb package...")
                 downloaded.delete(sure=True)
-                print(f"✅ DEB package installation completed\n{'='*80}")
+                print(f"✅ DEB package installation completed\n{'=' * 80}")
             else:
                 if platform.system() == "Windows":
                     print("🪟 Installing on Windows...")
@@ -146,6 +189,7 @@ class Installer:
                 if exe.name.replace(".exe", "") != self.exe_name.replace(".exe", ""):
                     from rich import print as pprint
                     from rich.panel import Panel
+
                     print("⚠️  Warning: Executable name mismatch")
                     pprint(Panel(f"Expected exe name: [red]{self.exe_name}[/red] \nAttained name: [red]{exe.name.replace('.exe', '')}[/red]", title="exe name mismatch", subtitle=self.repo_url))
                     new_exe_name = self.exe_name + ".exe" if platform.system() == "Windows" else self.exe_name
@@ -154,31 +198,31 @@ class Installer:
 
         print(f"💾 Saving version information to: {INSTALL_VERSION_ROOT.joinpath(self.exe_name)}")
         INSTALL_VERSION_ROOT.joinpath(self.exe_name).parent.mkdir(parents=True, exist_ok=True)
-        INSTALL_VERSION_ROOT.joinpath(self.exe_name).write_text(version_to_be_installed)
-        print(f"✅ Installation completed successfully!\n{'='*80}")
+        INSTALL_VERSION_ROOT.joinpath(self.exe_name).write_text(version_to_be_installed, encoding="utf-8")
+        print(f"✅ Installation completed successfully!\n{'=' * 80}")
 
     def download(self, version: Optional[str]):
-        print(f"\n{'='*80}\n📥 DOWNLOADING: {self.exe_name} 📥\n{'='*80}")
+        print(f"\n{'=' * 80}\n📥 DOWNLOADING: {self.exe_name} 📥\n{'=' * 80}")
+        download_link: Optional[Path] = None
+        version_to_be_installed: Optional[str] = None
         if "github" not in self.repo_url or ".zip" in self.repo_url or ".tar.gz" in self.repo_url:
             download_link = Path(self.repo_url)
             version_to_be_installed = "predefined_url"
             print(f"🔗 Using direct download URL: {download_link}")
             print(f"📦 Version to be installed: {version_to_be_installed}")
-
-        elif "http" in self.filename_template_linux_amd_64 or "http" in self.filename_template_windows_amd_64:
-            if platform.system() == "Windows":
-                download_link = Path(self.filename_template_windows_amd_64)
-                print(f"🪟 Using Windows-specific download URL: {download_link}")
-            elif platform.system() in ["Linux", "Darwin"]:
-                download_link = Path(self.filename_template_linux_amd_64)
-                system_name = "Linux" if platform.system() == "Linux" else "macOS"
-                print(f"🐧 Using {system_name}-specific download URL: {download_link}")
+        elif self._any_direct_http_template():
+            template, arch = self._select_template()
+            if not template.startswith("http"):
+                # Fall back to github-style handling below
+                pass
             else:
-                error_msg = f"❌ ERROR: System {platform.system()} not supported"
-                print(error_msg)
-                raise NotImplementedError(error_msg)
-
-            version_to_be_installed = "predefined_url"
+                download_link = Path(template)
+                version_to_be_installed = "predefined_url"
+                system_name = self._system_name()
+                print(f"🧭 Detected system={system_name} arch={arch}")
+                print(f"🔗 Using architecture-specific direct URL: {download_link}")
+                print(f"📦 Version to be installed: {version_to_be_installed}")
+                # continue to unified download logic below
 
         else:
             print("🌐 Retrieving release information from GitHub...")
@@ -189,36 +233,97 @@ class Installer:
             version_to_be_installed_stripped = version_to_be_installed.replace("v", "") if self.strip_v else version_to_be_installed
             version_to_be_installed_stripped = version_to_be_installed_stripped.replace("ipinfo-", "")
 
-            if platform.system() == "Windows":
-                file_name = self.filename_template_windows_amd_64.format(version_to_be_installed_stripped)
-                print(f"🪟 Windows file name: {file_name}")
-            elif platform.system() in ["Linux", "Darwin"]:
-                file_name = self.filename_template_linux_amd_64.format(version_to_be_installed_stripped)
-                system_name = "Linux" if platform.system() == "Linux" else "macOS"
-                print(f"🐧 {system_name} file name: {file_name}")
-            else:
-                error_msg = f"❌ ERROR: System {platform.system()} not supported"
-                print(error_msg)
-                raise NotImplementedError(error_msg)
+            template, arch = self._select_template()
+            system_name = self._system_name()
+            file_name = template.format(version_to_be_installed_stripped)
+            print(f"🧭 Detected system={system_name} arch={arch}")
+            print(f"📄 Using template: {template}")
+            print(f"🗂️  Resolved file name: {file_name}")
 
             print(f"📄 File name: {file_name}")
             download_link = release_url.joinpath(file_name)
 
+        assert download_link is not None, "download_link must be set"
+        assert version_to_be_installed is not None, "version_to_be_installed must be set"
         print(f"📥 Downloading {self.name} from: {download_link}")
         downloaded = PathExtended(download_link).download(folder=INSTALL_TMP_DIR).decompress()
-        print(f"✅ Download and extraction completed to: {downloaded}\n{'='*80}")
+        print(f"✅ Download and extraction completed to: {downloaded}\n{'=' * 80}")
         return downloaded, version_to_be_installed
 
+    # --------------------------- Arch / template helpers ---------------------------
+    def _normalized_arch(self) -> str:
+        arch_raw = platform.machine().lower()
+        if arch_raw in ("x86_64", "amd64"):
+            return "amd64"
+        if arch_raw in ("aarch64", "arm64", "armv8", "armv8l"):
+            return "arm64"
+        return arch_raw
+
+    def _system_name(self) -> str:
+        sys_ = platform.system()
+        if sys_ == "Darwin":
+            return "macOS"
+        return sys_
+
+    def _any_direct_http_template(self) -> bool:
+        templates: list[Optional[str]] = [
+            self.filename_template_windows_amd_64,
+            self.filename_template_windows_arm_64,
+            self.filename_template_linux_amd_64,
+            self.filename_template_linux_arm_64,
+            self.filename_template_macos_amd_64,
+            self.filename_template_macos_arm_64,
+        ]
+        return any(t for t in templates if t is not None and t.startswith("http"))
+
+    def _select_template(self) -> tuple[str, str]:
+        sys_name = platform.system()
+        arch = self._normalized_arch()
+        # mapping logic
+        candidates: list[str] = []
+        template: Optional[str] = None
+        if sys_name == "Windows":
+            if arch == "arm64" and self.filename_template_windows_arm_64:
+                template = self.filename_template_windows_arm_64
+            else:
+                template = self.filename_template_windows_amd_64
+            candidates = ["filename_template_windows_arm_64", "filename_template_windows_amd_64"]
+        elif sys_name == "Linux":
+            if arch == "arm64" and self.filename_template_linux_arm_64:
+                template = self.filename_template_linux_arm_64
+            else:
+                template = self.filename_template_linux_amd_64
+            candidates = ["filename_template_linux_arm_64", "filename_template_linux_amd_64"]
+        elif sys_name == "Darwin":
+            if arch == "arm64" and self.filename_template_macos_arm_64:
+                template = self.filename_template_macos_arm_64
+            elif arch == "amd64" and self.filename_template_macos_amd_64:
+                template = self.filename_template_macos_amd_64
+            else:
+                # fallback between available mac templates
+                template = self.filename_template_macos_arm_64 or self.filename_template_macos_amd_64
+            candidates = ["filename_template_macos_arm_64", "filename_template_macos_amd_64"]
+        else:
+            raise NotImplementedError(f"System {sys_name} not supported")
+
+        if template is None:
+            raise ValueError(f"No filename template available for system={sys_name} arch={arch}. Checked {candidates}")
+
+        return template, arch
+
     @staticmethod
     def get_github_release(repo_url: str, version: Optional[str] = None):
-        print(f"\n{'='*80}\n🔍 GITHUB RELEASE DETECTION 🔍\n{'='*80}")
+        print(f"\n{'=' * 80}\n🔍 GITHUB RELEASE DETECTION 🔍\n{'=' * 80}")
         print(f"🌐 Inspecting releases at: {repo_url}")
         # with console.status("Installing..."):  # makes troubles on linux when prompt asks for password to move file to /usr/bin
         if version is None:
             # see this: https://api.github.com/repos/cointop-sh/cointop/releases/latest
             print("🔍 Finding latest version...")
             import requests  # https://docs.github.com/en/repositories/releasing-projects-on-github/linking-to-releases
-            _latest_version = requests.get(str(repo_url) + "/releases/latest", timeout=10).url.split("/")[-1]  # this is to resolve the redirection that occures: https://stackoverflow.com/questions/36070821/how-to-get-redirect-url-using-python-requests
+
+            _latest_version = requests.get(str(repo_url) + "/releases/latest", timeout=10).url.split("/")[
+                -1
+            ]  # this is to resolve the redirection that occures: https://stackoverflow.com/questions/36070821/how-to-get-redirect-url-using-python-requests
             version_to_be_installed = _latest_version
             print(f"✅ Latest version detected: {version_to_be_installed}")
             # print(version_to_be_installed)
@@ -227,12 +332,12 @@ class Installer:
             print(f"📝 Using specified version: {version_to_be_installed}")
 
         release_url = Path(repo_url + "/releases/download/" + version_to_be_installed)
-        print(f"🔗 Release download URL: {release_url}\n{'='*80}")
+        print(f"🔗 Release download URL: {release_url}\n{'=' * 80}")
         return release_url, version_to_be_installed
 
     @staticmethod
     def check_if_installed_already(exe_name: str, version: str, use_cache: bool):
-        print(f"\n{'='*80}\n🔍 CHECKING INSTALLATION STATUS: {exe_name} 🔍\n{'='*80}")
+        print(f"\n{'=' * 80}\n🔍 CHECKING INSTALLATION STATUS: {exe_name} 🔍\n{'=' * 80}")
         version_to_be_installed = version
         INSTALL_VERSION_ROOT.joinpath(exe_name).parent.mkdir(parents=True, exist_ok=True)
         tmp_path = INSTALL_VERSION_ROOT.joinpath(exe_name)
@@ -240,19 +345,19 @@ class Installer:
         if use_cache:
             print("🗂️  Using cached version information...")
             if tmp_path.exists():
-                existing_version = tmp_path.read_text().rstrip()
+                existing_version = tmp_path.read_text(encoding="utf-8").rstrip()
                 print(f"📄 Found cached version: {existing_version}")
             else:
                 existing_version = None
                 print("ℹ️  No cached version information found")
         else:
             print("🔍 Checking installed version directly...")
-            resp = Terminal().run(exe_name, "--version", check=False).capture()
-            if resp.op == '':
+            result = subprocess.run([exe_name, "--version"], check=False, capture_output=True, text=True)
+            if result.stdout.strip() == "":
                 existing_version = None
                 print("ℹ️  Could not detect installed version")
             else:
-                existing_version = resp.op.strip()
+                existing_version = result.stdout.strip()
                 print(f"📄 Detected installed version: {existing_version}")
 
         if existing_version is not None:
@@ -262,11 +367,11 @@ class Installer:
                 return ("✅ Uptodate", version.strip(), version_to_be_installed.strip())
             else:
                 print(f"🔄 {exe_name} needs update: {existing_version.rstrip()} → {version_to_be_installed}")
-                tmp_path.write_text(version_to_be_installed)
+                tmp_path.write_text(version_to_be_installed, encoding="utf-8")
                 return ("❌ Outdated", existing_version.strip(), version_to_be_installed.strip())
         else:
             print(f"📦 {exe_name} is not installed. Will install version: {version_to_be_installed}")
-            tmp_path.write_text(version_to_be_installed)
+            tmp_path.write_text(version_to_be_installed, encoding="utf-8")
 
-        print(f"{'='*80}")
-        return ("⚠️ NotInstalled", "None", version_to_be_installed.strip())
+        print(f"{'=' * 80}")
+        return ("⚠️ NotInstalled", "None", version_to_be_installed.strip())

machineconfig/utils/io_save.py

@@ -5,16 +5,8 @@ from pathlib import Path
 import json
 import pickle
 import configparser
-
-try:
-    import toml  # type: ignore
-except Exception:  # pragma: no cover
-    toml = None  # type: ignore
-
-try:
-    import yaml  # type: ignore
-except Exception:  # pragma: no cover
-    yaml = None  # type: ignore
+import toml
+import yaml
 
 
 PathLike = Union[str, Path]
@@ -46,8 +38,6 @@ def save_json(obj: Any, path: PathLike, indent: Optional[int] = None, verbose: b
 
 
 def save_toml(obj: Mapping[str, Any], path: PathLike, verbose: bool = False) -> Path:
-    if toml is None:
-        raise RuntimeError("toml package is required to write TOML files")
     path_obj = _ensure_parent(path)
     with open(path_obj, "w", encoding="utf-8") as fh:
         toml.dump(obj, fh)
@@ -57,8 +47,6 @@ def save_toml(obj: Mapping[str, Any], path: PathLike, verbose: bool = False) ->
 
 
 def save_yaml(obj: Any, path: PathLike, verbose: bool = False) -> Path:
-    if yaml is None:
-        raise RuntimeError("PyYAML is required to write YAML files")
     path_obj = _ensure_parent(path)
     with open(path_obj, "w", encoding="utf-8") as fh:
         yaml.safe_dump(obj, fh, sort_keys=False)
@@ -80,7 +68,7 @@ def save_ini(path: PathLike, obj: Mapping[str, Mapping[str, Any]], verbose: bool
 
 
 class Save:
-    """Drop-in replacement for crocodile's Save helper.
+    """
 
     Provides static methods for common serialization formats while ensuring
     parent directories exist and returning a `P` path object.

machineconfig/utils/links.py

@@ -1,4 +1,4 @@
-from machineconfig.utils.path_reduced import P as PathExtended, PLike
+from machineconfig.utils.path_reduced import PathExtended as PathExtended, PLike
 from machineconfig.utils.utils2 import randstr
 from rich.console import Console
 from rich.panel import Panel
@@ -19,6 +19,7 @@ def build_links(target_paths: list[tuple[PLike, str]], repo_root: PLike):
         target_dirs_filtered.append((a_dir_obj, a_name))
 
     import git
+
     repo = git.Repo(repo_root, search_parent_directories=True)
     root_maybe = repo.working_tree_dir
     assert root_maybe is not None
@@ -31,7 +32,8 @@ def build_links(target_paths: list[tuple[PLike, str]], repo_root: PLike):
         links_path = repo_root_obj.joinpath("links", a_name)
         links_path.symlink_to(target=a_target_path)
 
-def symlink_func(this: PathExtended, to_this: PathExtended, prioritize_to_this: bool=True):
+
+def symlink_func(this: PathExtended, to_this: PathExtended, prioritize_to_this: bool = True):
     """helper function. creates a symlink from `this` to `to_this`.
     What can go wrong?
     depending on this and to_this existence, one will be prioretized depending on overwrite value.
@@ -39,15 +41,19 @@ def symlink_func(this: PathExtended, to_this: PathExtended, prioritize_to_this:
     False means to_this will potentially be overwittten."""
     this = PathExtended(this).expanduser().absolute()
     to_this = PathExtended(to_this).expanduser().absolute()
-    if this.is_symlink(): this.delete(sure=True)  # delete if it exists as symblic link, not a concrete path.
+    if this.is_symlink():
+        this.delete(sure=True)  # delete if it exists as symblic link, not a concrete path.
     if this.exists():  # this is a problem. It will be resolved via `overwrite`
         if prioritize_to_this is True:  # it *can* be deleted, but let's look at target first.
             if to_this.exists():  # this exists, to_this as well. to_this is prioritized.
                 this.append(f".orig_{randstr()}", inplace=True)  # rename is better than deletion
-            else: this.move(path=to_this)  # this exists, to_this doesn't. to_this is prioritized.
+            else:
+                this.move(path=to_this)  # this exists, to_this doesn't. to_this is prioritized.
         elif prioritize_to_this is False:  # don't sacrefice this, sacrefice to_this.
-            if to_this.exists(): this.move(path=to_this, overwrite=True)  # this exists, to_this as well, this is prioritized.   # now we are readly to make the link
-            else: this.move(path=to_this)  # this exists, to_this doesn't, this is prioritized.
+            if to_this.exists():
+                this.move(path=to_this, overwrite=True)  # this exists, to_this as well, this is prioritized.   # now we are readly to make the link
+            else:
+                this.move(path=to_this)  # this exists, to_this doesn't, this is prioritized.
     else:  # this doesn't exist.
         if not to_this.exists():
             to_this.parent.mkdir(parents=True, exist_ok=True)
@@ -58,18 +64,23 @@ def symlink_func(this: PathExtended, to_this: PathExtended, prioritize_to_this:
     except Exception as ex:
         console.print(Panel(f"❌ ERROR | Failed at linking {this} ➡️  {to_this}. Reason: {ex}", title="Error", expand=False))
 
-def symlink_copy(this: PathExtended, to_this: PathExtended, prioritize_to_this: bool=True):
+
+def symlink_copy(this: PathExtended, to_this: PathExtended, prioritize_to_this: bool = True):
     this = PathExtended(this).expanduser().absolute()
     to_this = PathExtended(to_this).expanduser().absolute()
-    if this.is_symlink(): this.delete(sure=True)  # delete if it exists as symblic link, not a concrete path.
+    if this.is_symlink():
+        this.delete(sure=True)  # delete if it exists as symblic link, not a concrete path.
     if this.exists():  # this is a problem. It will be resolved via `overwrite`
         if prioritize_to_this is True:  # it *can* be deleted, but let's look at target first.
             if to_this.exists():  # this exists, to_this as well. to_this is prioritized.
                 this.append(f".orig_{randstr()}", inplace=True)  # rename is better than deletion
-            else: this.move(path=to_this)  # this exists, to_this doesn't. to_this is prioritized.
+            else:
+                this.move(path=to_this)  # this exists, to_this doesn't. to_this is prioritized.
         elif prioritize_to_this is False:  # don't sacrefice this, sacrefice to_this.
-            if to_this.exists(): this.move(path=to_this, overwrite=True)  # this exists, to_this as well, this is prioritized.   # now we are readly to make the link
-            else: this.move(path=to_this)  # this exists, to_this doesn't, this is prioritized.
+            if to_this.exists():
+                this.move(path=to_this, overwrite=True)  # this exists, to_this as well, this is prioritized.   # now we are readly to make the link
+            else:
+                this.move(path=to_this)  # this exists, to_this doesn't, this is prioritized.
     else:  # this doesn't exist.
         if not to_this.exists():
             to_this.parent.mkdir(parents=True, exist_ok=True)