machineconfig 1.94__py3-none-any.whl → 1.96__py3-none-any.whl

machineconfig/utils/{utils_code.py → code.py}

@@ -3,12 +3,12 @@ import platform
 from rich.console import Console
 from rich.panel import Panel
 from rich.syntax import Syntax
-from crocodile.core import randstr
-from crocodile.file_management import P
+from machineconfig.utils.utils2 import randstr
+from machineconfig.utils.path_reduced import P as PathExtended
 from crocodile.meta import Terminal
 
 
-PROGRAM_PATH = (P.home().joinpath("tmp_results", "shells", "python_return_command") + (".ps1" if platform.system() == "Windows" else ".sh"))
+PROGRAM_PATH = (PathExtended.home().joinpath("tmp_results", "shells", "python_return_command") + (".ps1" if platform.system() == "Windows" else ".sh"))
 
 
 def get_shell_script_executing_python_file(python_file: str, func: Optional[str] = None, ve_name: str="ve", strict_execution: bool=True):
@@ -23,17 +23,19 @@ deactivate || true
 
     if strict_execution:
         if platform.system() == "Windows": shell_script = """$ErrorActionPreference = "Stop" """ + "\n" + shell_script
-        if platform.system() == "Linux": shell_script = "set -e" + "\n" + shell_script
+        if platform.system() in ["Linux", "Darwin"]: shell_script = "set -e" + "\n" + shell_script
 
-    if platform.system() == "Linux": shell_script = "#!/bin/bash" + "\n" + shell_script  # vs #!/usr/bin/env bash
+    if platform.system() in ["Linux", "Darwin"]: shell_script = "#!/bin/bash" + "\n" + shell_script  # vs #!/usr/bin/env bash
     return shell_script
 
 
 def write_shell_script_to_file(shell_script: str):
-    if platform.system() == "Linux": suffix = ".sh"
+    if platform.system() in ["Linux", "Darwin"]: suffix = ".sh"
     elif platform.system() == "Windows": suffix = ".ps1"
     else: raise NotImplementedError(f"Platform {platform.system()} not implemented.")
-    shell_file = P.tmp().joinpath("tmp_scripts", "shell", randstr() + suffix).create(parents_only=True).write_text(shell_script)
+    shell_file = PathExtended.tmp().joinpath("tmp_scripts", "shell", randstr() + suffix)
+    shell_file.parent.mkdir(parents=True, exist_ok=True)
+    shell_file.write_text(shell_script)
     return shell_file
 
 # Enhanced print/log/error/exception statements for better clarity and consistency
@@ -46,14 +48,9 @@ def write_shell_script_to_default_program_path(program: str, desc: str, preserve
             program = "$orig_path = $pwd\n" + program + "\ncd $orig_path"
         else:
             program = 'orig_path=$(cd -- "." && pwd)\n' + program + '\ncd "$orig_path" || exit'
-    if display:
-        print(f"""
-{'=' * 60}
-⚙️  SHELL SCRIPT | Executing at {PROGRAM_PATH}
-{'=' * 60}
-""")
-        print_code(code=program, lexer="shell", desc=desc)
-    PROGRAM_PATH.create(parents_only=True).write_text(program)
+    if display: print_code(code=program, lexer="shell", desc=desc, subtitle=str(PROGRAM_PATH))
+    PROGRAM_PATH.parent.mkdir(parents=True, exist_ok=True)
+    PROGRAM_PATH.write_text(program)
     if execute:
         Terminal().run(f". {PROGRAM_PATH}", shell="powershell").capture().print_if_unsuccessful(desc="🛠️  EXECUTION | Shell script running", strict_err=True, strict_returncode=True)
     return None
@@ -61,22 +58,28 @@ def write_shell_script_to_default_program_path(program: str, desc: str, preserve
 def get_shell_file_executing_python_script(python_script: str, ve_name: str, verbose: bool=True):
     if verbose:
         python_script = f"""
-code = r'''{python_script}'''
+code = r'''{python_script}''' """ + """
 try:
     from machineconfig.utils.utils import print_code
     print_code(code=code, lexer="python", desc="Python Script")
-except ImportError: print(f"\\n{'=' * 60}\\n📜 PYTHON SCRIPT:\\n\\n{{code}}\\n{'=' * 60}\\n")
+except ImportError:
+    from rich.console import Console
+    from rich.panel import Panel
+    console = Console()
+    console.print(Panel(f'''📜 PYTHON SCRIPT:\n\n{{code}}''', title="Python Script", expand=False))
 """ + python_script
-    python_file = P.tmp().joinpath("tmp_scripts", "python", randstr() + ".py").create(parents_only=True).write_text(python_script)
-    shell_script = get_shell_script_executing_python_file(python_file=python_file.to_str(), ve_name=ve_name)
+    python_file = PathExtended.tmp().joinpath("tmp_scripts", "python", randstr() + ".py")
+    python_file.parent.mkdir(parents=True, exist_ok=True)
+    python_file.write_text(python_script)
+    shell_script = get_shell_script_executing_python_file(python_file=str(python_file), ve_name=ve_name)
     shell_file = write_shell_script_to_file(shell_script)
     return shell_file
 
-def print_code(code: str, lexer: str, desc: str):
+def print_code(code: str, lexer: str, desc: str, subtitle: str=""):
     if lexer == "shell":
         if platform.system() == "Windows": lexer = "powershell"
-        elif platform.system() == "Linux": lexer = "sh"
+        elif platform.system() in ["Linux", "Darwin"]: lexer = "sh"
         else: raise NotImplementedError(f"Platform {platform.system()} not supported for lexer {lexer}")
     console = Console()
-    console.print(Panel(Syntax(code=code, lexer=lexer), title=f"📄 {desc}"), style="bold red")
+    console.print(Panel(Syntax(code=code, lexer=lexer), title=f"📄 {desc}", subtitle=subtitle), style="bold red")
 

machineconfig/utils/installer.py

@@ -3,26 +3,25 @@
 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 crocodile.file_management import P, Read
-from crocodile.core import List as L
+from machineconfig.utils.path_reduced import P as PathExtended
 from crocodile.meta import Terminal
 from machineconfig.utils.utils 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
 
 
 def check_latest():
-    print(f"""
-╔{'═'*78}╗
-║ 🔍  CHECKING FOR LATEST VERSIONS                                               ║
-╚{'═'*78}╝
-""")
+    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_gitshub = []
+    installers_github = []
     for inst__ in installers:
         if "ntop" in inst__.name: 
             print(f"⏭️  Skipping {inst__.name} (ntop)")
@@ -30,9 +29,9 @@ def check_latest():
         if "github" not in inst__.repo_url:
             print(f"⏭️  Skipping {inst__.name} (not a GitHub release)")
             continue
-        installers_gitshub.append(inst__)
+        installers_github.append(inst__)
         
-    print(f"\n🔍 Checking {len(installers_gitshub)} GitHub-based installers...\n")
+    print(f"\n🔍 Checking {len(installers_github)} GitHub-based installers...\n")
 
     def func(inst: Installer):
         print(f"🔎 Checking {inst.exe_name}...")
@@ -41,20 +40,37 @@ def check_latest():
         return inst.exe_name, verdict, current_ver, new_ver
 
     print("\n⏳ Processing installers...\n")
-    res = L(installers_gitshub).apply(func=func, jobs=1)
+    res = [func(inst) for inst in installers_github]
     
-    import pandas as pd
     print("\n📊 Generating results table...\n")
-    res_df = pd.DataFrame(res, columns=["Tool", "Status", "Current Version", "New Version"]).groupby("Status").apply(lambda x: x).reset_index(drop=True)
     
-    from crocodile.core import Display
-    Display.set_pandas_display()
-    print(f"""
-╔{'═'*78}╗
-║ 📊  INSTALLATION STATUS SUMMARY                                                ║
-╚{'═'*78}╝
-""")
-    print(res_df)
+    # 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
+        })
+    
+    # Group by status
+    grouped_data = {}
+    for item in result_data:
+        status = item["Status"]
+        if status not in grouped_data:
+            grouped_data[status] = []
+        grouped_data[status].append(item)
+    
+    console.print(Panel("📊  INSTALLATION STATUS SUMMARY", title="Status", expand=False))
+    
+    # Print each group
+    for status, items in grouped_data.items():
+        print(f"\n{status.upper()}:")
+        print("-" * 60)
+        for item in items:
+            print(f"  {item['Tool']:<20} | Current: {item['Current Version']:<15} | New: {item['New Version']}")
+    print("-" * 60)
     print(f"{'═'*80}")
 
 
@@ -62,16 +78,18 @@ def get_installed_cli_apps():
     print(f"\n{'='*80}\n🔍 LISTING INSTALLED CLI APPS 🔍\n{'='*80}")
     if platform.system() == "Windows": 
         print("🪟 Searching for Windows executables...")
-        apps = P.home().joinpath("AppData/Local/Microsoft/WindowsApps").search("*.exe", not_in=["notepad"])
-    elif platform.system() == "Linux": 
-        print("🐧 Searching for Linux executables...")
-        apps = P(LINUX_INSTALL_PATH).search("*") + P("/usr/local/bin").search("*")
+        apps = PathExtended.home().joinpath("AppData/Local/Microsoft/WindowsApps").search("*.exe", not_in=["notepad"])
+    elif platform.system() in ["Linux", "Darwin"]: 
+        print(f"🐧 Searching for {platform.system()} executables...")
+        if platform.system() == "Linux":
+            apps = PathExtended(LINUX_INSTALL_PATH).search("*") + PathExtended("/usr/local/bin").search("*")
+        else:  # Darwin/macOS
+            apps = PathExtended("/usr/local/bin").search("*") + PathExtended("/opt/homebrew/bin").search("*")
     else: 
         error_msg = f"❌ ERROR: System {platform.system()} not supported"
         print(error_msg)
         raise NotImplementedError(error_msg)
-        
-    apps = L([app for app in apps if app.size("kb") > 0.1 and not app.is_symlink()])  # no symlinks like paint and wsl and bash
+    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}")
     return apps
 
@@ -102,8 +120,8 @@ 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 = P(os_specific_installer.__file__).parent
-    path_os_generic = P(generic_installer.__file__).parent
+    path_os_specific = PathExtended(os_specific_installer.__file__).parent
+    path_os_generic = PathExtended(generic_installer.__file__).parent
 
     path_os_specific_dev = path_os_specific.joinpath("dev")
     path_os_generic_dev = path_os_generic.joinpath("dev")
@@ -111,16 +129,16 @@ 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')}""")
-    res_final["OS_SPECIFIC"] = Read.json(path=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")}""")
-    res_final["OS_GENERIC"] = Read.json(path=path_os_generic.joinpath("config.json"))
+    res_final["OS_GENERIC"] = read_json(path=path_os_generic.joinpath("config.json"))
     
     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"))
+    res_final["OS_SPECIFIC_DEV"] = read_json(path=path_os_specific_dev.joinpath("config.json"))
     
     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"))
+    res_final["OS_GENERIC_DEV"] = read_json(path=path_os_generic_dev.joinpath("config.json"))
 
     path_custom_installer = path_os_generic.with_name("python_custom_installers")
     path_custom_installer_dev = path_custom_installer.joinpath("dev")
@@ -153,7 +171,7 @@ def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
     return res_final
 
 
-def install_all(installers: L[Installer], safe: bool=False, jobs: int = 10, fresh: bool=False):
+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...")
@@ -167,10 +185,17 @@ def install_all(installers: L[Installer], safe: bool=False, jobs: int = 10, fres
         
         if platform.system().lower() == "windows":
             print("🪟 Moving applications to Windows Apps folder...")
-            apps_dir.search("*").apply(lambda app: app.move(folder=P.get_env().WindowsPaths().WindowsApps))
-        elif platform.system().lower() == "linux":
-            print("🐧 Moving applications to Linux bin folder...")
-            Terminal().run(f"sudo mv {apps_dir.as_posix()}/* {LINUX_INSTALL_PATH}/").capture().print_if_unsuccessful(desc=f"MOVING executable to {LINUX_INSTALL_PATH}", strict_err=True, strict_returncode=True)
+            # PathExtended.get_env().WindowsPaths().WindowsApps)
+            folder = PathExtended.home().joinpath("AppData/Local/Microsoft/WindowsApps")
+            apps_dir.search("*").apply(lambda app: app.move(folder=folder))
+        elif platform.system().lower() in ["linux", "darwin"]:
+            system_name = "Linux" if platform.system().lower() == "linux" else "macOS"
+            print(f"🐧 Moving applications to {system_name} bin folder...")
+            if platform.system().lower() == "linux":
+                install_path = LINUX_INSTALL_PATH
+            else:  # Darwin/macOS
+                install_path = "/usr/local/bin"
+            Terminal().run(f"sudo mv {apps_dir.as_posix()}/* {install_path}/").capture().print_if_unsuccessful(desc=f"MOVING executable to {install_path}", strict_err=True, strict_returncode=True)
         else: 
             error_msg = f"❌ ERROR: System {platform.system()} not supported"
             print(error_msg)
@@ -182,10 +207,16 @@ def install_all(installers: L[Installer], safe: bool=False, jobs: int = 10, fres
         
     print(f"🚀 Starting installation of {len(installers)} packages...")
     print(f"\n{'='*80}\n📦 INSTALLING FIRST PACKAGE 📦\n{'='*80}")
-    installers.list[0].install(version=None)
-    
+    installers[0].install(version=None)
+    installers_remaining = installers[1:]
     print(f"\n{'='*80}\n📦 INSTALLING REMAINING PACKAGES 📦\n{'='*80}")
-    res = installers.slice(start=1).apply(lambda x: x.install_robust(version=None), jobs=jobs)  # try out the first installer alone cause it will ask for password, so the rest will inherit the sudo session.
+    
+    # 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
+    )
+    
     console = Console()
     
     print("\n")
@@ -193,15 +224,21 @@ def install_all(installers: L[Installer], safe: bool=False, jobs: int = 10, fres
     
     print("\n")
     console.rule("✓ Same Version Apps")
-    print(f"{res.filter(lambda x: 'same version' in x).print()}")
+    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")
-    print(f"{res.filter(lambda x: 'updated from' in x).print()}")
+    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")
-    print(f"{res.filter(lambda x: 'Failed at' in x).print()}")
+    failed_results = [r for r in res if r and 'Failed at' in str(r)]
+    for result in failed_results:
+        print(f"  {result}")
 
     print("\n")
     print("✨ INSTALLATION COMPLETE ✨".center(100, "="))

machineconfig/utils/installer_utils/installer_abc.py

@@ -1,14 +1,15 @@
-from crocodile.file_management import P
+from machineconfig.utils.path_reduced import P as PathExtended
 from crocodile.meta import Terminal
 from typing import Optional, TypeAlias, Literal
 
 # LINUX_INSTALL_PATH = '/usr/local/bin'
-LINUX_INSTALL_PATH = '~/.local/bin'
-WINDOWS_INSTALL_PATH = P.home().joinpath("AppData/Local/Microsoft/WindowsApps").__str__()
+# 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: P, exe_name: Optional[str] = None, delete: bool=True, rename_to: Optional[str] = None):
+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():
@@ -52,7 +53,7 @@ def find_move_delete_windows(downloaded_file_path: P, exe_name: Optional[str] =
     return exe_new_location
 
 
-def find_move_delete_linux(downloaded: P, tool_name: str, delete: Optional[bool] = True, rename_to: Optional[str] = None):
+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}")
     if downloaded.is_file():
         exe = downloaded
@@ -95,6 +96,6 @@ def find_move_delete_linux(downloaded: P, tool_name: str, delete: Optional[bool]
         downloaded.delete(sure=True)
         print("✅ Temporary files removed")
 
-    exe_new_location = P(LINUX_INSTALL_PATH).joinpath(exe.name)
+    exe_new_location = PathExtended(LINUX_INSTALL_PATH).joinpath(exe.name)
     print(f"✅ Executable installed at: {exe_new_location}\n{'='*80}")
     return exe_new_location

machineconfig/utils/installer_utils/installer_class.py

@@ -1,22 +1,34 @@
-from crocodile.core import Struct
-from crocodile.file_management import P, Read
+
+from machineconfig.utils.path_reduced import P as PathExtended
 from crocodile.meta import Terminal
 from machineconfig.utils.installer_utils.installer_abc import find_move_delete_linux, find_move_delete_windows
 from machineconfig.utils.utils import INSTALL_TMP_DIR, INSTALL_VERSION_ROOT, LIBRARY_ROOT, check_tool_exists
-
+from machineconfig.utils.utils2 import pprint, read_json
 
 import platform
 from typing import Any, Optional
+from pathlib import Path
 
 
 class Installer:
-    def __init__(self, repo_url: str, name: str, doc: str, filename_template_windows_amd_64: str, filename_template_linux_amd_64: str,
-                 strip_v: bool, exe_name: str):
+    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}"
@@ -32,16 +44,18 @@ class Installer:
     def from_dict(d: dict[str, Any], name: str):
         try: return Installer(name=name, **d)
         except Exception as ex:
-            Struct(d).print(as_config=True)
+            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("📂 Searching for configuration files...")
-        path = choose_one_option(options=LIBRARY_ROOT.joinpath("jobs").search("config.json", r=True).list)
+        jobs_dir = Path(LIBRARY_ROOT.joinpath("jobs"))
+        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: dict[str, Any] = read_json(path)  # /python_generic_installers/config.json"))
         print("🔍 Select an application to install:")
         app_name = choose_one_option(options=list(config.keys()), fzf=True)
         # for keys, dict_ in config.items():
@@ -78,9 +92,9 @@ class Installer:
         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 = P(python_custom_installers.__file__).parent.joinpath(self.exe_name + ".py")
+            installer_path = Path(python_custom_installers.__file__).parent.joinpath(self.exe_name + ".py")
             if not installer_path.exists():
-                installer_path = P(python_custom_installers.__file__).parent.joinpath("dev", self.exe_name + ".py")
+                installer_path = Path(python_custom_installers.__file__).parent.joinpath("dev", self.exe_name + ".py")
                 print(f"🔍 Looking for installer in dev folder: {installer_path}")
             else:
                 print(f"🔍 Found installer at: {installer_path}")
@@ -108,7 +122,7 @@ class Installer:
         else:
             print("📥 Downloading from repository...")
             downloaded, version_to_be_installed = self.download(version=version)
-            if downloaded.to_str().endswith(".deb"):
+            if str(downloaded).endswith(".deb"):
                 print(f"📦 Installing .deb package: {downloaded}")
                 assert platform.system() == "Linux"
                 Terminal().run(f"sudo nala install -y {downloaded}").capture().print_if_unsuccessful(desc="Installing .deb", strict_err=True, strict_returncode=True)
@@ -119,8 +133,9 @@ class Installer:
                 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")
-                elif platform.system() == "Linux":
-                    print("🐧 Installing on Linux...")
+                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)
                 else:
                     error_msg = f"❌ ERROR: System {platform.system()} not supported"
@@ -138,24 +153,26 @@ class Installer:
                     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).create(parents_only=True).write_text(version_to_be_installed)
+        INSTALL_VERSION_ROOT.joinpath(self.exe_name).parent.mkdir(parents=True, exist_ok=True)
+        INSTALL_VERSION_ROOT.joinpath(self.exe_name).write_text(version_to_be_installed)
         print(f"✅ Installation completed successfully!\n{'='*80}")
 
     def download(self, version: Optional[str]):
         print(f"\n{'='*80}\n📥 DOWNLOADING: {self.exe_name} 📥\n{'='*80}")
         if "github" not in self.repo_url or ".zip" in self.repo_url or ".tar.gz" in self.repo_url:
-            download_link = P(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 = P(self.filename_template_windows_amd_64)
+                download_link = Path(self.filename_template_windows_amd_64)
                 print(f"🪟 Using Windows-specific download URL: {download_link}")
-            elif platform.system() == "Linux":
-                download_link = P(self.filename_template_linux_amd_64)
-                print(f"🐧 Using Linux-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}")
             else:
                 error_msg = f"❌ ERROR: System {platform.system()} not supported"
                 print(error_msg)
@@ -175,9 +192,10 @@ class Installer:
             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() == "Linux":
+            elif platform.system() in ["Linux", "Darwin"]:
                 file_name = self.filename_template_linux_amd_64.format(version_to_be_installed_stripped)
-                print(f"🐧 Linux file name: {file_name}")
+                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)
@@ -186,8 +204,8 @@ class Installer:
             print(f"📄 File name: {file_name}")
             download_link = release_url.joinpath(file_name)
 
-        print(f"📥 Downloading {self.name} from: {download_link.as_url_str()}")
-        downloaded = download_link.download(folder=INSTALL_TMP_DIR).decompress()
+        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}")
         return downloaded, version_to_be_installed
 
@@ -208,7 +226,7 @@ class Installer:
             version_to_be_installed = version
             print(f"📝 Using specified version: {version_to_be_installed}")
 
-        release_url = P(repo_url + "/releases/download/" + version_to_be_installed)
+        release_url = Path(repo_url + "/releases/download/" + version_to_be_installed)
         print(f"🔗 Release download URL: {release_url}\n{'='*80}")
         return release_url, version_to_be_installed
 
@@ -216,7 +234,8 @@ class Installer:
     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}")
         version_to_be_installed = version
-        tmp_path = INSTALL_VERSION_ROOT.joinpath(exe_name).create(parents_only=True)
+        INSTALL_VERSION_ROOT.joinpath(exe_name).parent.mkdir(parents=True, exist_ok=True)
+        tmp_path = INSTALL_VERSION_ROOT.joinpath(exe_name)
 
         if use_cache:
             print("🗂️  Using cached version information...")

machineconfig/utils/io_save.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from typing import Any, Union, Optional, Mapping
+from pathlib import Path
+import json
+import pickle
+import configparser
+
+try:
+    import toml  # type: ignore
+except Exception:  # pragma: no cover
+    toml = None  # type: ignore
+
+try:
+    import yaml  # type: ignore
+except Exception:  # pragma: no cover
+    yaml = None  # type: ignore
+
+
+PathLike = Union[str, Path]
+
+
+def _ensure_parent(path: PathLike) -> Path:
+    path_obj = Path(path)
+    path_obj.parent.mkdir(parents=True, exist_ok=True)
+    return path_obj
+
+
+def save_pickle(obj: Any, path: PathLike, verbose: bool = False) -> Path:
+    path_obj = _ensure_parent(path)
+    with open(path_obj, "wb") as fh:
+        pickle.dump(obj, fh, protocol=pickle.HIGHEST_PROTOCOL)
+    if verbose:
+        print(f"Saved pickle -> {path_obj}")
+    return Path(path_obj)
+
+
+def save_json(obj: Any, path: PathLike, indent: Optional[int] = None, verbose: bool = False) -> Path:
+    path_obj = _ensure_parent(path)
+    with open(path_obj, "w", encoding="utf-8") as fh:
+        json.dump(obj, fh, indent=indent, ensure_ascii=False)
+        fh.write("\n")
+    if verbose:
+        print(f"Saved json -> {path_obj}")
+    return Path(path_obj)
+
+
+def save_toml(obj: Mapping[str, Any], path: PathLike, verbose: bool = False) -> Path:
+    if toml is None:
+        raise RuntimeError("toml package is required to write TOML files")
+    path_obj = _ensure_parent(path)
+    with open(path_obj, "w", encoding="utf-8") as fh:
+        toml.dump(obj, fh)
+    if verbose:
+        print(f"Saved toml -> {path_obj}")
+    return Path(path_obj)
+
+
+def save_yaml(obj: Any, path: PathLike, verbose: bool = False) -> Path:
+    if yaml is None:
+        raise RuntimeError("PyYAML is required to write YAML files")
+    path_obj = _ensure_parent(path)
+    with open(path_obj, "w", encoding="utf-8") as fh:
+        yaml.safe_dump(obj, fh, sort_keys=False)
+    if verbose:
+        print(f"Saved yaml -> {path_obj}")
+    return Path(path_obj)
+
+
+def save_ini(path: PathLike, obj: Mapping[str, Mapping[str, Any]], verbose: bool = False) -> Path:
+    cp = configparser.ConfigParser()
+    for section, values in obj.items():
+        cp[section] = {str(k): str(v) for k, v in values.items()}
+    path_obj = _ensure_parent(path)
+    with open(path_obj, "w", encoding="utf-8") as fh:
+        cp.write(fh)
+    if verbose:
+        print(f"Saved ini -> {path_obj}")
+    return Path(path_obj)
+
+
+class Save:
+    """Drop-in replacement for crocodile's Save helper.
+
+    Provides static methods for common serialization formats while ensuring
+    parent directories exist and returning a `P` path object.
+    """
+
+    @staticmethod
+    def pickle(obj: Any, path: PathLike, verbose: bool = False, **_kwargs: Any) -> Path:
+        return save_pickle(obj=obj, path=path, verbose=verbose)
+
+    @staticmethod
+    def json(obj: Any, path: PathLike, indent: Optional[int] = None, verbose: bool = False, **_kwargs: Any) -> Path:
+        return save_json(obj=obj, path=path, indent=indent, verbose=verbose)
+
+    @staticmethod
+    def toml(obj: Mapping[str, Any], path: PathLike, verbose: bool = False, **_kwargs: Any) -> Path:
+        return save_toml(obj=obj, path=path, verbose=verbose)
+
+    @staticmethod
+    def yaml(obj: Any, path: PathLike, verbose: bool = False, **_kwargs: Any) -> Path:
+        return save_yaml(obj=obj, path=path, verbose=verbose)
+
+    @staticmethod
+    def ini(obj: Mapping[str, Mapping[str, Any]], path: PathLike, verbose: bool = False, **_kwargs: Any) -> Path:
+        return save_ini(path=path, obj=obj, verbose=verbose)