machineconfig 7.58__py3-none-any.whl → 7.59__py3-none-any.whl

machineconfig/utils/installer_utils/installer_class.py

@@ -1,7 +1,7 @@
-from machineconfig.utils.path_extended import PathExtended
-from machineconfig.utils.installer_utils.installer_abc import find_move_delete_linux, find_move_delete_windows
+from machineconfig.utils.path_extended import PathExtended, DECOMPRESS_SUPPORTED_FORMATS
+from machineconfig.utils.installer_utils.installer_locator_utils import find_move_delete_linux, find_move_delete_windows
 from machineconfig.utils.source_of_truth import INSTALL_TMP_DIR, INSTALL_VERSION_ROOT
-from machineconfig.utils.installer_utils.installer_abc import check_tool_exists
+from machineconfig.utils.installer_utils.installer_locator_utils import check_tool_exists
 from machineconfig.utils.schemas.installer.installer_types import InstallerData, get_os_name, get_normalized_arch
 
 import platform
@@ -11,6 +11,24 @@ from typing import Optional, Any
 from urllib.parse import urlparse
 
 
+
+def install_deb_package(downloaded: PathExtended) -> None:
+    print(f"📦 Installing .deb package: {downloaded}")
+    assert platform.system() == "Linux"
+    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)
+
+
 class Installer:
     def __init__(self, installer_data: InstallerData):
         self.installer_data: InstallerData = installer_data
@@ -106,9 +124,14 @@ class Installer:
                     runpy.run_path(str(installer_path), run_name=None)["main"](self.installer_data, version=version)
                     version_to_be_installed = str(version)
             elif installer_arch_os.startswith("https://"):  # its a url to be downloaded
-                downloaded_object = PathExtended(installer_arch_os).download(folder=INSTALL_TMP_DIR)
+                # downloaded_object = PathExtended(installer_arch_os).download(folder=INSTALL_TMP_DIR)
+                from machineconfig.scripts.python.helpers_utils.download import download
+                downloaded_object = download(installer_arch_os, output_dir=str(INSTALL_TMP_DIR))
+                if downloaded_object is None:
+                    raise ValueError(f"Failed to download from URL: {installer_arch_os}")
                 # object is either a zip containing a binary or a straight out binary.
-                if downloaded_object.suffix in [".zip", ".tar.gz"]:
+                downloaded_object = PathExtended(downloaded_object)
+                if downloaded_object.suffix in DECOMPRESS_SUPPORTED_FORMATS:
                     downloaded_object = downloaded_object.decompress()
                 if downloaded_object.suffix in [".exe", ""]:  # likely an executable
                     if platform.system() == "Windows":
@@ -131,26 +154,17 @@ class Installer:
                         print(f"🔄 Renaming to correct name: {new_exe_name}")
                         exe.with_name(name=new_exe_name, inplace=True, overwrite=True)
                     version_to_be_installed = "downloaded_binary"
+                elif downloaded_object.suffix in [".deb"]:
+                    install_deb_package(downloaded_object)
+                    version_to_be_installed = "downloaded_deb"
+                else:
+                    raise ValueError(f"Downloaded file is not an executable: {downloaded_object}")
             else:
                 raise NotImplementedError(f"CMD installation method not implemented for: {installer_arch_os}")
         else:
             assert repo_url.startswith("https://github.com/"), f"repoURL must be a GitHub URL, got {repo_url}"
-            downloaded, version_to_be_installed = self.download(version=version)
-            if str(downloaded).endswith(".deb"):
-                print(f"📦 Installing .deb package: {downloaded}")
-                assert platform.system() == "Linux"
-                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)
+            downloaded, version_to_be_installed = self.binary_download(version=version)
+            if str(downloaded).endswith(".deb"): install_deb_package(downloaded)
             else:
                 if platform.system() == "Windows":
                     exe = find_move_delete_windows(downloaded_file_path=downloaded, exe_name=exe_name, delete=True, rename_to=exe_name.replace(".exe", "") + ".exe")
@@ -173,13 +187,13 @@ class Installer:
                     exe.with_name(name=new_exe_name, inplace=True, overwrite=True)
         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 or "unknown", encoding="utf-8")
-    def download(self, version: Optional[str]) -> tuple[PathExtended, str]:
+    def binary_download(self, version: Optional[str]) -> tuple[PathExtended, str]:
         exe_name = self._get_exe_name()
         repo_url = self.installer_data["repoURL"]
         # app_name = self.installer_data["appName"]
         download_link: Optional[str] = None
         version_to_be_installed: Optional[str] = None
-        if "github" not in repo_url or ".zip" in repo_url or ".tar.gz" in repo_url:
+        if "github" not in repo_url or (any(ext in repo_url for ext in DECOMPRESS_SUPPORTED_FORMATS)):
             # Direct download URL
             download_link = repo_url
             version_to_be_installed = "predefined_url"
@@ -202,7 +216,7 @@ class Installer:
         downloaded = PathExtended(download_link).download(folder=INSTALL_TMP_DIR).decompress()
         if downloaded.is_dir() and len(downloaded.search("*", r=True)) == 1:
             only_file_in = next(downloaded.glob("*"))
-            if only_file_in.is_file() and only_file_in.suffix in [".7z", ".zip", ".tar.gz", ".tar"]:  # further decompress
+            if only_file_in.is_file() and only_file_in.suffix in DECOMPRESS_SUPPORTED_FORMATS:  # further decompress
                 downloaded = only_file_in.decompress()
         return downloaded, version_to_be_installed
 

machineconfig/utils/installer_utils/{installer.py → installer_cli.py}

@@ -1,19 +1,20 @@
 """Devops Devapps Install"""
 
 import typer
-from rich.console import Console
-from rich.panel import Panel
-from rich.table import Table
 from typing import Optional, Annotated
 from machineconfig.jobs.installer.package_groups import PACKAGE_GROUP2NAMES
 
-console = Console()
 
 
 def _handle_installer_not_found(search_term: str, all_names: list[str]) -> None:  # type: ignore
     """Handle installer not found with friendly suggestions using fuzzy matching."""
     from difflib import get_close_matches
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
     close_matches = get_close_matches(search_term, all_names, n=5, cutoff=0.4)
+    console = Console()
+
     console.print(f"\n❌ '[red]{search_term}[/red]' was not found.", style="bold")
     if close_matches:
         console.print("🤔 Did you mean one of these?", style="yellow")
@@ -61,6 +62,10 @@ def main(
             return install_clis(clis_names=[x.strip() for x in which.split(",") if x.strip() != ""])
     else:
         if group:
+            from rich.console import Console
+            from rich.table import Table
+            console = Console()
+
             typer.echo("❌ You must provide a group name when using the --group/-g option.")
             res = get_group_name_to_repr()
             console.print("[bold blue]Here are the available groups:[/bold blue]")
@@ -98,16 +103,16 @@ def get_group_name_to_repr() -> dict[str, str]:
 def install_interactively():
     from machineconfig.utils.options import choose_from_options
     from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
-    from machineconfig.utils.installer import get_installers
+    from machineconfig.utils.installer_utils.installer_runner import get_installers
     from machineconfig.utils.installer_utils.installer_class import Installer
+    from rich.console import Console
+    from rich.panel import Panel
+    # from rich.table import Table
     installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=None)
-    installer_options = []
-    for x in installers:
-        installer_options.append(Installer(installer_data=x).get_description())
-
+    installer_options = [Installer(installer_data=x).get_description() for x in installers]
     category_display_to_name = get_group_name_to_repr()
     options = list(category_display_to_name.keys()) + ["─" * 50] + installer_options
-    program_names = choose_from_options(multi=True, msg="Categories are prefixed with 📦", options=options, header="🚀 CHOOSE DEV APP OR CATEGORY", default="📦 termabc", fzf=True)
+    program_names = choose_from_options(multi=True, msg="Categories are prefixed with 📦", options=options, header="🚀 CHOOSE DEV APP OR CATEGORY", fzf=True)
     installation_messages: list[str] = []
     for _an_idx, a_program_name in enumerate(program_names):
         if a_program_name.startswith("─"):  # 50 dashes separator
@@ -122,24 +127,32 @@ def install_interactively():
             status_message = Installer(an_installer_data).install_robust(version=None)  # finish the task - this returns a status message, not a command
             installation_messages.append(status_message)
     if installation_messages:
+        console = Console()
+
         panel = Panel("\n".join([f"[blue]• {message}[/blue]" for message in installation_messages]), title="[bold green]📊 Installation Summary[/bold green]", border_style="green", padding=(1, 2))
         console.print(panel)
 
 
 def install_group(package_group: str):
-    from machineconfig.utils.installer import get_installers, install_bulk
+    from machineconfig.utils.installer_utils.installer_runner import get_installers, install_bulk
     from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
+    from rich.console import Console
+    from rich.panel import Panel
+    # from rich.table import Table
     if package_group in PACKAGE_GROUP2NAMES:
         panel = Panel(f"[bold yellow]Installing programs from category: [green]{package_group}[/green][/bold yellow]", title="[bold blue]📦 Category Installation[/bold blue]", border_style="blue", padding=(1, 2))
+        console = Console()
         console.print(panel)
         installers_ = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=[package_group])
         install_bulk(installers_data=installers_)
         return
-    print(f"❌ ERROR: Unknown package group: {package_group}. Available groups are: {list(PACKAGE_GROUP2NAMES.keys())}")
+    console = Console()
+    console.print(f"❌ ERROR: Unknown package group: {package_group}. Available groups are: {list(PACKAGE_GROUP2NAMES.keys())}")
 def install_clis(clis_names: list[str]):
     from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
-    from machineconfig.utils.installer import get_installers
+    from machineconfig.utils.installer_utils.installer_runner import get_installers
     from machineconfig.utils.installer_utils.installer_class import Installer
+    from rich.console import Console
     total_messages: list[str] = []
     for a_which in clis_names:
         all_installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=None)
@@ -155,6 +168,7 @@ def install_clis(clis_names: list[str]):
         message = Installer(selected_installer).install_robust(version=None)  # finish the task
         total_messages.append(message)
     if total_messages:
+        console = Console()
         console.print("\n[bold green]📊 Installation Results:[/bold green]")
         for a_message in total_messages:
             console.print(f"[blue]• {a_message}[/blue]")
@@ -162,13 +176,13 @@ def install_clis(clis_names: list[str]):
 
 
 def install_if_missing(which: str):
-    from machineconfig.utils.installer_utils.installer_abc import check_tool_exists
+    from machineconfig.utils.installer_utils.installer_locator_utils import check_tool_exists
     exists = check_tool_exists(which)
     if exists:
         print(f"✅ {which} is already installed.")
         return
     print(f"⏳ {which} not found. Installing...")
-    from machineconfig.utils.installer_utils.installer import main
+    from machineconfig.utils.installer_utils.installer_cli import main
     main(which=which, interactive=False)
 
 

machineconfig/utils/{installer.py → installer_utils/installer_runner.py}

@@ -1,6 +1,6 @@
 """package manager"""
 
-from machineconfig.utils.installer_utils.installer_abc import check_if_installed_already
+from machineconfig.utils.installer_utils.installer_locator_utils import check_if_installed_already
 from machineconfig.utils.installer_utils.installer_class import Installer
 from machineconfig.utils.schemas.installer.installer_types import InstallerData, InstallerDataFiles, get_normalized_arch, get_os_name, OPERATING_SYSTEMS, CPU_ARCHITECTURES
 from machineconfig.jobs.installer.package_groups import PACKAGE_GROUP2NAMES
@@ -132,30 +132,6 @@ def install_bulk(installers_data: list[InstallerData], safe: bool = False, jobs:
         print("✅ Version cache cleared")
     if safe:
         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_data)} packages...")
     print("📦 INSTALLING FIRST PACKAGE 📦")
     Installer(installers_data[0]).install(version=None)

machineconfig/utils/options.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from machineconfig.utils.installer_utils.installer_abc import check_tool_exists
+from machineconfig.utils.installer_utils.installer_locator_utils import check_tool_exists
 from rich.text import Text
 from rich.panel import Panel
 from rich.console import Console

machineconfig/utils/path_extended.py

@@ -16,6 +16,7 @@ OPLike: TypeAlias = Union[str, "PathExtended", Path, None]
 PLike: TypeAlias = Union[str, "PathExtended", Path]
 FILE_MODE: TypeAlias = Literal["r", "w", "x", "a"]
 SHUTIL_FORMATS: TypeAlias = Literal["zip", "tar", "gztar", "bztar", "xztar"]
+DECOMPRESS_SUPPORTED_FORMATS = [".tar.gz", ".tgz", ".tar", ".gz", ".tar.bz", ".tbz", ".tar.xz", ".zip", ".7z"]
 
 
 def _is_user_admin() -> bool:
@@ -152,7 +153,6 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
     # ======================================= File Editing / Reading ===================================
     def download(self, folder: OPLike = None, name: Optional[str] = None, allow_redirects: bool = True, timeout: Optional[int] = None, params: Any = None) -> "PathExtended":
         import requests
-
         response = requests.get(self.as_url_str(), allow_redirects=allow_redirects, timeout=timeout, params=params)  # Alternative: from urllib import request; request.urlopen(url).read().decode('utf-8').
         assert response.status_code == 200, f"Download failed with status code {response.status_code}\n{response.text}"
         if name is not None:
@@ -809,7 +809,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             path = self
         else:
             try:
-                path = self.rel2home()
+                path = PathExtended(self.expanduser().absolute().relative_to(Path.home()))
             except ValueError as ve:
                 if strict:
                     raise ve

machineconfig/utils/path_helper.py

@@ -1,4 +1,4 @@
-from machineconfig.utils.path_extended import PathExtended
+# from machineconfig.utils.path_extended import Path
 from machineconfig.utils.source_of_truth import EXCLUDE_DIRS
 from rich.console import Console
 from rich.panel import Panel
@@ -10,8 +10,8 @@ from typing import Optional
 console = Console()
 
 
-def sanitize_path(a_path: str) -> PathExtended:
-    path = PathExtended(a_path)
+def sanitize_path(a_path: str) -> Path:
+    path = Path(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":
@@ -22,13 +22,13 @@ def sanitize_path(a_path: str) -> PathExtended:
         if platform.system() == "Windows":  # path copied from Linux/Mac to Windows
             # For Linux: /home/username, for Mac: /Users/username
             skip_parts = 3 if path.as_posix().startswith("/home") else 3  # Both have 3 parts to skip
-            path = PathExtended.home().joinpath(*path.parts[skip_parts:])
+            path = Path.home().joinpath(*path.parts[skip_parts:])
             assert path.exists(), f"File not found: {path}"
             source_os = "Linux" if path.as_posix().startswith("/home") else "macOS"
             console.print(Panel(f"🔗 PATH MAPPING | {source_os} → Windows: `{a_path}` ➡️ `{path}`", title="Path Mapping", expand=False))
-        elif platform.system() in ["Linux", "Darwin"] and PathExtended.home().as_posix() not in path.as_posix():  # copied between Unix-like systems with different username
+        elif platform.system() in ["Linux", "Darwin"] and Path.home().as_posix() not in path.as_posix():  # copied between Unix-like systems with different username
             skip_parts = 3  # Both /home/username and /Users/username have 3 parts to skip
-            path = PathExtended.home().joinpath(*path.parts[skip_parts:])
+            path = Path.home().joinpath(*path.parts[skip_parts:])
             assert path.exists(), f"File not found: {path}"
             current_os = "Linux" if platform.system() == "Linux" else "macOS"
             source_os = "Linux" if path.as_posix().startswith("/home") else "macOS"
@@ -36,12 +36,12 @@ def sanitize_path(a_path: str) -> PathExtended:
     elif path.as_posix().startswith("C:"):
         if platform.system() in ["Linux", "Darwin"]:  # path copied from Windows to Linux/Mac
             xx = str(a_path).replace("\\\\", "/")
-            path = PathExtended.home().joinpath(*PathExtended(xx).parts[3:])  # exclude C:\\Users\\username
+            path = Path.home().joinpath(*Path(xx).parts[3:])  # exclude C:\\Users\\username
             assert path.exists(), f"File not found: {path}"
             target_os = "Linux" if platform.system() == "Linux" else "macOS"
             console.print(Panel(f"🔗 PATH MAPPING | Windows → {target_os}: `{a_path}` ➡️ `{path}`", title="Path Mapping", expand=False))
-        elif platform.system() == "Windows" and PathExtended.home().as_posix() not in path.as_posix():  # copied from Windows to Windows with different username
-            path = PathExtended.home().joinpath(*path.parts[2:])
+        elif platform.system() == "Windows" and Path.home().as_posix() not in path.as_posix():  # copied from Windows to Windows with different username
+            path = Path.home().joinpath(*path.parts[2:])
             assert path.exists(), f"File not found: {path}"
             console.print(Panel(f"🔗 PATH MAPPING | Windows → Windows: `{a_path}` ➡️ `{path}`", title="Path Mapping", expand=False))
     return path.expanduser().absolute()
@@ -66,12 +66,12 @@ def find_scripts(root: Path, name_substring: str, suffixes: set[str]) -> tuple[l
     return filename_matches, partial_path_matches
 
 
-def match_file_name(sub_string: str, search_root: PathExtended, suffixes: set[str]) -> PathExtended:
+def match_file_name(sub_string: str, search_root: Path, suffixes: set[str]) -> Path:
     search_root_obj = search_root.absolute()
     # assume subscript is filename only, not a sub_path. There is no need to fzf over the paths.
     filename_matches, partial_path_matches = find_scripts(search_root_obj, sub_string, suffixes)
     if len(filename_matches) == 1:
-        return PathExtended(filename_matches[0])
+        return Path(filename_matches[0])
     console.print(Panel(f"Partial filename {search_root_obj} match with case-insensitivity failed. This generated #{len(filename_matches)} results.", title="Search", expand=False))
     if len(filename_matches) < 20:
         print("\n".join([a_potential_match.as_posix() for a_potential_match in filename_matches]))
@@ -80,23 +80,23 @@ def match_file_name(sub_string: str, search_root: PathExtended, suffixes: set[st
         # let's see if avoiding .lower() helps narrowing down to one result
         reduced_scripts = [a_potential_match for a_potential_match in filename_matches if sub_string in a_potential_match.name]
         if len(reduced_scripts) == 1:
-            return PathExtended(reduced_scripts[0])
+            return Path(reduced_scripts[0])
         elif len(reduced_scripts) > 1:
             from machineconfig.utils.options import choose_from_options
             choice = choose_from_options(multi=False, msg="Multiple matches found", options=reduced_scripts, fzf=True)
-            return PathExtended(choice)
+            return Path(choice)
         print(f"Result: This still generated {len(reduced_scripts)} results.")
         if len(reduced_scripts) < 10:
             print("\n".join([a_potential_match.as_posix() for a_potential_match in reduced_scripts]))
 
     console.print(Panel(f"Partial path match with case-insensitivity failed. This generated #{len(partial_path_matches)} results.", title="Search", expand=False))
     if len(partial_path_matches) == 1:
-        return PathExtended(partial_path_matches[0])
+        return Path(partial_path_matches[0])
     elif len(partial_path_matches) > 1:
         print("Try to narrow down partial_path_matches search by case-sensitivity.")
         reduced_scripts = [a_potential_match for a_potential_match in partial_path_matches if sub_string in a_potential_match.as_posix()]
         if len(reduced_scripts) == 1:
-            return PathExtended(reduced_scripts[0])
+            return Path(reduced_scripts[0])
         print(f"Result: This still generated {len(reduced_scripts)} results.")        
 
     try:
@@ -131,21 +131,24 @@ def match_file_name(sub_string: str, search_root: PathExtended, suffixes: set[st
     return search_root_obj.joinpath(res)
 
 
-def search_for_files_of_interest(path_obj: PathExtended, suffixes: set[str]):
-    if path_obj.joinpath(".venv").exists():
-        path_objects = path_obj.search("*", not_in=[".venv"])
-        files: list[PathExtended] = []
-        for a_path_obj in path_objects:
-            files += search_for_files_of_interest(path_obj=a_path_obj, suffixes=suffixes)
-        return files
+def search_for_files_of_interest(path_obj: Path, suffixes: set[str]) -> list[Path]:
     if path_obj.is_file():
         return [path_obj]
-    files: list[PathExtended] = []
-    for a_suffix in suffixes:
-        if a_suffix == ".py":
-            files += path_obj.search(pattern="*.py", r=True, not_in=["__init__.py"])
-        else:
-            files += path_obj.search(pattern=f"*{a_suffix}", r=True)
+    files: list[Path] = []
+    directories_to_visit: list[Path] = [path_obj]
+    while directories_to_visit:
+        current_dir = directories_to_visit.pop()
+        for entry in current_dir.iterdir():
+            if entry.is_dir():
+                if entry.name == ".venv":
+                    continue
+                directories_to_visit.append(entry)
+                continue
+            if entry.suffix not in suffixes:
+                continue
+            if entry.suffix == ".py" and entry.name == "__init__.py":
+                continue
+            files.append(entry)
     return files
 
 
@@ -160,15 +163,15 @@ def get_choice_file(path: str, suffixes: Optional[set[str]]):
         else:
             suffixes = {".py"}
     if not path_obj.exists():
-        print(f"🔍 Searching for file matching `{path}` under `{PathExtended.cwd()}`, but only if suffix matches {suffixes}")
-        choice_file = match_file_name(sub_string=path, search_root=PathExtended.cwd(), suffixes=suffixes)
+        print(f"🔍 Searching for file matching `{path}` under `{Path.cwd()}`, but only if suffix matches {suffixes}")
+        choice_file = match_file_name(sub_string=path, search_root=Path.cwd(), suffixes=suffixes)
     elif path_obj.is_dir():
         print(f"🔍 Searching recursively for Python, PowerShell and Shell scripts in directory `{path_obj}`")
         files = search_for_files_of_interest(path_obj, suffixes=suffixes)
         print(f"🔍 Got #{len(files)} results.")
         from machineconfig.utils.options import choose_from_options
         choice_file = choose_from_options(multi=False, options=files, fzf=True, msg="Choose one option")
-        choice_file = PathExtended(choice_file)
+        choice_file = Path(choice_file)
     else:
         choice_file = path_obj
     return choice_file

machineconfig/utils/ssh.py

@@ -8,7 +8,7 @@ from machineconfig.utils.terminal import Response
 from machineconfig.utils.accessories import pprint, randstr
 from machineconfig.utils.meta import lambda_to_python_script
 UV_RUN_CMD = "$HOME/.local/bin/uv run" if platform.system() != "Windows" else """& "$env:USERPROFILE/.local/bin/uv" run"""
-MACHINECONFIG_VERSION = "machineconfig>=7.58"
+MACHINECONFIG_VERSION = "machineconfig>=7.59"
 DEFAULT_PICKLE_SUBDIR = "tmp_results/tmp_scripts/ssh"
 
 class SSH:

{machineconfig-7.58.dist-info → machineconfig-7.59.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 7.58
+Version: 7.59
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0