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

machineconfig/utils/code.py

@@ -1,11 +1,11 @@
 from typing import Optional
 import platform
+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
 
 
 PROGRAM_PATH = (PathExtended.home().joinpath("tmp_results", "shells", "python_return_command") + (".ps1" if platform.system() == "Windows" else ".sh"))
@@ -35,7 +35,7 @@ def write_shell_script_to_file(shell_script: str):
     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
@@ -50,9 +50,17 @@ def write_shell_script_to_default_program_path(program: str, desc: str, preserve
             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))
     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(f"❌ 🛠️  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):
@@ -70,7 +78,7 @@ except ImportError:
 """ + 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)
+    python_file.write_text(python_script, encoding="utf-8")
     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
@@ -82,4 +90,3 @@ def print_code(code: str, lexer: str, desc: str, subtitle: str=""):
         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

@@ -6,7 +6,6 @@ from rich.console import Console
 from rich.panel import Panel # Added import
 
 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
 
@@ -23,14 +22,14 @@ def check_latest():
     # 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,9 +40,9 @@ 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:
@@ -53,17 +52,17 @@ def check_latest():
             "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()}:")
@@ -76,16 +75,16 @@ def check_latest():
 
 def get_installed_cli_apps():
     print(f"\n{'='*80}\n🔍 LISTING INSTALLED CLI APPS 🔍\n{'='*80}")
-    if platform.system() == "Windows": 
+    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)
@@ -111,11 +110,11 @@ def get_installers(system: str, dev: bool) -> list[Installer]:
 
 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"🔍 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...")
@@ -133,10 +132,10 @@ def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
 
     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"))
 
@@ -166,74 +165,73 @@ def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
 
     res_final["CUSTOM"] = res_custom
     res_final["CUSTOM_DEV"] = res_custom_dev
-    
+
     print(f"✅ Configuration loading complete:\n - OS_SPECIFIC: {len(res_final['OS_SPECIFIC'])} items\n - OS_GENERIC: {len(res_final['OS_GENERIC'])} items\n - CUSTOM: {len(res_final['CUSTOM'])} items\n{'='*80}")
     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: 
+    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}")
     installers[0].install(version=None)
     installers_remaining = installers[1:]
     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) 
+        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)]
     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)]
     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)]

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 typing import Optional, TypeAlias, Literal
+import subprocess
 
 # LINUX_INSTALL_PATH = '/usr/local/bin'
 # LINUX_INSTALL_PATH = '~/.local/bin'
@@ -18,12 +18,12 @@ def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optio
     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 +31,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}'")
@@ -62,7 +62,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 +70,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 +87,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)
 
@@ -98,4 +109,4 @@ def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Opt
 
     exe_new_location = PathExtended(LINUX_INSTALL_PATH).joinpath(exe.name)
     print(f"✅ Executable installed at: {exe_new_location}\n{'='*80}")
-    return exe_new_location
+    return exe_new_location

machineconfig/utils/installer_utils/installer_class.py

@@ -1,11 +1,11 @@
 
 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
+import subprocess
 from typing import Any, Optional
 from pathlib import Path
 
@@ -68,12 +68,14 @@ class Installer:
     def install_robust(self, version: Optional[str]):
         try:
             print(f"\n{'='*80}\n🚀 INSTALLING {self.exe_name.upper()} 🚀\n{'='*80}")
-            old_version_cli = Terminal().run(f"{self.exe_name} --version").op.replace("\n", "")
+            result_old = subprocess.run(f"{self.exe_name} --version", shell=True, capture_output=True, text=True)
+            old_version_cli = result_old.stdout.strip()
             print(f"📊 Current version: {old_version_cli or 'Not installed'}")
 
             self.install(version=version)
 
-            new_version_cli = Terminal().run(f"{self.exe_name} --version").op.replace("\n", "")
+            result_new = subprocess.run(f"{self.exe_name} --version", shell=True, capture_output=True, text=True)
+            new_version_cli = result_new.stdout.strip()
             print(f"📊 New version: {new_version_cli}")
 
             if old_version_cli == new_version_cli:
@@ -104,9 +106,16 @@ class Installer:
             program: str = runpy.run_path(str(installer_path), run_name=None)['main'](version=version)
             # print(program)
             print("🚀 Running installation script...")
-            Terminal(stdin=None, stdout=None, stderr=None).run_script(script=program, shell="default").print(desc="Running custom installer", capture=True)
-            # import subprocess
-            # subprocess.run(program, shell=True, check=True)
+            if platform.system() == "Linux": script = "#!/bin/bash" + "\n" + program
+            else: script = program
+            script_file = PathExtended.tmpfile(name="tmp_shell_script", suffix=".ps1" if platform.system() == "Windows" else ".sh", folder="tmp_scripts").write_text(script, newline=None if platform.system() == "Windows" else "\n")
+            if platform.system() == "Windows":
+                start_cmd = "powershell"
+                full_command = f"{start_cmd} {script_file}"
+            else:
+                start_cmd = "bash"
+                full_command = f"{start_cmd} {script_file}"
+            subprocess.run(full_command, stdin=None, stdout=None, stderr=None, shell=True, text=True)
             version_to_be_installed = str(version)
             print(f"✅ Custom installation completed\n{'='*80}")
 
@@ -116,7 +125,15 @@ class Installer:
             desc = package_manager + " installation"
             version_to_be_installed = package_manager + "Latest"
             print(f"🚀 Running: {self.repo_url}")
-            Terminal().run(self.repo_url, shell="default").capture().print_if_unsuccessful(desc=desc, strict_err=True, strict_returncode=True)
+            result = subprocess.run(self.repo_url, shell=True, capture_output=True, text=True)
+            success = result.returncode == 0 and result.stderr == ""
+            if not success:
+                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}")
             print(f"✅ Package manager installation completed\n{'='*80}")
 
         else:
@@ -125,7 +142,16 @@ class Installer:
             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)
+                result = subprocess.run(f"sudo nala install -y {downloaded}", shell=True, capture_output=True, text=True)
+                success = result.returncode == 0 and result.stderr == ""
+                if not success:
+                    desc = "Installing .deb"
+                    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}")
                 print("🗑️  Cleaning up .deb package...")
                 downloaded.delete(sure=True)
                 print(f"✅ DEB package installation completed\n{'='*80}")
@@ -154,7 +180,7 @@ class Installer:
 
         print(f"💾 Saving version information to: {INSTALL_VERSION_ROOT.joinpath(self.exe_name)}")
         INSTALL_VERSION_ROOT.joinpath(self.exe_name).parent.mkdir(parents=True, exist_ok=True)
-        INSTALL_VERSION_ROOT.joinpath(self.exe_name).write_text(version_to_be_installed)
+        INSTALL_VERSION_ROOT.joinpath(self.exe_name).write_text(version_to_be_installed, encoding="utf-8")
         print(f"✅ Installation completed successfully!\n{'='*80}")
 
     def download(self, version: Optional[str]):
@@ -240,19 +266,19 @@ class Installer:
         if use_cache:
             print("🗂️  Using cached version information...")
             if tmp_path.exists():
-                existing_version = tmp_path.read_text().rstrip()
+                existing_version = tmp_path.read_text(encoding="utf-8").rstrip()
                 print(f"📄 Found cached version: {existing_version}")
             else:
                 existing_version = None
                 print("ℹ️  No cached version information found")
         else:
             print("🔍 Checking installed version directly...")
-            resp = Terminal().run(exe_name, "--version", check=False).capture()
-            if resp.op == '':
+            result = subprocess.run([exe_name, "--version"], check=False, capture_output=True, text=True)
+            if result.stdout.strip() == '':
                 existing_version = None
                 print("ℹ️  Could not detect installed version")
             else:
-                existing_version = resp.op.strip()
+                existing_version = result.stdout.strip()
                 print(f"📄 Detected installed version: {existing_version}")
 
         if existing_version is not None:
@@ -262,11 +288,11 @@ class Installer:
                 return ("✅ Uptodate", version.strip(), version_to_be_installed.strip())
             else:
                 print(f"🔄 {exe_name} needs update: {existing_version.rstrip()} → {version_to_be_installed}")
-                tmp_path.write_text(version_to_be_installed)
+                tmp_path.write_text(version_to_be_installed, encoding="utf-8")
                 return ("❌ Outdated", existing_version.strip(), version_to_be_installed.strip())
         else:
             print(f"📦 {exe_name} is not installed. Will install version: {version_to_be_installed}")
-            tmp_path.write_text(version_to_be_installed)
+            tmp_path.write_text(version_to_be_installed, encoding="utf-8")
 
         print(f"{'='*80}")
-        return ("⚠️ NotInstalled", "None", version_to_be_installed.strip())
+        return ("⚠️ NotInstalled", "None", version_to_be_installed.strip())

machineconfig/utils/io_save.py

@@ -5,16 +5,8 @@ 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
+import toml
+import yaml
 
 
 PathLike = Union[str, Path]
@@ -46,8 +38,6 @@ def save_json(obj: Any, path: PathLike, indent: Optional[int] = None, verbose: b
 
 
 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)
@@ -57,8 +47,6 @@ def save_toml(obj: Mapping[str, Any], path: PathLike, verbose: bool = False) ->
 
 
 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)
@@ -80,7 +68,7 @@ def save_ini(path: PathLike, obj: Mapping[str, Mapping[str, Any]], verbose: bool
 
 
 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.

machineconfig/utils/options.py

@@ -1,4 +1,4 @@
-from crocodile.meta import Terminal
+
 from pathlib import Path
 from rich.text import Text
 from rich.panel import Panel
@@ -27,7 +27,13 @@ def check_tool_exists(tool_name: str, install_script: Optional[str] = None) -> b
     if res is False and install_script is not None:
         console = Console()
         console.print(Panel(f"📥 INSTALLING TOOL | Installing {tool_name}...", border_style="bold blue", expand=False))
-        Terminal().run(install_script, shell="powershell").print()
+        result = subprocess.run(install_script, shell=True, capture_output=True, text=True)
+        print(f"Command: {install_script}")
+        if result.stdout:
+            print(f"STDOUT: {result.stdout}")
+        if result.stderr:
+            print(f"STDERR: {result.stderr}")
+        print(f"Return code: {result.returncode}")
         return check_tool_exists(tool_name=tool_name, install_script=None)
     return res
 
@@ -130,7 +136,8 @@ def display_options(msg: str, options: Iterable[T], header: str="", tail: str=""
 def choose_cloud_interactively() -> str:
     console = Console()
     console.print(Panel("🔍 LISTING CLOUD REMOTES | Fetching available cloud remotes...", border_style="bold blue", expand=False))
-    tmp = Terminal().run("rclone listremotes").op_if_successfull_or_default(strict_returcode=False)
+    result = subprocess.run("rclone listremotes", shell=True, capture_output=True, text=True)
+    tmp = result.stdout if result.returncode == 0 else None
     if isinstance(tmp, str):
         remotes: list[str] = [x.replace(":", "") for x in tmp.splitlines()]
 

machineconfig/utils/path.py

@@ -13,6 +13,11 @@ console = Console()
 
 def sanitize_path(a_path: PathExtended) -> PathExtended:
     path = PathExtended(a_path)
+    if Path.cwd() == Path.home() and not path.exists():
+        result = input("Current working directory is home, and passed path is not full path, are you sure you want to continue, [y]/n? ") or "y"
+        if result == "y":
+            import sys
+            sys.exit()
     if path.as_posix().startswith("/home") or path.as_posix().startswith("/Users"):
         if platform.system() == "Windows":  # path copied from Linux/Mac to Windows
             # For Linux: /home/username, for Mac: /Users/username