machineconfig 2.0__py3-none-any.whl → 2.2__py3-none-any.whl

machineconfig/utils/installer.py

@@ -1,12 +1,12 @@
-"""package manager
-"""
+"""package manager"""
+
 from machineconfig.utils.installer_utils.installer_abc import LINUX_INSTALL_PATH, CATEGORY
 from machineconfig.utils.installer_utils.installer_class import Installer
 from rich.console import Console
-from rich.panel import Panel # Added import
+from rich.panel import Panel  # Added import
 
-from machineconfig.utils.path_reduced import P as PathExtended
-from machineconfig.utils.utils import INSTALL_VERSION_ROOT
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.source_of_truth import INSTALL_VERSION_ROOT
 from machineconfig.utils.utils2 import read_json
 
 # from dataclasses import dataclass
@@ -16,8 +16,8 @@ from joblib import Parallel, delayed
 
 
 def check_latest():
-    console = Console() # Added console initialization
-    console.print(Panel("🔍  CHECKING FOR LATEST VERSIONS", title="Status", expand=False)) # Replaced print with Panel
+    console = Console()  # Added console initialization
+    console.print(Panel("🔍  CHECKING FOR LATEST VERSIONS", title="Status", expand=False))  # Replaced print with Panel
     installers = get_installers(system=platform.system(), dev=False)
     # installers += get_installers(system=platform.system(), dev=True)
     installers_github = []
@@ -46,12 +46,7 @@ def check_latest():
     # Convert to list of dictionaries and group by status
     result_data = []
     for tool, status, current_ver, new_ver in res:
-        result_data.append({
-            "Tool": tool,
-            "Status": status,
-            "Current Version": current_ver,
-            "New Version": new_ver
-        })
+        result_data.append({"Tool": tool, "Status": status, "Current Version": current_ver, "New Version": new_ver})
 
     # Group by status
     grouped_data: dict[str, list[dict[str, Any]]] = {}
@@ -70,11 +65,11 @@ def check_latest():
         for item in items:
             print(f"  {item['Tool']:<20} | Current: {item['Current Version']:<15} | New: {item['New Version']}")
     print("-" * 60)
-    print(f"{'═'*80}")
+    print(f"{'═' * 80}")
 
 
 def get_installed_cli_apps():
-    print(f"\n{'='*80}\n🔍 LISTING INSTALLED CLI APPS 🔍\n{'='*80}")
+    print(f"\n{'=' * 80}\n🔍 LISTING INSTALLED CLI APPS 🔍\n{'=' * 80}")
     if platform.system() == "Windows":
         print("🪟 Searching for Windows executables...")
         apps = PathExtended.home().joinpath("AppData/Local/Microsoft/WindowsApps").search("*.exe", not_in=["notepad"])
@@ -89,12 +84,12 @@ def get_installed_cli_apps():
         print(error_msg)
         raise NotImplementedError(error_msg)
     apps = [app for app in apps if app.size("kb") > 0.1 and not app.is_symlink()]  # no symlinks like paint and wsl and bash
-    print(f"✅ Found {len(apps)} installed applications\n{'='*80}")
+    print(f"✅ Found {len(apps)} installed applications\n{'=' * 80}")
     return apps
 
 
 def get_installers(system: str, dev: bool) -> list[Installer]:
-    print(f"\n{'='*80}\n🔍 LOADING INSTALLER CONFIGURATIONS 🔍\n{'='*80}")
+    print(f"\n{'=' * 80}\n🔍 LOADING INSTALLER CONFIGURATIONS 🔍\n{'=' * 80}")
     res_all = get_all_dicts(system=system)
     if not dev:
         print("ℹ️  Excluding development installers...")
@@ -104,12 +99,12 @@ def get_installers(system: str, dev: bool) -> list[Installer]:
     res_final = {}
     for _k, v in res_all.items():
         res_final.update(v)
-    print(f"✅ Loaded {len(res_final)} installer configurations\n{'='*80}")
+    print(f"✅ Loaded {len(res_final)} installer configurations\n{'=' * 80}")
     return [Installer.from_dict(d=vd, name=k) for k, vd in res_final.items()]
 
 
 def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
-    print(f"\n{'='*80}\n📂 LOADING CONFIGURATION FILES 📂\n{'='*80}")
+    print(f"\n{'=' * 80}\n📂 LOADING CONFIGURATION FILES 📂\n{'=' * 80}")
 
     print(f"🔍 Importing OS-specific installers for {system}...")
     if system == "Windows":
@@ -119,6 +114,7 @@ def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
 
     print("🔍 Importing generic installers...")
     import machineconfig.jobs.python_generic_installers as generic_installer
+
     path_os_specific = PathExtended(os_specific_installer.__file__).parent
     path_os_generic = PathExtended(generic_installer.__file__).parent
 
@@ -127,7 +123,7 @@ def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
 
     print("📂 Loading configuration files...")
     res_final: dict[CATEGORY, dict[str, dict[str, Any]]] = {}
-    print(f"""📄 Loading OS-specific config from: {path_os_specific.joinpath('config.json')}""")
+    print(f"""📄 Loading OS-specific config from: {path_os_specific.joinpath("config.json")}""")
     res_final["OS_SPECIFIC"] = read_json(path=path_os_specific.joinpath("config.json"))
 
     print(f"""📄 Loading OS-generic config from: {path_os_generic.joinpath("config.json")}""")
@@ -144,11 +140,12 @@ def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
 
     print(f"🔍 Loading custom installers from: {path_custom_installer}")
     import runpy
+
     res_custom: dict[str, dict[str, Any]] = {}
     for item in path_custom_installer.search("*.py", r=False, not_in=["__init__"]):
         try:
             print(f"📄 Loading custom installer: {item.name}")
-            config_dict = runpy.run_path(str(item), run_name=None)['config_dict']
+            config_dict = runpy.run_path(str(item), run_name=None)["config_dict"]
             res_custom[item.stem] = config_dict
         except Exception as ex:
             print(f"❌ Failed to load {item}: {ex}")
@@ -158,7 +155,7 @@ def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
     for item in path_custom_installer_dev.search("*.py", r=False, not_in=["__init__"]):
         try:
             print(f"📄 Loading custom dev installer: {item.name}")
-            config_dict = runpy.run_path(str(item), run_name=None)['config_dict']
+            config_dict = runpy.run_path(str(item), run_name=None)["config_dict"]
             res_custom_dev[item.stem] = config_dict
         except Exception as ex:
             print(f"❌ Failed to load {item}: {ex}")
@@ -166,15 +163,15 @@ def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
     res_final["CUSTOM"] = res_custom
     res_final["CUSTOM_DEV"] = res_custom_dev
 
-    print(f"✅ Configuration loading complete:\n - OS_SPECIFIC: {len(res_final['OS_SPECIFIC'])} items\n - OS_GENERIC: {len(res_final['OS_GENERIC'])} items\n - CUSTOM: {len(res_final['CUSTOM'])} items\n{'='*80}")
+    print(f"✅ Configuration loading complete:\n - OS_SPECIFIC: {len(res_final['OS_SPECIFIC'])} items\n - OS_GENERIC: {len(res_final['OS_GENERIC'])} items\n - CUSTOM: {len(res_final['CUSTOM'])} items\n{'=' * 80}")
     return res_final
 
 
-def install_all(installers: list[Installer], safe: bool=False, jobs: int = 10, fresh: bool=False):
-    print(f"\n{'='*80}\n🚀 BULK INSTALLATION PROCESS 🚀\n{'='*80}")
+def install_all(installers: list[Installer], safe: bool = False, jobs: int = 10, fresh: bool = False):
+    print(f"\n{'=' * 80}\n🚀 BULK INSTALLATION PROCESS 🚀\n{'=' * 80}")
     if fresh:
         print("🧹 Fresh install requested - clearing version cache...")
-        INSTALL_VERSION_ROOT.delete(sure=True)
+        PathExtended(INSTALL_VERSION_ROOT).delete(sure=True)
         print("✅ Version cache cleared")
 
     if safe:
@@ -204,16 +201,13 @@ def install_all(installers: list[Installer], safe: bool=False, jobs: int = 10, f
         # return None
 
     print(f"🚀 Starting installation of {len(installers)} packages...")
-    print(f"\n{'='*80}\n📦 INSTALLING FIRST PACKAGE 📦\n{'='*80}")
+    print(f"\n{'=' * 80}\n📦 INSTALLING FIRST PACKAGE 📦\n{'=' * 80}")
     installers[0].install(version=None)
     installers_remaining = installers[1:]
-    print(f"\n{'='*80}\n📦 INSTALLING REMAINING PACKAGES 📦\n{'='*80}")
+    print(f"\n{'=' * 80}\n📦 INSTALLING REMAINING PACKAGES 📦\n{'=' * 80}")
 
     # Use joblib for parallel processing of remaining installers
-    res = Parallel(n_jobs=jobs)(
-        delayed(lambda x: x.install_robust(version=None))(installer)
-        for installer in installers_remaining
-    )
+    res = Parallel(n_jobs=jobs)(delayed(lambda x: x.install_robust(version=None))(installer) for installer in installers_remaining)
 
     console = Console()
 
@@ -222,19 +216,19 @@ def install_all(installers: list[Installer], safe: bool=False, jobs: int = 10, f
 
     print("\n")
     console.rule("✓ Same Version Apps")
-    same_version_results = [r for r in res if r and 'same version' in str(r)]
+    same_version_results = [r for r in res if r and "same version" in str(r)]
     for result in same_version_results:
         print(f"  {result}")
 
     print("\n")
     console.rule("⬆️ Updated Apps")
-    updated_results = [r for r in res if r and 'updated from' in str(r)]
+    updated_results = [r for r in res if r and "updated from" in str(r)]
     for result in updated_results:
         print(f"  {result}")
 
     print("\n")
     console.rule("❌ Failed Apps")
-    failed_results = [r for r in res if r and 'Failed at' in str(r)]
+    failed_results = [r for r in res if r and "Failed at" in str(r)]
     for result in failed_results:
         print(f"  {result}")
 

machineconfig/utils/installer_utils/installer_abc.py

@@ -1,17 +1,17 @@
-from machineconfig.utils.path_reduced import P as PathExtended
+
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.source_of_truth import WINDOWS_INSTALL_PATH, LINUX_INSTALL_PATH
 from typing import Optional, TypeAlias, Literal
 import subprocess
 
-# LINUX_INSTALL_PATH = '/usr/local/bin'
-# LINUX_INSTALL_PATH = '~/.local/bin'
-LINUX_INSTALL_PATH = PathExtended.home().joinpath(".local/bin").__str__()
-WINDOWS_INSTALL_PATH = PathExtended.home().joinpath("AppData/Local/Microsoft/WindowsApps").__str__()
+
 CATEGORY: TypeAlias = Literal["OS_SPECIFIC", "OS_GENERIC", "CUSTOM", "OS_SPECIFIC_DEV", "OS_GENERIC_DEV", "CUSTOM_DEV"]
 
 
-def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optional[str] = None, delete: bool=True, rename_to: Optional[str] = None):
-    print(f"\n{'='*80}\n🔍 PROCESSING WINDOWS EXECUTABLE 🔍\n{'='*80}")
-    if exe_name is not None and ".exe" in exe_name: exe_name = exe_name.replace(".exe", "")
+def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optional[str] = None, delete: bool = True, rename_to: Optional[str] = None):
+    print(f"\n{'=' * 80}\n🔍 PROCESSING WINDOWS EXECUTABLE 🔍\n{'=' * 80}")
+    if exe_name is not None and ".exe" in exe_name:
+        exe_name = exe_name.replace(".exe", "")
     if downloaded_file_path.is_file():
         exe = downloaded_file_path
         print(f"📄 Found direct executable file: {exe}")
@@ -49,12 +49,12 @@ def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optio
         downloaded_file_path.delete(sure=True)
         print("✅ Temporary files removed")
 
-    print(f"{'='*80}")
+    print(f"{'=' * 80}")
     return exe_new_location
 
 
 def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Optional[bool] = True, rename_to: Optional[str] = None):
-    print(f"\n{'='*80}\n🔍 PROCESSING LINUX EXECUTABLE 🔍\n{'='*80}")
+    print(f"\n{'=' * 80}\n🔍 PROCESSING LINUX EXECUTABLE 🔍\n{'=' * 80}")
     if downloaded.is_file():
         exe = downloaded
         print(f"📄 Found direct executable file: {exe}")
@@ -108,5 +108,5 @@ def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Opt
         print("✅ Temporary files removed")
 
     exe_new_location = PathExtended(LINUX_INSTALL_PATH).joinpath(exe.name)
-    print(f"✅ Executable installed at: {exe_new_location}\n{'='*80}")
+    print(f"✅ Executable installed at: {exe_new_location}\n{'=' * 80}")
     return exe_new_location

machineconfig/utils/installer_utils/installer_class.py

@@ -1,7 +1,7 @@
-
-from machineconfig.utils.path_reduced import P as PathExtended
+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.source_of_truth import INSTALL_TMP_DIR, INSTALL_VERSION_ROOT, LIBRARY_ROOT
+from machineconfig.utils.options import check_tool_exists
 from machineconfig.utils.utils2 import pprint, read_json
 
 import platform
@@ -11,45 +11,59 @@ 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}")
-        from machineconfig.utils.utils import choose_one_option
+        print(f"\n{'=' * 80}\n🔍 SELECT APPLICATION TO INSTALL 🔍\n{'=' * 80}")
+        from machineconfig.utils.options 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,12 +76,12 @@ 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}")
+            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'}")
@@ -90,10 +104,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")
@@ -102,13 +117,17 @@ 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...")
-            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() == "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")
+            script_file.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}"
@@ -117,7 +136,7 @@ class Installer:
                 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]
@@ -134,7 +153,7 @@ class Installer:
                 if result.stderr:
                     print(f"STDERR: {result.stderr}")
                 print(f"Return code: {result.returncode}")
-            print(f"✅ Package manager installation completed\n{'='*80}")
+            print(f"✅ Package manager installation completed\n{'=' * 80}")
 
         else:
             print("📥 Downloading from repository...")
@@ -154,7 +173,7 @@ class Installer:
                     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...")
@@ -172,6 +191,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
@@ -181,30 +201,30 @@ 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, encoding="utf-8")
-        print(f"✅ Installation completed successfully!\n{'='*80}")
+        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...")
@@ -215,36 +235,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)
@@ -253,12 +334,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)
@@ -274,7 +355,7 @@ class Installer:
         else:
             print("🔍 Checking installed version directly...")
             result = subprocess.run([exe_name, "--version"], check=False, capture_output=True, text=True)
-            if result.stdout.strip() == '':
+            if result.stdout.strip() == "":
                 existing_version = None
                 print("ℹ️  Could not detect installed version")
             else:
@@ -285,7 +366,7 @@ class Installer:
             if existing_version == version_to_be_installed:
                 print(f"✅ {exe_name} is up to date (version {version_to_be_installed})")
                 print(f"📂 Version information stored at: {INSTALL_VERSION_ROOT}")
-                return ("✅ Uptodate", version.strip(), version_to_be_installed.strip())
+                return ("✅ Up to date", 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, encoding="utf-8")
@@ -294,5 +375,5 @@ class Installer:
             print(f"📦 {exe_name} is not installed. Will install version: {version_to_be_installed}")
             tmp_path.write_text(version_to_be_installed, encoding="utf-8")
 
-        print(f"{'='*80}")
+        print(f"{'=' * 80}")
         return ("⚠️ NotInstalled", "None", version_to_be_installed.strip())