machineconfig 3.2__py3-none-any.whl → 3.3__py3-none-any.whl

machineconfig/utils/installer.py

@@ -1,7 +1,8 @@
 """package manager"""
 
-from machineconfig.utils.installer_utils.installer_abc import LINUX_INSTALL_PATH, CATEGORY
+from machineconfig.utils.installer_utils.installer_abc import LINUX_INSTALL_PATH
 from machineconfig.utils.installer_utils.installer_class import Installer
+from machineconfig.utils.schemas.installer.installer_types import APP_INSTALLER_CATEGORY, InstallerData, InstallerDataFiles
 from rich.console import Console
 from rich.panel import Panel  # Added import
 
@@ -9,7 +10,6 @@ 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
 from typing import Any
 import platform
 from joblib import Parallel, delayed
@@ -22,21 +22,25 @@ def check_latest():
     # installers += get_installers(system=platform.system(), dev=True)
     installers_github = []
     for inst__ in installers:
-        if "ntop" in inst__.name:
-            print(f"⏭️  Skipping {inst__.name} (ntop)")
+        app_name = inst__.installer_data.get("appName", "unknown")
+        repo_url = inst__.installer_data.get("repoURL", "")
+        if "ntop" in app_name:
+            print(f"⏭️  Skipping {app_name} (ntop)")
             continue
-        if "github" not in inst__.repo_url:
-            print(f"⏭️  Skipping {inst__.name} (not a GitHub release)")
+        if "github" not in repo_url:
+            print(f"⏭️  Skipping {app_name} (not a GitHub release)")
             continue
         installers_github.append(inst__)
 
     print(f"\n🔍 Checking {len(installers_github)} GitHub-based installers...\n")
 
     def func(inst: Installer):
-        print(f"🔎 Checking {inst.exe_name}...")
-        _release_url, version_to_be_installed = inst.get_github_release(repo_url=inst.repo_url, version=None)
-        verdict, current_ver, new_ver = inst.check_if_installed_already(exe_name=inst.exe_name, version=version_to_be_installed, use_cache=False)
-        return inst.exe_name, verdict, current_ver, new_ver
+        exe_name = inst.installer_data.get("exeName", "unknown")
+        repo_url = inst.installer_data.get("repoURL", "")
+        print(f"🔎 Checking {exe_name}...")
+        _release_url, version_to_be_installed = inst.get_github_release(repo_url=repo_url, version=None)
+        verdict, current_ver, new_ver = inst.check_if_installed_already(exe_name=exe_name, version=version_to_be_installed, use_cache=False)
+        return exe_name, verdict, current_ver, new_ver
 
     print("\n⏳ Processing installers...\n")
     res = [func(inst) for inst in installers_github]
@@ -90,20 +94,23 @@ def get_installed_cli_apps():
 
 def get_installers(system: str, dev: bool) -> list[Installer]:
     print(f"\n{'=' * 80}\n🔍 LOADING INSTALLER CONFIGURATIONS 🔍\n{'=' * 80}")
-    res_all = get_all_dicts(system=system)
+    res_all = get_all_installer_data_files(system=system)
     if not dev:
         print("ℹ️  Excluding development installers...")
         del res_all["CUSTOM_DEV"]
         del res_all["OS_SPECIFIC_DEV"]
         del res_all["OS_GENERIC_DEV"]
-    res_final = {}
-    for _k, v in res_all.items():
-        res_final.update(v)
-    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()]
 
+    # Flatten the installer data from all categories
+    all_installers: list[InstallerData] = []
+    for _category, installer_data_files in res_all.items():
+        all_installers.extend(installer_data_files["installers"])
 
-def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
+    print(f"✅ Loaded {len(all_installers)} installer configurations\n{'=' * 80}")
+    return [Installer(installer_data=installer_data) for installer_data in all_installers]
+
+
+def get_all_installer_data_files(system: str) -> dict[APP_INSTALLER_CATEGORY, InstallerDataFiles]:
     print(f"\n{'=' * 80}\n📂 LOADING CONFIGURATION FILES 📂\n{'=' * 80}")
 
     print(f"🔍 Importing OS-specific installers for {system}...")
@@ -122,18 +129,23 @@ def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
     path_os_generic_dev = path_os_generic.joinpath("dev")
 
     print("📂 Loading configuration files...")
-    res_final: dict[CATEGORY, dict[str, dict[str, Any]]] = {}
+    res_final: dict[APP_INSTALLER_CATEGORY, InstallerDataFiles] = {}
+
     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"))
+    os_specific_data = read_json(path=path_os_specific.joinpath("config.json"))
+    res_final["OS_SPECIFIC"] = InstallerDataFiles(os_specific_data)
 
     print(f"""📄 Loading OS-generic config from: {path_os_generic.joinpath("config.json")}""")
-    res_final["OS_GENERIC"] = read_json(path=path_os_generic.joinpath("config.json"))
+    os_generic_data = read_json(path=path_os_generic.joinpath("config.json"))
+    res_final["OS_GENERIC"] = InstallerDataFiles(os_generic_data)
 
     print(f"""📄 Loading OS-specific dev config from: {path_os_specific_dev.joinpath("config.json")}""")
-    res_final["OS_SPECIFIC_DEV"] = read_json(path=path_os_specific_dev.joinpath("config.json"))
+    os_specific_dev_data = read_json(path=path_os_specific_dev.joinpath("config.json"))
+    res_final["OS_SPECIFIC_DEV"] = InstallerDataFiles(os_specific_dev_data)
 
     print(f"""📄 Loading OS-generic dev config from: {path_os_generic_dev.joinpath("config.json")}""")
-    res_final["OS_GENERIC_DEV"] = read_json(path=path_os_generic_dev.joinpath("config.json"))
+    os_generic_dev_data = read_json(path=path_os_generic_dev.joinpath("config.json"))
+    res_final["OS_GENERIC_DEV"] = InstallerDataFiles(os_generic_dev_data)
 
     path_custom_installer = path_os_generic.with_name("python_custom_installers")
     path_custom_installer_dev = path_custom_installer.joinpath("dev")
@@ -141,29 +153,31 @@ 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]] = {}
+    res_custom_installers: list[InstallerData] = []
     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"]
-            res_custom[item.stem] = config_dict
+            installer_data: InstallerData = runpy.run_path(str(item), run_name=None)["config_dict"]
+            res_custom_installers.append(installer_data)
         except Exception as ex:
             print(f"❌ Failed to load {item}: {ex}")
 
     print(f"🔍 Loading custom dev installers from: {path_custom_installer_dev}")
-    res_custom_dev: dict[str, dict[str, Any]] = {}
+    res_custom_dev_installers: list[InstallerData] = []
     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"]
-            res_custom_dev[item.stem] = config_dict
+            installer_data: InstallerData = runpy.run_path(str(item), run_name=None)["config_dict"]
+            res_custom_dev_installers.append(installer_data)
         except Exception as ex:
             print(f"❌ Failed to load {item}: {ex}")
 
-    res_final["CUSTOM"] = res_custom
-    res_final["CUSTOM_DEV"] = res_custom_dev
+    res_final["CUSTOM"] = InstallerDataFiles({"version": "1", "installers": res_custom_installers})
+    res_final["CUSTOM_DEV"] = InstallerDataFiles({"version": "1", "installers": res_custom_dev_installers})
 
-    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']['installers'])} items\n - OS_GENERIC: {len(res_final['OS_GENERIC']['installers'])} items\n - CUSTOM: {len(res_final['CUSTOM']['installers'])} items\n{'=' * 80}"
+    )
     return res_final
 
 

machineconfig/utils/installer_utils/installer_abc.py

@@ -1,12 +1,9 @@
 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
+from typing import Optional
 import subprocess
 
 
-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:

machineconfig/utils/installer_utils/installer_class.py

@@ -2,62 +2,37 @@ 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.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
+from machineconfig.utils.utils2 import read_json
+from machineconfig.utils.schemas.installer.installer_types import InstallerData, InstallerDataFiles
 
 import platform
 import subprocess
-from typing import Any, Optional
+from typing import 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_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 __init__(self, installer_data: InstallerData):
+        self.installer_data: InstallerData = installer_data
 
     def __repr__(self) -> str:
-        return f"Installer of {self.exe_name} {self.name} @ {self.repo_url}"
+        exe_name = self.installer_data.get("exeName", "unknown")
+        app_name = self.installer_data.get("appName", "unknown")
+        repo_url = self.installer_data.get("repoURL", "unknown")
+        return f"Installer of {exe_name} {app_name} @ {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)
+        exe_name = self.installer_data.get("exeName", "")
+        if not exe_name:
+            return "Invalid installer: missing exeName"
+
+        old_version_cli: bool = check_tool_exists(tool_name=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__
-
-    @staticmethod
-    def from_dict(d: dict[str, Any], name: str):
-        try:
-            return Installer(name=name, **d)
-        except Exception as ex:
-            pprint(d, "Installer Creation Error")
-            raise ex
+        doc = self.installer_data.get("doc", "No description")
+        return f"{exe_name:<12} {old_version_cli_str} {doc}"
 
     @staticmethod
     def choose_app_and_install():
@@ -69,49 +44,69 @@ class Installer:
         config_paths = [Path(p) for p in jobs_dir.rglob("config.json")]
         path = choose_one_option(options=config_paths)
         print(f"📄 Loading configuration from: {path}")
-        config: dict[str, Any] = read_json(path)  # /python_generic_installers/config.json"))
+        config_data = read_json(path)
+        installer_data_files = InstallerDataFiles(config_data)
+
+        # Extract app names from the installers
+        app_names = [installer["appName"] for installer in installer_data_files["installers"]]
         print("🔍 Select an application to install:")
-        app_name = choose_one_option(options=list(config.keys()), fzf=True)
-        # for keys, dict_ in config.items():
-        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}")
+        app_name = choose_one_option(options=app_names, fzf=True)
+
+        # Find the selected installer data
+        selected_installer_data = None
+        for installer_data in installer_data_files["installers"]:
+            if installer_data["appName"] == app_name:
+                selected_installer_data = installer_data
+                break
+
+        if selected_installer_data is None:
+            raise ValueError(f"Could not find installer data for {app_name}")
+
+        installer = Installer(installer_data=selected_installer_data)
+        print(f"📦 Selected application: {selected_installer_data.get('exeName', 'unknown')}")
+        version = input(f"📝 Enter version to install for {selected_installer_data.get('exeName', 'unknown')} [latest]: ") or None
+        print(f"\n{'=' * 80}\n🚀 INSTALLING {selected_installer_data.get('exeName', 'UNKNOWN').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}")
-            result_old = subprocess.run(f"{self.exe_name} --version", shell=True, capture_output=True, text=True)
+            exe_name = self.installer_data.get("exeName", "unknown")
+            print(f"\n{'=' * 80}\n🚀 INSTALLING {exe_name.upper()} 🚀\n{'=' * 80}")
+            result_old = subprocess.run(f"{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)
 
-            result_new = subprocess.run(f"{self.exe_name} --version", shell=True, capture_output=True, text=True)
+            result_new = subprocess.run(f"{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:
                 print(f"ℹ️  Same version detected: {old_version_cli}")
-                return f"""📦️ 😑 {self.exe_name}, same version: {old_version_cli}"""
+                return f"""📦️ 😑 {exe_name}, same version: {old_version_cli}"""
             else:
                 print(f"🚀 Update successful: {old_version_cli} ➡️ {new_version_cli}")
-                return f"""📦️ 🤩 {self.exe_name} updated from {old_version_cli} ➡️ TO ➡️  {new_version_cli}"""
+                return f"""📦️ 🤩 {exe_name} updated from {old_version_cli} ➡️ TO ➡️  {new_version_cli}"""
 
         except Exception as ex:
-            print(f"❌ ERROR: Installation failed for {self.exe_name}: {ex}")
-            return f"""📦️ ❌ Failed to install `{self.name}` with error: {ex}"""
+            exe_name = self.installer_data.get("exeName", "unknown")
+            app_name = self.installer_data.get("appName", "unknown")
+            print(f"❌ ERROR: Installation failed for {exe_name}: {ex}")
+            return f"""📦️ ❌ Failed to install `{app_name}` with error: {ex}"""
 
     def install(self, version: Optional[str]):
-        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}")
+        exe_name = self.installer_data.get("exeName", "unknown")
+        repo_url = self.installer_data.get("repoURL", "")
+
+        print(f"\n{'=' * 80}\n🔧 INSTALLATION PROCESS: {exe_name} 🔧\n{'=' * 80}")
+        if repo_url == "CUSTOM":
+            print(f"🧩 Using custom installer for {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")
+            installer_path = Path(python_custom_installers.__file__).parent.joinpath(exe_name + ".py")
             if not installer_path.exists():
-                installer_path = Path(python_custom_installers.__file__).parent.joinpath("dev", self.exe_name + ".py")
+                installer_path = Path(python_custom_installers.__file__).parent.joinpath("dev", exe_name + ".py")
                 print(f"🔍 Looking for installer in dev folder: {installer_path}")
             else:
                 print(f"🔍 Found installer at: {installer_path}")
@@ -138,13 +133,13 @@ class Installer:
             version_to_be_installed = str(version)
             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]
+        elif "npm " in repo_url or "pip " in repo_url or "winget " in repo_url:
+            package_manager = repo_url.split(" ", maxsplit=1)[0]
             print(f"📦 Using package manager: {package_manager}")
             desc = package_manager + " installation"
             version_to_be_installed = package_manager + "Latest"
-            print(f"🚀 Running: {self.repo_url}")
-            result = subprocess.run(self.repo_url, shell=True, capture_output=True, text=True)
+            print(f"🚀 Running: {repo_url}")
+            result = subprocess.run(repo_url, shell=True, capture_output=True, text=True)
             success = result.returncode == 0 and result.stderr == ""
             if not success:
                 print(f"❌ {desc} failed")
@@ -177,38 +172,43 @@ class Installer:
             else:
                 if platform.system() == "Windows":
                     print("🪟 Installing on Windows...")
-                    exe = find_move_delete_windows(downloaded_file_path=downloaded, exe_name=self.exe_name, delete=True, rename_to=self.exe_name.replace(".exe", "") + ".exe")
+                    exe = find_move_delete_windows(downloaded_file_path=downloaded, exe_name=exe_name, delete=True, rename_to=exe_name.replace(".exe", "") + ".exe")
                 elif platform.system() in ["Linux", "Darwin"]:
                     system_name = "Linux" if platform.system() == "Linux" else "macOS"
                     print(f"🐧 Installing on {system_name}...")
-                    exe = find_move_delete_linux(downloaded=downloaded, tool_name=self.exe_name, delete=True, rename_to=self.exe_name)
+                    exe = find_move_delete_linux(downloaded=downloaded, tool_name=exe_name, delete=True, rename_to=exe_name)
                 else:
                     error_msg = f"❌ ERROR: System {platform.system()} not supported"
                     print(error_msg)
                     raise NotImplementedError(error_msg)
 
                 _ = exe
-                if exe.name.replace(".exe", "") != self.exe_name.replace(".exe", ""):
+                if exe.name.replace(".exe", "") != 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
+                    pprint(Panel(f"Expected exe name: [red]{exe_name}[/red] \nAttained name: [red]{exe.name.replace('.exe', '')}[/red]", title="exe name mismatch", subtitle=repo_url))
+                    new_exe_name = exe_name + ".exe" if platform.system() == "Windows" else exe_name
                     print(f"🔄 Renaming to correct name: {new_exe_name}")
                     exe.with_name(name=new_exe_name, inplace=True, overwrite=True)
 
-        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"💾 Saving version information to: {INSTALL_VERSION_ROOT.joinpath(exe_name)}")
+        INSTALL_VERSION_ROOT.joinpath(exe_name).parent.mkdir(parents=True, exist_ok=True)
+        INSTALL_VERSION_ROOT.joinpath(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}")
+        exe_name = self.installer_data.get("exeName", "unknown")
+        repo_url = self.installer_data.get("repoURL", "")
+        app_name = self.installer_data.get("appName", "unknown")
+        strip_v = self.installer_data.get("stripVersion", False)
+
+        print(f"\n{'=' * 80}\n📥 DOWNLOADING: {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)
+        if "github" not in repo_url or ".zip" in repo_url or ".tar.gz" in repo_url:
+            download_link = Path(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}")
@@ -228,11 +228,11 @@ class Installer:
 
         else:
             print("🌐 Retrieving release information from GitHub...")
-            release_url, version_to_be_installed = Installer.get_github_release(repo_url=self.repo_url, version=version)
+            release_url, version_to_be_installed = Installer.get_github_release(repo_url=repo_url, version=version)
             print(f"📦 Version to be installed: {version_to_be_installed}")
             print(f"📦 Release URL: {release_url}")
 
-            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.replace("v", "") if strip_v else version_to_be_installed
             version_to_be_installed_stripped = version_to_be_installed_stripped.replace("ipinfo-", "")
 
             template, arch = self._select_template()
@@ -247,7 +247,7 @@ class Installer:
 
         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}")
+        print(f"📥 Downloading {app_name} from: {download_link}")
         downloaded = PathExtended(download_link).download(folder=INSTALL_TMP_DIR).decompress()
         print(f"✅ Download and extraction completed to: {downloaded}\n{'=' * 80}")
         return downloaded, version_to_be_installed
@@ -268,47 +268,53 @@ class Installer:
         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"))
+        filename_templates = self.installer_data.get("filenameTemplate", {})
+        templates: list[str] = []
+
+        for arch_templates in filename_templates.values():
+            templates.extend([t for t in arch_templates.values() if t])
+
+        return any(t for t in templates if t.startswith("http"))
 
     def _select_template(self) -> tuple[str, str]:
         sys_name = platform.system()
         arch = self._normalized_arch()
+
+        filename_templates = self.installer_data.get("filenameTemplate", {})
+
+        # Get templates for each architecture
+        amd64_templates = filename_templates.get("amd64", {})
+        arm64_templates = filename_templates.get("arm64", {})
+
         # 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
+            if arch == "arm64" and arm64_templates.get("windows"):
+                template = arm64_templates["windows"]
             else:
-                template = self.filename_template_windows_amd_64
-            candidates = ["filename_template_windows_arm_64", "filename_template_windows_amd_64"]
+                template = amd64_templates.get("windows", "")
+            candidates = ["arm64.windows", "amd64.windows"]
         elif sys_name == "Linux":
-            if arch == "arm64" and self.filename_template_linux_arm_64:
-                template = self.filename_template_linux_arm_64
+            if arch == "arm64" and arm64_templates.get("linux"):
+                template = arm64_templates["linux"]
             else:
-                template = self.filename_template_linux_amd_64
-            candidates = ["filename_template_linux_arm_64", "filename_template_linux_amd_64"]
+                template = amd64_templates.get("linux", "")
+            candidates = ["arm64.linux", "amd64.linux"]
         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
+            if arch == "arm64" and arm64_templates.get("macos"):
+                template = arm64_templates["macos"]
+            elif arch == "amd64" and amd64_templates.get("macos"):
+                template = amd64_templates["macos"]
             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"]
+                template = arm64_templates.get("macos") or amd64_templates.get("macos") or ""
+            candidates = ["arm64.macos", "amd64.macos"]
         else:
             raise NotImplementedError(f"System {sys_name} not supported")
 
-        if template is None:
+        if not template:
             raise ValueError(f"No filename template available for system={sys_name} arch={arch}. Checked {candidates}")
 
         return template, arch

machineconfig/utils/path_reduced.py

@@ -395,7 +395,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         from machineconfig.utils.terminal import Terminal
 
         if system() == "Windows" and not Terminal.is_user_admin():  # you cannot create symlink without priviliages.
-            import win32com.shell.shell
+            import win32com.shell.shell  # type: ignore # pylint: disable=E0401
 
             _proce_info = win32com.shell.shell.ShellExecuteEx(lpVerb="runas", lpFile=sys.executable, lpParameters=f" -c \"from pathlib import Path; Path(r'{self.expanduser()}').symlink_to(r'{str(target_obj)}')\"")
             # TODO update PATH for this to take effect immediately.

machineconfig/utils/procs.py

@@ -241,6 +241,7 @@ def get_age(create_time: Any) -> str:
 
 def main():
     from machineconfig.utils.procs import ProcessManager
+
     ProcessManager().choose_and_kill()
 
 

machineconfig/utils/schemas/installer/installer_types.py

@@ -0,0 +1,20 @@
+from typing import TypedDict, Literal, TypeAlias
+
+
+APP_INSTALLER_CATEGORY: TypeAlias = Literal["OS_SPECIFIC", "OS_GENERIC", "CUSTOM", "OS_SPECIFIC_DEV", "OS_GENERIC_DEV", "CUSTOM_DEV"]
+CPU_ARCHITECTURES: TypeAlias = Literal["amd64", "arm64"]
+OPERATING_SYSTEMS: TypeAlias = Literal["windows", "linux", "macos"]
+
+
+class InstallerData(TypedDict):
+    appName: str
+    repoURL: str
+    doc: str
+    filenameTemplate: dict[CPU_ARCHITECTURES, dict[OPERATING_SYSTEMS, str]]
+    stripVersion: bool
+    exeName: str
+
+
+class InstallerDataFiles(TypedDict):
+    version: str
+    installers: list[InstallerData]

machineconfig/utils/utils2.py

@@ -44,10 +44,12 @@ def read_ini(path: "Path", encoding: Optional[str] = None):
 
 def read_json(path: "Path", r: bool = False, **kwargs: Any) -> Any:  # return could be list or dict etc
     import json
+
     try:
         mydict = json.loads(Path(path).read_text(encoding="utf-8"), **kwargs)
     except Exception:
         import pyjson5
+
         mydict = pyjson5.loads(Path(path).read_text(encoding="utf-8"), **kwargs)  # file has C-style comments.
     _ = r
     return mydict

{machineconfig-3.2.dist-info → machineconfig-3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 3.2
+Version: 3.3
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0