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

machineconfig/utils/installer_utils/installer_class.py

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

machineconfig/utils/io.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from typing import Any, Union, Optional, Mapping
+from pathlib import Path
+import json
+import pickle
+import configparser
+
+
+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:
+#     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:
+#     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)
+
+
+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 from_pickle(path: Path) -> Any:
+    import pickle
+
+    return pickle.loads(path.read_bytes())

machineconfig/utils/links.py

@@ -1,5 +1,5 @@
-from machineconfig.utils.path_reduced import PathExtended as PathExtended, PLike
-from machineconfig.utils.utils2 import randstr
+from machineconfig.utils.path_extended import PathExtended as PathExtended, PLike
+from machineconfig.utils.accessories import randstr
 from rich.console import Console
 from rich.panel import Panel
 

machineconfig/utils/notifications.py

@@ -1,16 +1,8 @@
 """Notifications Module"""
 
-# from crocodile.core import install_n_import
-# from crocodile.file_management import P, Read
 from pathlib import Path
-
-# from crocodile.meta import RepeatUntilNoException
 import smtplib
 import imaplib
-
-# from email import message
-# from email import encoders
-# from email.mime.base import MIMEBase
 from email.mime.text import MIMEText
 from email.mime.multipart import MIMEMultipart
 from typing import Optional, Any, Union
@@ -192,7 +184,6 @@ encryption = ssl
     #     else:
     #         body_file_path = None
     #         assert body is not None, "You must pass either body or body_file."
-    #     from crocodile.meta import Terminal
 
     #     to_str = ",".join(to)
     #     attachments_str = " ".join([f"--attachment {str(p)}" for p in attachments]) if attachments is not None else ""

machineconfig/utils/{path_reduced.py → path_extended.py}

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

machineconfig/utils/{path.py → path_helper.py}

@@ -1,4 +1,4 @@
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.path_extended import PathExtended as PathExtended
 from machineconfig.utils.options import choose_one_option
 from machineconfig.utils.source_of_truth import EXCLUDE_DIRS
 from rich.console import Console

machineconfig/utils/procs.py

@@ -8,7 +8,7 @@ from typing import Optional, Any
 from rich.console import Console
 from rich.panel import Panel
 from datetime import datetime, timezone
-from machineconfig.utils.utils2 import pprint
+from machineconfig.utils.accessories import pprint
 
 console = Console()
 
@@ -241,6 +241,7 @@ def get_age(create_time: Any) -> str:
 
 def main():
     from machineconfig.utils.procs import ProcessManager
+
     ProcessManager().choose_and_kill()
 
 

machineconfig/utils/{utils5.py → scheduler.py}

@@ -3,7 +3,8 @@ from typing import Callable, Optional, Union, Any, NoReturn, TypeVar, Protocol,
 import logging
 import time
 from datetime import datetime, timezone, timedelta
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
+from machineconfig.utils.io import from_pickle
+from machineconfig.utils.path_extended import PathExtended as PathExtended
 
 
 class LoggerTemplate(Protocol):
@@ -108,7 +109,7 @@ class Scheduler:
             # "logfile": self.logger.file_path
         }
         summ.update(sess_stats)
-        from machineconfig.utils.utils2 import get_repr
+        from machineconfig.utils.accessories import get_repr
 
         tmp = get_repr(summ)
         self.logger.critical("\n--> Scheduler has finished running a session. \n" + tmp + "\n" + "-" * 100)
@@ -157,12 +158,6 @@ def to_pickle(obj: Any, path: Path) -> None:
     path.write_bytes(pickle.dumps(obj))
 
 
-def from_pickle(path: Path) -> Any:
-    import pickle
-
-    return pickle.loads(path.read_bytes())
-
-
 class Cache(Generic[T]):  # This class helps to accelrate access to latest data coming from expensive function. The class has two flavours, memory-based and disk-based variants."""
     # source_func: Callable[[], T]
     def __init__(

machineconfig/utils/schemas/installer/installer_types.py

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

machineconfig/utils/ssh.py

@@ -3,8 +3,8 @@ import os
 from dataclasses import dataclass
 import rich.console
 from machineconfig.utils.terminal import Terminal, Response, MACHINE
-from machineconfig.utils.path_reduced import PathExtended, PLike, OPLike
-from machineconfig.utils.utils2 import pprint
+from machineconfig.utils.path_extended import PathExtended, PLike, OPLike
+from machineconfig.utils.accessories import pprint
 # from machineconfig.utils.ve import get_ve_activate_line
 
 

machineconfig/utils/terminal.py

@@ -1,4 +1,4 @@
-from machineconfig.utils.path_reduced import PathExtended, OPLike
+from machineconfig.utils.path_extended import PathExtended, OPLike
 import subprocess
 from typing import Any, BinaryIO, Optional, Union
 import platform
@@ -219,9 +219,19 @@ class Terminal:
 
     @staticmethod
     def get_header(wdir: OPLike, toolbox: bool):
+        if toolbox:
+            toobox_code = """
+try:
+    from crocodile.toolbox import *
+except ImportError:
+    print("Crocodile not found, skipping import.")
+    pass
+"""
+        else:
+            toobox_code = "# No toolbox import."
         return f"""
 # >> Code prepended
-{"from crocodile.toolbox import *" if toolbox else "# No toolbox import."}
+{toobox_code}
 {'''sys.path.insert(0, r'{wdir}') ''' if wdir is not None else "# No path insertion."}
 # >> End of header, start of script passed
 """

machineconfig/utils/ve.py

@@ -1,8 +1,7 @@
-from machineconfig.utils.path_reduced import PathExtended as PathExtended
-from machineconfig.utils.utils2 import read_ini
+from machineconfig.utils.path_extended import PathExtended as PathExtended
+from machineconfig.utils.io import read_ini
 import platform
 from typing import Optional
-from pathlib import Path
 
 
 def get_ve_path_and_ipython_profile(init_path: PathExtended) -> tuple[Optional[str], Optional[str]]:
@@ -39,19 +38,6 @@ def get_ve_path_and_ipython_profile(init_path: PathExtended) -> tuple[Optional[s
     return ve_path, ipy_profile
 
 
-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
-
-
 def get_ve_activate_line(ve_root: str):
     if platform.system() == "Windows":
         activate_ve_line = f". {ve_root}/Scripts/activate.ps1"