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

machineconfig/utils/code.py

@@ -1,85 +1,113 @@
-from typing import Optional
 import platform
+from typing import Optional
+import subprocess
 from rich.console import Console
 from rich.panel import Panel
 from rich.syntax import Syntax
 from machineconfig.utils.utils2 import randstr
-from machineconfig.utils.path_reduced import P as PathExtended
-from crocodile.meta import Terminal
+from machineconfig.utils.ve import get_ve_activate_line
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
 
 
-PROGRAM_PATH = (PathExtended.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):
-    if func is None: exec_line = f"""python {python_file}"""
-    else: exec_line = f"""python -m fire {python_file} {func}"""
+def get_shell_script_executing_python_file(python_file: str, func: Optional[str], ve_path: str, strict_execution: bool = True):
+    if func is None:
+        exec_line = f"""python {python_file}"""
+    else:
+        exec_line = f"""python -m fire {python_file} {func}"""
     shell_script = f"""
-. $HOME/scripts/activate_ve {ve_name}
-echo "Executing {exec_line}"
+echo "Executing `{exec_line}`"
+{get_ve_activate_line(ve_path)}
 {exec_line}
 deactivate || true
 """
 
     if strict_execution:
-        if platform.system() == "Windows": shell_script = """$ErrorActionPreference = "Stop" """ + "\n" + shell_script
-        if platform.system() in ["Linux", "Darwin"]: shell_script = "set -e" + "\n" + shell_script
+        if platform.system() == "Windows":
+            shell_script = """$ErrorActionPreference = "Stop" """ + "\n" + shell_script
+        if platform.system() in ["Linux", "Darwin"]:
+            shell_script = "set -e" + "\n" + shell_script
 
-    if platform.system() in ["Linux", "Darwin"]: 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 get_shell_file_executing_python_script(python_script: str, ve_path: str, verbose: bool = True):
+    if verbose:
+        python_script = (
+            f"""
+code = r'''{python_script}''' """
+            + """
+try:
+    from machineconfig.utils.utils import print_code
+    print_code(code=code, lexer="python", desc="Python Script")
+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 = PathExtended.tmp().joinpath("tmp_scripts", "python", randstr() + ".py")
+    python_file.parent.mkdir(parents=True, exist_ok=True)
+    python_file.write_text(python_script, encoding="utf-8")
+    shell_script = get_shell_script_executing_python_file(python_file=str(python_file), func=None, ve_path=ve_path)
+    shell_file = write_shell_script_to_file(shell_script)
+    return shell_file
+
+
 def write_shell_script_to_file(shell_script: str):
-    if platform.system() in ["Linux", "Darwin"]: suffix = ".sh"
-    elif platform.system() == "Windows": suffix = ".ps1"
-    else: raise NotImplementedError(f"Platform {platform.system()} not implemented.")
+    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 = PathExtended.tmp().joinpath("tmp_scripts", "shell", randstr() + suffix)
     shell_file.parent.mkdir(parents=True, exist_ok=True)
-    shell_file.write_text(shell_script)
+    shell_file.write_text(shell_script, encoding="utf-8")
     return shell_file
 
+
 # Enhanced print/log/error/exception statements for better clarity and consistency
 # Improved formatting and language of messages
 # Ensured consistent use of f-strings with triple quotes where applicable
 
+
 def write_shell_script_to_default_program_path(program: str, desc: str, preserve_cwd: bool, display: bool, execute: bool):
     if preserve_cwd:
         if platform.system() == "Windows":
             program = "$orig_path = $pwd\n" + program + "\ncd $orig_path"
         else:
             program = 'orig_path=$(cd -- "." && pwd)\n' + program + '\ncd "$orig_path" || exit'
-    if display: print_code(code=program, lexer="shell", desc=desc, subtitle=str(PROGRAM_PATH))
+    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)
+    PROGRAM_PATH.write_text(program, encoding="utf-8")
     if execute:
-        Terminal().run(f". {PROGRAM_PATH}", shell="powershell").capture().print_if_unsuccessful(desc="🛠️  EXECUTION | Shell script running", strict_err=True, strict_returncode=True)
+        result = subprocess.run(f". {PROGRAM_PATH}", shell=True, capture_output=True, text=True)
+        success = result.returncode == 0 and result.stderr == ""
+        if not success:
+            print("❌ 🛠️  EXECUTION | Shell script running failed")
+            if result.stdout:
+                print(f"STDOUT: {result.stdout}")
+            if result.stderr:
+                print(f"STDERR: {result.stderr}")
+            print(f"Return code: {result.returncode}")
     return None
 
-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}''' """ + """
-try:
-    from machineconfig.utils.utils import print_code
-    print_code(code=code, lexer="python", desc="Python Script")
-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 = 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, subtitle: str=""):
+def print_code(code: str, lexer: str, desc: str, subtitle: str = ""):
     if lexer == "shell":
-        if platform.system() == "Windows": lexer = "powershell"
-        elif platform.system() in ["Linux", "Darwin"]: lexer = "sh"
-        else: raise NotImplementedError(f"Platform {platform.system()} not supported for lexer {lexer}")
+        if platform.system() == "Windows":
+            lexer = "powershell"
+        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}", subtitle=subtitle), style="bold red")
-

machineconfig/utils/installer.py

@@ -1,12 +1,11 @@
-"""package manager
-"""
+"""package manager"""
+
 from machineconfig.utils.installer_utils.installer_abc import LINUX_INSTALL_PATH, CATEGORY
 from machineconfig.utils.installer_utils.installer_class import Installer
 from rich.console import Console
-from rich.panel import Panel # Added import
+from rich.panel import Panel  # Added import
 
-from machineconfig.utils.path_reduced import P as PathExtended
-from crocodile.meta import Terminal
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from machineconfig.utils.utils import INSTALL_VERSION_ROOT
 from machineconfig.utils.utils2 import read_json
 
@@ -17,20 +16,20 @@ from joblib import Parallel, delayed
 
 
 def check_latest():
-    console = Console() # Added console initialization
-    console.print(Panel("🔍  CHECKING FOR LATEST VERSIONS", title="Status", expand=False)) # Replaced print with Panel
+    console = Console()  # Added console initialization
+    console.print(Panel("🔍  CHECKING FOR LATEST VERSIONS", title="Status", expand=False))  # Replaced print with Panel
     installers = get_installers(system=platform.system(), dev=False)
     # installers += get_installers(system=platform.system(), dev=True)
     installers_github = []
     for inst__ in installers:
-        if "ntop" in inst__.name: 
+        if "ntop" in inst__.name:
             print(f"⏭️  Skipping {inst__.name} (ntop)")
             continue
         if "github" not in inst__.repo_url:
             print(f"⏭️  Skipping {inst__.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):
@@ -41,29 +40,24 @@ def check_latest():
 
     print("\n⏳ Processing installers...\n")
     res = [func(inst) for inst in installers_github]
-    
+
     print("\n📊 Generating results table...\n")
-    
+
     # Convert to list of dictionaries and group by status
     result_data = []
     for tool, status, current_ver, new_ver in res:
-        result_data.append({
-            "Tool": tool,
-            "Status": status,
-            "Current Version": current_ver,
-            "New Version": new_ver
-        })
-    
+        result_data.append({"Tool": tool, "Status": status, "Current Version": current_ver, "New Version": new_ver})
+
     # Group by status
-    grouped_data = {}
+    grouped_data: dict[str, list[dict[str, Any]]] = {}
     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()}:")
@@ -71,31 +65,31 @@ def check_latest():
         for item in items:
             print(f"  {item['Tool']:<20} | Current: {item['Current Version']:<15} | New: {item['New Version']}")
     print("-" * 60)
-    print(f"{'═'*80}")
+    print(f"{'═' * 80}")
 
 
 def get_installed_cli_apps():
-    print(f"\n{'='*80}\n🔍 LISTING INSTALLED CLI APPS 🔍\n{'='*80}")
-    if platform.system() == "Windows": 
+    print(f"\n{'=' * 80}\n🔍 LISTING INSTALLED CLI APPS 🔍\n{'=' * 80}")
+    if platform.system() == "Windows":
         print("🪟 Searching for Windows executables...")
         apps = PathExtended.home().joinpath("AppData/Local/Microsoft/WindowsApps").search("*.exe", not_in=["notepad"])
-    elif platform.system() in ["Linux", "Darwin"]: 
+    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: 
+    else:
         error_msg = f"❌ ERROR: System {platform.system()} not supported"
         print(error_msg)
         raise NotImplementedError(error_msg)
     apps = [app for app in apps if app.size("kb") > 0.1 and not app.is_symlink()]  # no symlinks like paint and wsl and bash
-    print(f"✅ Found {len(apps)} installed applications\n{'='*80}")
+    print(f"✅ Found {len(apps)} installed applications\n{'=' * 80}")
     return apps
 
 
 def get_installers(system: str, dev: bool) -> list[Installer]:
-    print(f"\n{'='*80}\n🔍 LOADING INSTALLER CONFIGURATIONS 🔍\n{'='*80}")
+    print(f"\n{'=' * 80}\n🔍 LOADING INSTALLER CONFIGURATIONS 🔍\n{'=' * 80}")
     res_all = get_all_dicts(system=system)
     if not dev:
         print("ℹ️  Excluding development installers...")
@@ -105,21 +99,22 @@ def get_installers(system: str, dev: bool) -> list[Installer]:
     res_final = {}
     for _k, v in res_all.items():
         res_final.update(v)
-    print(f"✅ Loaded {len(res_final)} installer configurations\n{'='*80}")
+    print(f"✅ Loaded {len(res_final)} installer configurations\n{'=' * 80}")
     return [Installer.from_dict(d=vd, name=k) for k, vd in res_final.items()]
 
 
 def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
-    print(f"\n{'='*80}\n📂 LOADING CONFIGURATION FILES 📂\n{'='*80}")
-    
+    print(f"\n{'=' * 80}\n📂 LOADING CONFIGURATION FILES 📂\n{'=' * 80}")
+
     print(f"🔍 Importing OS-specific installers for {system}...")
-    if system == "Windows": 
+    if system == "Windows":
         import machineconfig.jobs.python_windows_installers as os_specific_installer
-    else: 
+    else:
         import machineconfig.jobs.python_linux_installers as os_specific_installer
 
     print("🔍 Importing generic installers...")
     import machineconfig.jobs.python_generic_installers as generic_installer
+
     path_os_specific = PathExtended(os_specific_installer.__file__).parent
     path_os_generic = PathExtended(generic_installer.__file__).parent
 
@@ -128,15 +123,15 @@ def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
 
     print("📂 Loading configuration files...")
     res_final: dict[CATEGORY, dict[str, dict[str, Any]]] = {}
-    print(f"""📄 Loading OS-specific config from: {path_os_specific.joinpath('config.json')}""")
+    print(f"""📄 Loading OS-specific config from: {path_os_specific.joinpath("config.json")}""")
     res_final["OS_SPECIFIC"] = read_json(path=path_os_specific.joinpath("config.json"))
 
     print(f"""📄 Loading OS-generic config from: {path_os_generic.joinpath("config.json")}""")
     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"))
-    
+
     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"))
 
@@ -145,11 +140,12 @@ def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
 
     print(f"🔍 Loading custom installers from: {path_custom_installer}")
     import runpy
+
     res_custom: dict[str, dict[str, Any]] = {}
     for item in path_custom_installer.search("*.py", r=False, not_in=["__init__"]):
         try:
             print(f"📄 Loading custom installer: {item.name}")
-            config_dict = runpy.run_path(str(item), run_name=None)['config_dict']
+            config_dict = runpy.run_path(str(item), run_name=None)["config_dict"]
             res_custom[item.stem] = config_dict
         except Exception as ex:
             print(f"❌ Failed to load {item}: {ex}")
@@ -159,84 +155,80 @@ def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
     for item in path_custom_installer_dev.search("*.py", r=False, not_in=["__init__"]):
         try:
             print(f"📄 Loading custom dev installer: {item.name}")
-            config_dict = runpy.run_path(str(item), run_name=None)['config_dict']
+            config_dict = runpy.run_path(str(item), run_name=None)["config_dict"]
             res_custom_dev[item.stem] = config_dict
         except Exception as ex:
             print(f"❌ Failed to load {item}: {ex}")
 
     res_final["CUSTOM"] = res_custom
     res_final["CUSTOM_DEV"] = res_custom_dev
-    
-    print(f"✅ Configuration loading complete:\n - OS_SPECIFIC: {len(res_final['OS_SPECIFIC'])} items\n - OS_GENERIC: {len(res_final['OS_GENERIC'])} items\n - CUSTOM: {len(res_final['CUSTOM'])} items\n{'='*80}")
+
+    print(f"✅ Configuration loading complete:\n - OS_SPECIFIC: {len(res_final['OS_SPECIFIC'])} items\n - OS_GENERIC: {len(res_final['OS_GENERIC'])} items\n - CUSTOM: {len(res_final['CUSTOM'])} items\n{'=' * 80}")
     return res_final
 
 
-def install_all(installers: list[Installer], safe: bool=False, jobs: int = 10, fresh: bool=False):
-    print(f"\n{'='*80}\n🚀 BULK INSTALLATION PROCESS 🚀\n{'='*80}")
-    if fresh: 
+def install_all(installers: list[Installer], safe: bool = False, jobs: int = 10, fresh: bool = False):
+    print(f"\n{'=' * 80}\n🚀 BULK INSTALLATION PROCESS 🚀\n{'=' * 80}")
+    if fresh:
         print("🧹 Fresh install requested - clearing version cache...")
         INSTALL_VERSION_ROOT.delete(sure=True)
         print("✅ Version cache cleared")
-        
+
     if safe:
-        print("⚠️  Safe installation mode activated...")
-        from machineconfig.jobs.python.check_installations import APP_SUMMARY_PATH
-        apps_dir = APP_SUMMARY_PATH.readit()
-        
-        if platform.system().lower() == "windows":
-            print("🪟 Moving applications to Windows Apps folder...")
-            # 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)
-            raise NotImplementedError(error_msg)
-            
-        apps_dir.delete(sure=True)
-        print(f"✅ Safe installation completed\n{'='*80}")
-        return None
-        
+        pass
+        # print("⚠️  Safe installation mode activated...")
+        # from machineconfig.jobs.python.check_installations import APP_SUMMARY_PATH
+        # if platform.system().lower() == "windows":
+        #     print("🪟 Moving applications to Windows Apps folder...")
+        #     # 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)
+        #     raise NotImplementedError(error_msg)
+
+        # apps_dir.delete(sure=True)
+        # print(f"✅ Safe installation completed\n{'='*80}")
+        # return None
+
     print(f"🚀 Starting installation of {len(installers)} packages...")
-    print(f"\n{'='*80}\n📦 INSTALLING FIRST PACKAGE 📦\n{'='*80}")
+    print(f"\n{'=' * 80}\n📦 INSTALLING FIRST PACKAGE 📦\n{'=' * 80}")
     installers[0].install(version=None)
     installers_remaining = installers[1:]
-    print(f"\n{'='*80}\n📦 INSTALLING REMAINING PACKAGES 📦\n{'='*80}")
-    
+    print(f"\n{'=' * 80}\n📦 INSTALLING REMAINING PACKAGES 📦\n{'=' * 80}")
+
     # Use joblib for parallel processing of remaining installers
-    res = Parallel(n_jobs=jobs)(
-        delayed(lambda x: x.install_robust(version=None))(installer) 
-        for installer in installers_remaining
-    )
-    
+    res = Parallel(n_jobs=jobs)(delayed(lambda x: x.install_robust(version=None))(installer) for installer in installers_remaining)
+
     console = Console()
-    
+
     print("\n")
     console.rule("📊 INSTALLATION RESULTS SUMMARY 📊")
-    
+
     print("\n")
     console.rule("✓ Same Version Apps")
-    same_version_results = [r for r in res if r and 'same version' in str(r)]
+    same_version_results = [r for r in res if r and "same version" in str(r)]
     for result in same_version_results:
         print(f"  {result}")
-    
+
     print("\n")
     console.rule("⬆️ Updated Apps")
-    updated_results = [r for r in res if r and 'updated from' in str(r)]
+    updated_results = [r for r in res if r and "updated from" in str(r)]
     for result in updated_results:
         print(f"  {result}")
-    
+
     print("\n")
     console.rule("❌ Failed Apps")
-    failed_results = [r for r in res if r and 'Failed at' in str(r)]
+    failed_results = [r for r in res if r and "Failed at" in str(r)]
     for result in failed_results:
         print(f"  {result}")
 

machineconfig/utils/installer_utils/installer_abc.py

@@ -1,6 +1,6 @@
-from machineconfig.utils.path_reduced import P as PathExtended
-from crocodile.meta import Terminal
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from typing import Optional, TypeAlias, Literal
+import subprocess
 
 # LINUX_INSTALL_PATH = '/usr/local/bin'
 # LINUX_INSTALL_PATH = '~/.local/bin'
@@ -9,21 +9,22 @@ WINDOWS_INSTALL_PATH = PathExtended.home().joinpath("AppData/Local/Microsoft/Win
 CATEGORY: TypeAlias = Literal["OS_SPECIFIC", "OS_GENERIC", "CUSTOM", "OS_SPECIFIC_DEV", "OS_GENERIC_DEV", "CUSTOM_DEV"]
 
 
-def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optional[str] = None, delete: bool=True, rename_to: Optional[str] = None):
-    print(f"\n{'='*80}\n🔍 PROCESSING WINDOWS EXECUTABLE 🔍\n{'='*80}")
-    if exe_name is not None and ".exe" in exe_name: exe_name = exe_name.replace(".exe", "")
+def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optional[str] = None, delete: bool = True, rename_to: Optional[str] = None):
+    print(f"\n{'=' * 80}\n🔍 PROCESSING WINDOWS EXECUTABLE 🔍\n{'=' * 80}")
+    if exe_name is not None and ".exe" in exe_name:
+        exe_name = exe_name.replace(".exe", "")
     if downloaded_file_path.is_file():
         exe = downloaded_file_path
         print(f"📄 Found direct executable file: {exe}")
     else:
         print(f"🔎 Searching for executable in: {downloaded_file_path}")
         if exe_name is None:
-            exe = downloaded_file_path.search("*.exe", r=True).list[0]
+            exe = downloaded_file_path.search("*.exe", r=True)[0]
             print(f"✅ Found executable: {exe}")
         else:
             tmp = downloaded_file_path.search(f"{exe_name}.exe", r=True)
             if len(tmp) == 1:
-                exe = tmp.list[0]
+                exe = tmp[0]
                 print(f"✅ Found exact match for {exe_name}.exe: {exe}")
             else:
                 search_res = downloaded_file_path.search("*.exe", r=True)
@@ -31,10 +32,10 @@ def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optio
                     print(f"❌ ERROR: No executable found in {downloaded_file_path}")
                     raise IndexError(f"No executable found in {downloaded_file_path}")
                 elif len(search_res) == 1:
-                    exe = search_res.list[0]
+                    exe = search_res[0]
                     print(f"✅ Found single executable: {exe}")
                 else:
-                    exe = search_res.sort(lambda x: x.size("kb")).list[-1]
+                    exe = max(search_res, key=lambda x: x.size("kb"))
                     print(f"✅ Selected largest executable ({exe.size('kb')} KB): {exe}")
         if rename_to and exe.name != rename_to:
             print(f"🏷️  Renaming '{exe.name}' to '{rename_to}'")
@@ -49,12 +50,12 @@ def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optio
         downloaded_file_path.delete(sure=True)
         print("✅ Temporary files removed")
 
-    print(f"{'='*80}")
+    print(f"{'=' * 80}")
     return exe_new_location
 
 
 def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Optional[bool] = True, rename_to: Optional[str] = None):
-    print(f"\n{'='*80}\n🔍 PROCESSING LINUX EXECUTABLE 🔍\n{'='*80}")
+    print(f"\n{'=' * 80}\n🔍 PROCESSING LINUX EXECUTABLE 🔍\n{'=' * 80}")
     if downloaded.is_file():
         exe = downloaded
         print(f"📄 Found direct executable file: {exe}")
@@ -62,7 +63,7 @@ def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Opt
         print(f"🔎 Searching for executable in: {downloaded}")
         res = downloaded.search(f"*{tool_name}*", folders=False, r=True)
         if len(res) == 1:
-            exe = res.list[0]
+            exe = res[0]
             print(f"✅ Found match for pattern '*{tool_name}*': {exe}")
         else:
             exe_search_res = downloaded.search(tool_name, folders=False, r=True)
@@ -70,10 +71,10 @@ def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Opt
                 print(f"❌ ERROR: No search results for `{tool_name}` in `{downloaded}`")
                 raise IndexError(f"No executable found in {downloaded}")
             elif len(exe_search_res) == 1:
-                exe = exe_search_res.list[0]
+                exe = exe_search_res[0]
                 print(f"✅ Found exact match for '{tool_name}': {exe}")
             else:
-                exe = exe_search_res.sort(lambda x: x.size("kb")).list[-1]
+                exe = max(exe_search_res, key=lambda x: x.size("kb"))
                 print(f"✅ Selected largest executable ({exe.size('kb')} KB): {exe}")
 
     if rename_to and exe.name != rename_to:
@@ -87,7 +88,18 @@ def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Opt
     # exe.move(folder=LINUX_INSTALL_PATH, overwrite=False)
     if "/usr" in LINUX_INSTALL_PATH:
         print("🔑 Using sudo to move file to system directory...")
-        Terminal().run(f"sudo mv {exe} {LINUX_INSTALL_PATH}/").capture().print_if_unsuccessful(desc=f"MOVING executable `{exe}` to {LINUX_INSTALL_PATH}", strict_err=True, strict_returncode=True)
+        cmd = f"sudo mv {exe} {LINUX_INSTALL_PATH}/"
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+        success = result.returncode == 0 and result.stderr == ""
+        if not success:
+            desc = f"MOVING executable `{exe}` to {LINUX_INSTALL_PATH}"
+            print(f"❌ {desc} failed")
+            if result.stdout:
+                print(f"STDOUT: {result.stdout}")
+            if result.stderr:
+                print(f"STDERR: {result.stderr}")
+            print(f"Return code: {result.returncode}")
+            raise RuntimeError(f"Failed to move executable: {result.stderr or result.stdout}")
     else:
         exe.move(folder=LINUX_INSTALL_PATH, overwrite=True)
 
@@ -97,5 +109,5 @@ def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Opt
         print("✅ Temporary files removed")
 
     exe_new_location = PathExtended(LINUX_INSTALL_PATH).joinpath(exe.name)
-    print(f"✅ Executable installed at: {exe_new_location}\n{'='*80}")
-    return exe_new_location
+    print(f"✅ Executable installed at: {exe_new_location}\n{'=' * 80}")
+    return exe_new_location