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

machineconfig/scripts/python/fire_jobs.py

@@ -11,17 +11,17 @@ from machineconfig.scripts.python.helpers.helpers4 import search_for_files_of_in
 from machineconfig.scripts.python.helpers.helpers4 import convert_kwargs_to_fire_kwargs_str
 from machineconfig.scripts.python.helpers.helpers4 import parse_pyfile
 from machineconfig.scripts.python.helpers.helpers4 import get_import_module_code
-from machineconfig.utils.ve import get_repo_root, get_ve_activate_line, get_ve_path_and_ipython_profile
+from machineconfig.utils.ve import get_ve_activate_line, get_ve_path_and_ipython_profile
 from machineconfig.utils.options import display_options, choose_one_option
-from machineconfig.utils.path import match_file_name, sanitize_path
+from machineconfig.utils.path_helper import match_file_name, sanitize_path
 
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
-from machineconfig.utils.io_save import save_toml
-from machineconfig.utils.utils2 import randstr, read_toml
+from machineconfig.utils.path_extended import PathExtended as PathExtended
+from machineconfig.utils.accessories import get_repo_root, randstr
 from machineconfig.scripts.python.fire_jobs_args_helper import get_args, FireJobArgs, extract_kwargs
 import platform
 from typing import Optional
 from pathlib import Path
+import tomllib
 # import os
 
 
@@ -113,7 +113,7 @@ def route(args: FireJobArgs) -> None:
                     toml_path = toml_path_maybe
             if toml_path is not None:
                 print(f"📄 Reading config.toml @ {toml_path}")
-                config = read_toml(toml_path)
+                config = tomllib.loads(toml_path.read_text(encoding="utf-8"))
                 if "server" in config:
                     if "port" in config["server"]:
                         port = config["server"]["port"]
@@ -121,7 +121,7 @@ def route(args: FireJobArgs) -> None:
                 if repo_root is not None:
                     secrets_template_path = PathExtended.home().joinpath(f"dotfiles/creds/streamlit/{PathExtended(repo_root).name}/{choice_file.name}/secrets.toml")
                     if args.environment != "" and not secrets_path.exists() and secrets_template_path.exists():
-                        secrets_template = read_toml(secrets_template_path)
+                        secrets_template = tomllib.loads(secrets_template_path.read_text(encoding="utf-8"))
                         if args.environment == "ip":
                             host_url = f"http://{local_ip_v4}:{port}/oauth2callback"
                         elif args.environment == "localhost":
@@ -134,7 +134,7 @@ def route(args: FireJobArgs) -> None:
                             secrets_template["auth"]["redirect_uri"] = host_url
                             secrets_template["auth"]["cookie_secret"] = randstr(35)
                             secrets_template["auth"]["auth0"]["redirect_uri"] = host_url
-                            save_toml(obj=secrets_template, path=secrets_path)
+                            # save_toml(obj=secrets_template, path=secrets_path)
                         except Exception as ex:
                             print(ex)
                             raise ex

machineconfig/scripts/python/fire_jobs_layout_helper.py

@@ -3,8 +3,8 @@ from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig, Layou
 from typing import Optional, TYPE_CHECKING
 from machineconfig.scripts.python.helpers.helpers4 import search_for_files_of_interest
 from machineconfig.utils.options import choose_one_option
-from machineconfig.utils.path import match_file_name, sanitize_path
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.path_helper import match_file_name, sanitize_path
+from machineconfig.utils.path_extended import PathExtended as PathExtended
 
 if TYPE_CHECKING:
     from machineconfig.scripts.python.fire_jobs_args_helper import FireJobArgs

machineconfig/scripts/python/ftpx.py

@@ -8,9 +8,9 @@ Currently, the only way to work around this is to predifine the host in ~/.ssh/c
 
 import argparse
 from machineconfig.utils.ssh import SSH
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.path_extended import PathExtended as PathExtended
 from machineconfig.scripts.python.helpers.helpers2 import ES
-from machineconfig.utils.utils2 import pprint
+from machineconfig.utils.accessories import pprint
 
 
 def main():

machineconfig/scripts/python/helpers/cloud_helpers.py

@@ -1,5 +1,6 @@
 from pathlib import Path
-from machineconfig.utils.utils2 import pprint, read_json, read_ini
+from machineconfig.utils.io import read_ini, read_json
+from machineconfig.utils.accessories import pprint
 from typing import Optional
 import os
 from machineconfig.utils.source_of_truth import DEFAULTS_PATH

machineconfig/scripts/python/helpers/helpers2.py

@@ -1,6 +1,7 @@
 from machineconfig.scripts.python.helpers.cloud_helpers import Args, ArgsDefaults, absolute, find_cloud_config, get_secure_share_cloud_config
+from machineconfig.utils.io import read_ini
 from machineconfig.utils.source_of_truth import DEFAULTS_PATH
-from machineconfig.utils.utils2 import read_ini, pprint
+from machineconfig.utils.accessories import pprint
 from typing import Optional
 from rich.console import Console
 from rich.panel import Panel
@@ -103,7 +104,7 @@ def parse_cloud_source_target(args: Args, source: str, target: str) -> tuple[str
         if len(source_parts) > 1 and source_parts[1] == ES:  # the source path is to be inferred from target.
             assert ES not in target, f"You can't use expand symbol `{ES}` in both source and target. Cyclical inference dependency arised."
             target_obj = absolute(target)
-            from machineconfig.utils.path_reduced import PathExtended as PathExtended
+            from machineconfig.utils.path_extended import PathExtended as PathExtended
 
             remote_path = PathExtended(target_obj).get_remote_path(os_specific=os_specific, root=root, rel2home=rel2home, strict=False)
             source = f"{cloud}:{remote_path.as_posix()}"
@@ -123,7 +124,7 @@ def parse_cloud_source_target(args: Args, source: str, target: str) -> tuple[str
         if len(target_parts) > 1 and target_parts[1] == ES:  # the target path is to be inferred from source.
             assert ES not in source, "You can't use $ in both source and target. Cyclical inference dependency arised."
             source_obj = absolute(source)
-            from machineconfig.utils.path_reduced import PathExtended as PathExtended
+            from machineconfig.utils.path_extended import PathExtended as PathExtended
 
             remote_path = PathExtended(source_obj).get_remote_path(os_specific=os_specific, root=root, rel2home=rel2home, strict=False)
             target = f"{cloud}:{remote_path.as_posix()}"

machineconfig/scripts/python/helpers/helpers4.py

@@ -3,7 +3,7 @@ import inspect
 import os
 
 # import argparse
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.path_extended import PathExtended as PathExtended
 # from machineconfig.utils.utils import choose_ssh_host
 
 

machineconfig/scripts/python/helpers/repo_sync_helpers.py

@@ -1,8 +1,8 @@
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.path_extended import PathExtended as PathExtended
 from machineconfig.utils.terminal import Terminal
 from machineconfig.scripts.python.get_zellij_cmd import get_zellij_cmd
 from machineconfig.utils.source_of_truth import CONFIG_PATH, DEFAULTS_PATH
-from machineconfig.utils.utils2 import read_ini
+from machineconfig.utils.io import read_ini
 from machineconfig.utils.code import write_shell_script_to_file
 import platform
 from rich.console import Console

machineconfig/scripts/python/mount_nfs.py

@@ -1,6 +1,6 @@
 """NFS mounting script"""
 
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.path_extended import PathExtended as PathExtended
 from machineconfig.utils.ssh import SSH
 from machineconfig.utils.terminal import Terminal
 from machineconfig.utils.options import display_options, choose_ssh_host

machineconfig/scripts/python/mount_ssh.py

@@ -3,7 +3,7 @@
 from platform import system
 from machineconfig.utils.ssh import SSH
 from machineconfig.utils.terminal import Terminal
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.path_extended import PathExtended as PathExtended
 
 from machineconfig.utils.options import choose_ssh_host
 

machineconfig/scripts/python/repos.py

@@ -5,11 +5,13 @@ in the event that username@github.com is not mentioned in the remote url.
 
 """
 
+from machineconfig.utils.io import read_ini
 from machineconfig.utils.source_of_truth import CONFIG_PATH, DEFAULTS_PATH
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
-from machineconfig.utils.utils2 import randstr, read_ini
+from machineconfig.utils.path_extended import PathExtended as PathExtended
+from machineconfig.utils.accessories import randstr
 from machineconfig.scripts.python.repos_helper_update import update_repository
 from machineconfig.scripts.python.repos_helper_record import main as record_repos
+from machineconfig.scripts.python.repos_helper_clone import clone_repos
 
 import argparse
 from enum import Enum
@@ -119,7 +121,7 @@ def main():
     elif args.clone or args.checkout or args.checkout_to_branch:
         print("\n📥 Cloning or checking out repositories...")
         print(">>>>>>>>> Cloning Repos")
-        if not repos_root.exists() or repos_root.name != "repos.json":  # Fixed: use name instead of stem
+        if not repos_root.exists() or repos_root.name != "repos.json":
             repos_root = PathExtended(CONFIG_PATH).joinpath("repos").joinpath(repos_root.rel2home()).joinpath("repos.json")
             if not repos_root.exists():
                 if args.cloud is None:
@@ -130,6 +132,7 @@ def main():
                     assert cloud is not None, f"Path {repos_root} does not exist and cloud was not passed. You can't clone without one of them."
                 repos_root.from_cloud(cloud=cloud, rel2home=True)
         assert (repos_root.exists() and repos_root.name == "repos.json") or args.cloud is not None, f"Path {repos_root} does not exist and cloud was not passed. You can't clone without one of them."
+        clone_repos(spec_path=repos_root, preferred_remote=None, checkout_branch_flag=args.checkout_to_branch, checkout_commit_flag=args.checkout)
 
     elif args.all or args.commit or args.pull or args.push:
         print(f"\n🔄 Performing Git actions on repositories @ `{repos_root}`...")

machineconfig/scripts/python/repos_helper_clone.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from typing import Literal, Optional, cast
+
+from git import Repo as GitRepo
+from git.exc import GitCommandError
+from rich import print as pprint
+from rich.progress import BarColumn, MofNCompleteColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+
+from machineconfig.utils.path_extended import PathExtended as PathExtended
+from machineconfig.utils.schemas.repos.repos_types import RepoRecordDict, RepoRecordFile, RepoRemote
+from machineconfig.utils.io import read_json
+
+
+CloneStatus = Literal["cloned", "skipped", "failed"]
+
+
+def choose_remote(remotes: list[RepoRemote], preferred_remote: Optional[str]) -> Optional[RepoRemote]:
+    if preferred_remote is not None:
+        for remote in remotes:
+            if remote["name"] == preferred_remote:
+                return remote
+    for remote in remotes:
+        if remote["name"] == "origin":
+            return remote
+    return remotes[0] if len(remotes) > 0 else None
+
+
+def ensure_destination(parent_dir: str, name: str) -> PathExtended:
+    parent_path = PathExtended(parent_dir).expanduser().absolute()
+    parent_path.mkdir(parents=True, exist_ok=True)
+    return parent_path.joinpath(name)
+
+
+def checkout_branch(repo: GitRepo, branch: str) -> bool:
+    if branch == "DETACHED":
+        return False
+    current_branch = repo.active_branch.name if not repo.head.is_detached else None
+    if current_branch == branch:
+        return False
+    repo.git.checkout(branch)
+    return True
+
+
+def checkout_commit(repo: GitRepo, commit: str) -> bool:
+    if commit in {"", "UNKNOWN"}:
+        return False
+    current_commit = repo.head.commit.hexsha
+    if current_commit == commit:
+        return False
+    repo.git.checkout(commit)
+    return True
+
+
+def clone_single_repo(repo_spec: RepoRecordDict, preferred_remote: Optional[str], checkout_branch_flag: bool, checkout_commit_flag: bool) -> tuple[CloneStatus, str]:
+    destination = ensure_destination(parent_dir=repo_spec["parentDir"], name=repo_spec["name"])
+    repo_path = destination.joinpath(".git")
+    remotes = repo_spec["remotes"]
+    if len(remotes) == 0:
+        return ("failed", f"No remotes configured for {destination}")
+    remote = choose_remote(remotes=remotes, preferred_remote=preferred_remote)
+    if remote is None:
+        return ("failed", f"No usable remote for {destination}")
+    repo = None
+    status: CloneStatus
+    message: str
+    if destination.exists() and repo_path.exists():
+        status = "skipped"
+        repo = GitRepo(str(destination))
+        message = f"Skipped cloning for {destination}; existing repository reused"
+    elif destination.exists() and not repo_path.exists():
+        return ("failed", f"Destination exists but is not a git repository: {destination}")
+    else:
+        try:
+            pprint(f"📥 Cloning {repo_spec['name']} from {remote['url']}")
+            repo = GitRepo.clone_from(url=remote["url"], to_path=str(destination))
+            status = "cloned"
+            message = f"Cloned {destination}"
+        except Exception as err:  # noqa: BLE001
+            return ("failed", f"Clone failed for {destination}: {err}")
+    assert repo is not None
+    checkout_summary: list[str] = []
+    try:
+        if checkout_branch_flag:
+            if checkout_branch(repo=repo, branch=repo_spec["version"]["branch"]):
+                checkout_summary.append(f"branch {repo_spec['version']['branch']}")
+        if checkout_commit_flag:
+            if checkout_commit(repo=repo, commit=repo_spec["version"]["commit"]):
+                checkout_summary.append(f"commit {repo_spec['version']['commit'][:8]}")
+    except GitCommandError as err:
+        return ("failed", f"Checkout failed for {destination}: {err}")
+    if len(checkout_summary) > 0:
+        message = f"{message} | Checked out {' & '.join(checkout_summary)}"
+    return (status, message)
+
+
+def clone_repos(spec_path: PathExtended, preferred_remote: Optional[str], checkout_branch_flag: bool, checkout_commit_flag: bool) -> list[tuple[CloneStatus, str]]:
+    data = cast(RepoRecordFile, read_json(path=spec_path))
+    repos = data["repos"]
+    results: list[tuple[CloneStatus, str]] = []
+    with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), BarColumn(), MofNCompleteColumn(), TimeElapsedColumn()) as progress:
+        task_id = progress.add_task("Processing repositories...", total=len(repos))
+        for repo_spec in repos:
+            progress.update(task_id, description=f"Processing {repo_spec['name']}")
+            try:
+                result = clone_single_repo(repo_spec=repo_spec, preferred_remote=preferred_remote, checkout_branch_flag=checkout_branch_flag, checkout_commit_flag=checkout_commit_flag)
+            except Exception as err:  # noqa: BLE001
+                result = ("failed", f"Unexpected error for {repo_spec['name']}: {err}")
+            results.append(result)
+            if result[0] == "failed":
+                pprint(f"❌ {result[1]}")
+            elif result[0] == "cloned":
+                pprint(f"✅ {result[1]}")
+            else:
+                pprint(f"⏭️ {result[1]}")
+            progress.update(task_id, advance=1)
+    success_count = len([status for status, _ in results if status == "cloned"])
+    skip_count = len([status for status, _ in results if status == "skipped"])
+    fail_count = len([status for status, _ in results if status == "failed"])
+    pprint(f"✅ Cloned: {success_count} | ⏭️ Skipped: {skip_count} | ❌ Failed: {fail_count}")
+    return results

machineconfig/scripts/python/repos_helper_record.py

@@ -1,9 +1,9 @@
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.path_extended import PathExtended as PathExtended
 from machineconfig.utils.schemas.repos.repos_types import GitVersionInfo, RepoRecordDict, RepoRemote
 
 from machineconfig.utils.schemas.repos.repos_types import RepoRecordFile
 from machineconfig.utils.source_of_truth import CONFIG_PATH
-from machineconfig.utils.io_save import save_json
+from machineconfig.utils.io import save_json
 
 from typing import Optional
 

machineconfig/scripts/python/start_slidev.py

@@ -4,7 +4,7 @@ slidev
 
 from machineconfig.utils.source_of_truth import CONFIG_PATH
 from machineconfig.utils.code import print_code
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.path_extended import PathExtended as PathExtended
 from machineconfig.utils.terminal import Terminal
 import subprocess
 import platform

machineconfig/scripts/python/wsl_windows_transfer.py

@@ -1,6 +1,6 @@
 """TWSL"""
 
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.path_extended import PathExtended as PathExtended
 import argparse
 import platform
 import getpass

machineconfig/setup_windows/wt_and_pwsh/install_nerd_fonts.py

@@ -4,20 +4,21 @@ https://glitchbone.github.io/vscode-base16-term/#/3024
 
 """
 
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.path_extended import PathExtended as PathExtended
 from machineconfig.utils.source_of_truth import LIBRARY_ROOT
 from machineconfig.utils.installer_utils.installer_class import Installer
 import subprocess
 from typing import Iterable
+from machineconfig.utils.schemas.installer.installer_types import InstallerData
 
 
-nerd_fonts = {
-    "repo_url": "https://github.com/ryanoasis/nerd-fonts",
+nerd_fonts: InstallerData = {
+    "appName": "Cascadia Code Nerd Font",
+    "repoURL": "https://github.com/ryanoasis/nerd-fonts",
     "doc": "Nerd Fonts is a project that patches developer targeted fonts with a high number of glyphs (icons)",
-    "filename_template_windows_amd_64": "CascadiaCode.zip",
-    "filename_template_linux_amd_64": "CascadiaCode.zip",
-    "strip_v": False,
-    "exe_name": "nerd_fonts",
+    "filenameTemplate": {"amd64": {"windows": "CascadiaCode.zip", "linux": "CascadiaCode.zip", "macos": ""}, "arm64": {"windows": "", "linux": "", "macos": ""}},
+    "stripVersion": False,
+    "exeName": "nerd_fonts",
 }
 
 
@@ -64,7 +65,7 @@ def install_nerd_fonts() -> None:
         return
     print(f"🔍 Missing fonts detected: {', '.join(missing)}. Proceeding with installation...")
     print("🔍 Downloading Nerd Fonts package...")
-    folder, _version_to_be_installed = Installer.from_dict(d=nerd_fonts, name="nerd_fonts").download(version=None)
+    folder, _version_to_be_installed = Installer(installer_data=nerd_fonts).download(version=None)
 
     print("🧹 Cleaning up unnecessary files...")
     [p.delete(sure=True) for p in folder.search("*Windows*")]

machineconfig/setup_windows/wt_and_pwsh/set_wt_settings.py

@@ -1,8 +1,8 @@
 """Set Windows Terminal Settings"""
 
-from machineconfig.utils.utils2 import randstr, read_json
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
-from machineconfig.utils.io_save import save_json
+from machineconfig.utils.accessories import randstr
+from machineconfig.utils.path_extended import PathExtended as PathExtended
+from machineconfig.utils.io import read_json, save_json
 import platform
 
 # from uuid import uuid4

machineconfig/utils/{utils2.py → accessories.py}

@@ -32,33 +32,6 @@ def split[T](iterable: list[T], every: int = 1, to: Optional[int] = None) -> lis
     return list(res)
 
 
-def read_ini(path: "Path", encoding: Optional[str] = None):
-    if not Path(path).exists() or Path(path).is_dir():
-        raise FileNotFoundError(f"File not found or is a directory: {path}")
-    import configparser
-
-    res = configparser.ConfigParser()
-    res.read(filenames=[str(path)], encoding=encoding)
-    return res
-
-
-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
-
-
-def read_toml(path: "Path"):
-    import tomli
-
-    return tomli.loads(path.read_text(encoding="utf-8"))
-
-
 def pprint(obj: dict[Any, Any], title: str) -> None:
     from rich import inspect
 
@@ -84,3 +57,16 @@ def human_friendly_dict(d: dict[str, Any]) -> dict[str, Any]:
         else:
             result[k] = v
     return result
+
+
+def get_repo_root(path: Path) -> Optional[Path]:
+    from git import Repo, InvalidGitRepositoryError
+
+    try:
+        repo = Repo(str(path), search_parent_directories=True)
+        root = repo.working_tree_dir
+        if root is not None:
+            return Path(root)
+    except InvalidGitRepositoryError:
+        pass
+    return None

machineconfig/utils/code.py

@@ -5,9 +5,9 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.syntax import Syntax
 
-from machineconfig.utils.utils2 import randstr
+from machineconfig.utils.accessories import randstr
 from machineconfig.utils.ve import get_ve_activate_line
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.path_extended import PathExtended as PathExtended
 
 
 def get_shell_script_executing_python_file(python_file: str, func: Optional[str], ve_path: str, strict_execution: bool = True):

machineconfig/utils/installer.py

@@ -1,15 +1,15 @@
 """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
 
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.path_extended import PathExtended as PathExtended
 from machineconfig.utils.source_of_truth import INSTALL_VERSION_ROOT
-from machineconfig.utils.utils2 import read_json
+from machineconfig.utils.io 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.path_extended 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: