machineconfig 7.64__py3-none-any.whl → 7.79__py3-none-any.whl

machineconfig/utils/installer_utils/install_from_url.py

@@ -0,0 +1,180 @@
+
+
+import platform
+from urllib.parse import urlparse
+
+import typer
+from typing import Optional, TypeAlias, cast
+
+from machineconfig.utils.installer_utils.installer_class import install_deb_package
+from machineconfig.utils.installer_utils.installer_locator_utils import find_move_delete_linux, find_move_delete_windows
+from machineconfig.utils.path_extended import DECOMPRESS_SUPPORTED_FORMATS, PathExtended
+from machineconfig.utils.source_of_truth import INSTALL_TMP_DIR, INSTALL_VERSION_ROOT
+
+SUPPORTED_GITHUB_HOSTS = {"github.com", "www.github.com"}
+
+GitHubAsset: TypeAlias = dict[str, object]
+GitHubRelease: TypeAlias = dict[str, object]
+
+
+def _extract_repo_name(github_url: str) -> str:
+    parsed = urlparse(github_url)
+    parts = [part for part in parsed.path.strip("/").split("/") if part]
+    if len(parts) < 2:
+        return ""
+    owner, repo = parts[0], parts[1]
+    if repo == "":
+        return ""
+    return f"{owner}/{repo}"
+
+
+def _fetch_latest_release(repo_name: str) -> Optional[GitHubRelease]:
+    import json
+    import requests
+    try:
+        response = requests.get(f"https://api.github.com/repos/{repo_name}/releases/latest", timeout=30)
+    except requests.RequestException:
+        return None
+    if response.status_code != 200:
+        return None
+    try:
+        data = response.json()
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(data, dict):
+        return None
+    return cast(GitHubRelease, data)
+
+
+def _format_size(size_bytes: int) -> str:
+    if size_bytes <= 0:
+        return "0 B"
+    units = ("B", "KiB", "MiB", "GiB", "TiB")
+    value = float(size_bytes)
+    index = 0
+    while value >= 1024 and index < len(units) - 1:
+        value /= 1024
+        index += 1
+    return f"{value:.1f} {units[index]}"
+
+
+def _derive_tool_name(repo_name: str, asset_name: str) -> str:
+    repo_segment = repo_name.split("/", maxsplit=1)[-1]
+    repo_clean = repo_segment.replace(".git", "").lower()
+    repo_filtered = "".join(char for char in repo_clean if char.isalnum())
+    if repo_filtered:
+        return repo_filtered
+    asset_clean = asset_name.lower()
+    asset_filtered = "".join(char for char in asset_clean if char.isalnum())
+    if asset_filtered:
+        return asset_filtered
+    return "githubapp"
+
+
+def install_from_github_url(github_url: str) -> None:
+    from machineconfig.utils.options import choose_from_options
+    from rich.console import Console
+    from rich.panel import Panel
+
+    console = Console()
+    repo_name = _extract_repo_name(github_url)
+    if repo_name == "":
+        console.print(Panel(f"Invalid GitHub URL: {github_url}", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    console.print(Panel(f"Fetching latest release for [green]{repo_name}[/green]", title="🌐 GitHub", border_style="blue"))
+    release_raw = _fetch_latest_release(repo_name)
+    if not release_raw:
+        console.print(Panel("No releases available for this repository.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    release = release_raw
+    assets_value = release.get("assets", [])
+    assets: list[GitHubAsset] = []
+    if isinstance(assets_value, list):
+        for asset in assets_value:
+            if isinstance(asset, dict):
+                typed_asset: GitHubAsset = {}
+                name_value = asset.get("name")
+                url_value = asset.get("browser_download_url")
+                size_value = asset.get("size")
+                content_value = asset.get("content_type")
+                if isinstance(name_value, str):
+                    typed_asset["name"] = name_value
+                if isinstance(url_value, str):
+                    typed_asset["browser_download_url"] = url_value
+                if isinstance(size_value, int):
+                    typed_asset["size"] = size_value
+                if isinstance(content_value, str):
+                    typed_asset["content_type"] = content_value
+                assets.append(typed_asset)
+    if not assets:
+        console.print(Panel("No downloadable assets found in the latest release.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    binary_assets = assets
+    selection_pool = binary_assets if binary_assets else assets
+    if not selection_pool:
+        console.print(Panel("No assets available for installation.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    options_map: dict[str, GitHubAsset] = {}
+    for asset in selection_pool:
+        name = asset.get("name")
+        download_url = asset.get("browser_download_url")
+        if not isinstance(name, str) or not isinstance(download_url, str) or name == "" or download_url == "":
+            continue
+        size_value = asset.get("size")
+        size = size_value if isinstance(size_value, int) else 0
+        label = f"{name} [{_format_size(size)}]"
+        options_map[label] = asset
+    if not options_map:
+        console.print(Panel("Release assets lack download URLs.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    selection_label = choose_from_options(options=list(options_map.keys()), msg="Select a release asset", multi=False, header="📦 GitHub Release Assets", fzf=True)
+    selected_asset = options_map[selection_label]
+    download_url_value = selected_asset.get("browser_download_url")
+    asset_name_value = selected_asset.get("name")
+    if not isinstance(download_url_value, str) or download_url_value == "":
+        console.print(Panel("Selected asset lacks a download URL.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    asset_name = asset_name_value if isinstance(asset_name_value, str) else "github_binary"
+    version_value = release.get("tag_name")
+    version = version_value if isinstance(version_value, str) and version_value != "" else "latest"
+    console.print(Panel(f"Downloading [cyan]{asset_name}[/cyan]", title="⬇️ Download", border_style="magenta"))
+    archive_path = PathExtended(download_url_value).download(folder=INSTALL_TMP_DIR)
+    extracted_path = archive_path
+    if extracted_path.suffix in DECOMPRESS_SUPPORTED_FORMATS:
+        extracted_path = archive_path.decompress()
+        archive_path.delete(sure=True)
+        if extracted_path.is_dir():
+            nested_items = list(extracted_path.glob("*"))
+            if len(nested_items) == 1:
+                nested_path = PathExtended(nested_items[0])
+                if nested_path.suffix in DECOMPRESS_SUPPORTED_FORMATS:
+                    extracted_path = nested_path.decompress()
+                    nested_path.delete(sure=True)
+    if extracted_path.suffix == ".deb":
+        install_deb_package(extracted_path)
+        tool_name_deb = _derive_tool_name(repo_name, asset_name)
+        INSTALL_VERSION_ROOT.joinpath(tool_name_deb).parent.mkdir(parents=True, exist_ok=True)
+        INSTALL_VERSION_ROOT.joinpath(tool_name_deb).write_text(version, encoding="utf-8")
+        console.print(Panel(f"Installed Debian package for [green]{tool_name_deb}[/green]", title="✅ Complete", border_style="green"))
+        return
+    system_name = platform.system()
+    tool_name = _derive_tool_name(repo_name, asset_name)
+    rename_target = f"{tool_name}.exe" if system_name == "Windows" else tool_name
+    try:
+        if system_name == "Windows":
+            installed_path = find_move_delete_windows(downloaded_file_path=extracted_path, exe_name=tool_name, delete=True, rename_to=rename_target)
+        elif system_name in {"Linux", "Darwin"}:
+            installed_path = find_move_delete_linux(downloaded=extracted_path, tool_name=tool_name, delete=True, rename_to=rename_target)
+        else:
+            console.print(Panel(f"Unsupported operating system: {system_name}", title="❌ Error", border_style="red"))
+            raise typer.Exit(1)
+    except IndexError:
+        if system_name == "Windows":
+            installed_path = find_move_delete_windows(downloaded_file_path=extracted_path, exe_name=None, delete=True, rename_to=rename_target)
+        elif system_name in {"Linux", "Darwin"}:
+            installed_path = find_move_delete_linux(downloaded=extracted_path, tool_name="", delete=True, rename_to=rename_target)
+        else:
+            raise
+    INSTALL_VERSION_ROOT.joinpath(tool_name).parent.mkdir(parents=True, exist_ok=True)
+    INSTALL_VERSION_ROOT.joinpath(tool_name).write_text(version, encoding="utf-8")
+    console.print(Panel(f"Installed [green]{tool_name}[/green] to {installed_path}\nVersion: {version}", title="✅ Complete", border_style="green"))

machineconfig/utils/installer_utils/installer_class.py

@@ -12,18 +12,22 @@ from urllib.parse import urlparse
 
 
 def install_deb_package(downloaded: PathExtended) -> None:
+    from rich import print as rprint
+    from rich.panel import Panel
     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:
+        from rich.console import Group
         desc = "Installing .deb"
-        print(f"❌ {desc} failed")
+        sub_panels = []
         if result.stdout:
-            print(f"STDOUT: {result.stdout}")
+            sub_panels.append(Panel(result.stdout, title="STDOUT", style="blue"))
         if result.stderr:
-            print(f"STDERR: {result.stderr}")
-        print(f"Return code: {result.returncode}")
+            sub_panels.append(Panel(result.stderr, title="STDERR", style="red"))
+        group_content = Group(f"❌ {desc} failed\nReturn code: {result.returncode}", *sub_panels)
+        rprint(Panel(group_content, title=desc, style="red"))
     print("🗑️  Cleaning up .deb package...")
     downloaded.delete(sure=True)
 
@@ -79,19 +83,23 @@ class Installer:
         version_to_be_installed: str = "unknown"  # Initialize to ensure it's always bound
         if repo_url == "CMD":
             if any(pm in installer_arch_os for pm in ["npm ", "pip ", "winget ", "brew ", "curl "]):
+                from rich import print as rprint
+                from rich.panel import Panel
+                from rich.console import Group
                 package_manager = installer_arch_os.split(" ", maxsplit=1)[0]
                 print(f"📦 Using package manager: {installer_arch_os}")
                 desc = package_manager + " installation"
                 version_to_be_installed = package_manager + "Latest"
-                result = subprocess.run(installer_arch_os, shell=True, capture_output=True, text=False)
-                success = result.returncode == 0 and result.stderr == "".encode()
+                result = subprocess.run(installer_arch_os, shell=True, capture_output=False, text=True)
+                success = result.returncode == 0 and result.stderr == ""
                 if not success:
-                    print(f"❌ {desc} failed")
+                    sub_panels = []
                     if result.stdout:
-                        print(f"STDOUT: {result.stdout}")
+                        sub_panels.append(Panel(result.stdout, title="STDOUT", style="blue"))
                     if result.stderr:
-                        print(f"STDERR: {result.stderr}")
-                    print(f"Return code: {result.returncode}")
+                        sub_panels.append(Panel(result.stderr, title="STDERR", style="red"))
+                    group_content = Group(f"❌ {desc} failed\nReturn code: {result.returncode}", *sub_panels)
+                    rprint(Panel(group_content, title=desc, style="red"))
             elif installer_arch_os.endswith((".sh", ".py", ".ps1")):
                 import machineconfig.jobs.installer as module
                 from pathlib import Path

machineconfig/utils/installer_utils/installer_cli.py

@@ -1,11 +1,13 @@
 """Devops Devapps Install"""
 
 import typer
-from typing import Optional, Annotated
+from typing import Annotated, Optional
 from machineconfig.jobs.installer.package_groups import PACKAGE_GROUP2NAMES
+from machineconfig.utils.installer_utils.installer_class import Installer
 
 
-def main(
+
+def main_installer_cli(
     which: Annotated[Optional[str], typer.Argument(..., help="Comma-separated list of program/groups names to install (if --group flag is set).")] = None,
     group: Annotated[bool, typer.Option(..., "--group", "-g", help="Treat 'which' as a group name. A group is bundle of apps.")] = False,
     interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Interactive selection of programs to install.")] = False,
@@ -142,17 +144,21 @@ def install_clis(clis_names: list[str]):
     from machineconfig.utils.installer_utils.installer_runner import get_installers
     from machineconfig.utils.installer_utils.installer_class import Installer
     from rich.console import Console
+    all_installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=None)
     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)
+    for a_cli_name in clis_names:
+        if "github.com" in a_cli_name.lower():
+            from machineconfig.utils.installer_utils.install_from_url import install_from_github_url
+            install_from_github_url(github_url=a_cli_name)
+            continue
         selected_installer = None
         for installer in all_installers:
             app_name = installer["appName"]
-            if app_name.lower() == a_which.lower():
+            if app_name.lower() == a_cli_name.lower():
                 selected_installer = installer
                 break
         if selected_installer is None:
-            _handle_installer_not_found(a_which, all_names=[inst["appName"] for inst in all_installers])
+            _handle_installer_not_found(a_cli_name, all_names=[inst["appName"] for inst in all_installers])
             return None
         message = Installer(selected_installer).install_robust(version=None)  # finish the task
         total_messages.append(message)
@@ -169,13 +175,12 @@ def install_if_missing(which: str):
         print(f"✅ {which} is already installed.")
         return
     print(f"⏳ {which} not found. Installing...")
-    from machineconfig.utils.installer_utils.installer_cli import main
-    main(which=which, interactive=False)
+    from machineconfig.utils.installer_utils.installer_cli import main_installer_cli
+    main_installer_cli(which=which, interactive=False)
 
 
 if __name__ == "__main__":
     from machineconfig.utils.schemas.installer.installer_types import InstallerData
     from machineconfig.utils.installer_utils.installer_class import Installer
-
     _ = InstallerData, Installer
     pass

machineconfig/utils/links.py

@@ -164,7 +164,7 @@ def symlink_map(config_file_default_path: PathExtended, self_managed_config_file
                 else:
                     # Files are different, use on_conflict strategy
                     import subprocess
-                    command = f"""delta --side-by-side "{config_file_default_path}" "{self_managed_config_file_path}" """
+                    command = f"""delta  --paging never --side-by-side "{config_file_default_path}" "{self_managed_config_file_path}" """
                     try:
                         console.print(Panel(f"🆘 CONFLICT DETECTED | Showing diff between {config_file_default_path} and {self_managed_config_file_path}", title="Conflict Detected", expand=False))
                         subprocess.run(command, shell=True, check=True)
@@ -293,7 +293,7 @@ def copy_map(config_file_default_path: PathExtended, self_managed_config_file_pa
                 else:
                     # Files are different, use on_conflict strategy
                     import subprocess
-                    command = f"""delta --side-by-side "{config_file_default_path}" "{self_managed_config_file_path}" """
+                    command = f"""delta  --paging never --side-by-side "{config_file_default_path}" "{self_managed_config_file_path}" """
                     try:
                         console.print(Panel(f"🆘 CONFLICT DETECTED | Showing diff between {config_file_default_path} and {self_managed_config_file_path}", title="Conflict Detected", expand=False))
                         subprocess.run(command, shell=True, check=True)

machineconfig/utils/meta.py

@@ -29,7 +29,8 @@ except (ImportError, ModuleNotFoundError) as ex:
     return txt
 
 
-def lambda_to_python_script(lmb: Callable[[], Any], in_global: bool, import_module: bool) -> str:
+def lambda_to_python_script(lmb: Callable[[], Any],
+            in_global: bool, import_module: bool) -> str:
     """
     caveats: always use keyword arguments in the lambda call for best results.
     return statement not allowed in the wrapped function (otherwise it can be put in the global space)
@@ -250,7 +251,6 @@ if __name__ == "__main__":
     import_code_robust = "<import_code_robust>"
     res = lambda_to_python_script(
             lambda: print_code(code=import_code_robust, lexer="python", desc="import as module code"),
-            # in_global=True, import_module=False
             in_global=True, import_module=False
         )
     print(res)

machineconfig/utils/options.py

@@ -14,10 +14,10 @@ from typing import Optional, Union, Iterable, overload, Literal, cast
 
 
 @overload
-def choose_from_options[T](msg: str, options: Iterable[T], multi: Literal[False], custom_input: bool = False, header: str = "", tail: str = "", prompt: str = "", default: Optional[T] = None, fzf: bool = False) -> T: ...
+def choose_from_options[T](options: Iterable[T], msg: str, multi: Literal[False], custom_input: bool = False, header: str = "", tail: str = "", prompt: str = "", default: Optional[T] = None, fzf: bool = False) -> T: ...
 @overload
-def choose_from_options[T](msg: str, options: Iterable[T], multi: Literal[True], custom_input: bool = True, header: str = "", tail: str = "", prompt: str = "", default: Optional[T] = None, fzf: bool = False, ) -> list[T]: ...
-def choose_from_options[T](msg: str, options: Iterable[T], multi: bool, custom_input: bool = True, header: str = "", tail: str = "", prompt: str = "", default: Optional[T] = None, fzf: bool = False, ) -> Union[T, list[T]]:
+def choose_from_options[T](options: Iterable[T], msg: str, multi: Literal[True], custom_input: bool = True, header: str = "", tail: str = "", prompt: str = "", default: Optional[T] = None, fzf: bool = False, ) -> list[T]: ...
+def choose_from_options[T](options: Iterable[T], msg: str, multi: bool, custom_input: bool = True, header: str = "", tail: str = "", prompt: str = "", default: Optional[T] = None, fzf: bool = False, ) -> Union[T, list[T]]:
     # TODO: replace with https://github.com/tmbo/questionary
     # # also see https://github.com/charmbracelet/gum
     options_strings: list[str] = [str(x) for x in options]

machineconfig/utils/path_extended.py

@@ -711,7 +711,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
                 :return: pathlib.Path pointing to the destination directory where contents were extracted
                 :raises: FileNotFoundError if archive does not exist; py7zr.Bad7zFile or other error if extraction fails
                 """
-                import py7zr
+                import py7zr  # type: ignore
                 import tempfile
                 from pathlib import Path
                 archive_path_obj = Path(archive_path)

machineconfig/utils/path_helper.py

@@ -1,4 +1,3 @@
-# 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