Installer Module¶

class InstallerData(TypedDict):
    appName: str                    # Display name (also used for executable lookup)
    doc: str                        # Description shown in interactive mode
    repoURL: str                    # "CMD" or GitHub repository URL
    fileNamePattern: dict[          # Platform-specific installation patterns
        CPU_ARCHITECTURES,          # "amd64" | "arm64"
        dict[
            OPERATING_SYSTEMS,      # "windows" | "linux" | "macos"
            Optional[str]           # Installation pattern or None if unsupported
        ]
    ]

from machineconfig.utils.installer_utils.installer_class import Installer
from machineconfig.utils.schemas.installer.installer_types import InstallerData

installer_data: InstallerData = {
    "appName": "fd",
    "repoURL": "https://github.com/sharkdp/fd",
    "doc": "A simple, fast and user-friendly alternative to find",
    "fileNamePattern": {
        "amd64": {
            "linux": "fd-v{version}-x86_64-unknown-linux-musl.tar.gz",
            "windows": "fd-v{version}-x86_64-pc-windows-msvc.zip",
            "macos": "fd-v{version}-x86_64-apple-darwin.tar.gz"
        },
        "arm64": {
            "linux": "fd-v{version}-aarch64-unknown-linux-musl.tar.gz",
            "macos": "fd-v{version}-aarch64-apple-darwin.tar.gz",
            "windows": None
        }
    }
}

installer = Installer(installer_data)

installer.install(version=None)      # Install latest
installer.install(version="v9.0.0")  # Install specific version

status = installer.install_robust(version=None)
# Returns: "fd updated from v8.7.0 -> v9.0.0"
# Or: "fd, same version: v9.0.0"
# Or: "Failed to install `fd` with error: ..."

extracted_path, version = installer.binary_download(version=None)
# extracted_path: PathExtended to extracted files
# version: Actual version string (e.g., "v9.0.0")

download_url, version = installer.get_github_release(
    repo_url="https://github.com/sharkdp/fd",
    version=None  # or specific version
)

desc = installer.get_description()
# "fd           ✅ A simple, fast and user-friendly alternative to find"

from typing import Optional
from machineconfig.utils.schemas.installer.installer_types import InstallerData

def main(installer_data: InstallerData, version: Optional[str]) -> None:
    """
    Main entry point for custom installation.

    Args:
        installer_data: The installer configuration from installer_data.json
        version: Specific version to install, or None for latest
    """
    # Platform detection
    import platform
    system = platform.system()  # "Windows", "Linux", "Darwin"

    # Installation logic...

# Supported languages for grammar installation
LANGUAGES_SUPPORTED = ["python", "nu", "bash", "lua", "powershell"]

def main(installer_data: InstallerData, version: Optional[str], install_lib: bool = True):
    # Download binary
    downloaded, _version = inst.binary_download(version=version)

    # Install executable
    hx_file.move(folder=target_bin_path, overwrite=True)

    # Install runtime (selectively for supported languages)
    if install_lib:
        for child in runtime.iterdir():
            if child.name == "grammars":
                for lang in LANGUAGES_SUPPORTED:
                    lang_file = child.joinpath(f"{lang}.so")
                    if lang_file.exists():
                        lang_file.copy(folder=target_runtime.joinpath("grammars"))

def find_move_delete_windows(downloaded_file_path, tool_name, delete, rename_to):
    # Finds .exe in downloaded archive
    # Moves to WindowsApps directory
    # Handles renaming if needed

def find_move_delete_linux(downloaded, tool_name, delete, rename_to):
    # Finds binary in extracted archive
    # Sets executable permissions (chmod 777)
    # Uses sudo for /usr/local/bin
    # Moves to installation path

from machineconfig.utils.installer_utils.installer_locator_utils import check_if_installed_already

verdict, current_ver, new_ver = check_if_installed_already(
    exe_name="fd",
    version="v9.0.0",
    use_cache=False
)
# verdict: "✅ Up to date" | "❌ Outdated" | "⚠️ NotInstalled"

from machineconfig.utils.installer_utils.installer_runner import install_bulk, get_installers
from machineconfig.utils.schemas.installer.installer_types import get_os_name, get_normalized_arch

# Get all installers for current platform
installers = get_installers(
    os=get_os_name(),
    arch=get_normalized_arch(),
    which_cats=["termabc"]  # or None for all
)

# Install with parallel processing
install_bulk(
    installers_data=installers,
    safe=False,
    jobs=10,      # Parallel workers
    fresh=False   # Don't clear version cache
)

from machineconfig.jobs.installer.checks.check_installations import main

# Run full scan
main()
# Outputs:
#   - ~/.config/machineconfig/profile/records/{platform}/apps_metadata_report.csv
#   - ~/.config/machineconfig/profile/records/{platform}/apps_engine_results_report.csv

PACKAGES_DEV_UTILS = [
    "devcontainer",
    "rust-analyzer",
    "mytool",  # Add here
]

from typing import Optional
from machineconfig.utils.schemas.installer.installer_types import InstallerData

def main(installer_data: InstallerData, version: Optional[str]) -> None:
    # Custom installation logic
    pass

from machineconfig.utils.installer_utils.installer_runner import install_bulk
install_bulk(installers, fresh=True)  # Clears cache

# Main CLI entry point
from machineconfig.utils.installer_utils.installer_cli import main_installer_cli

# Install specific packages
from machineconfig.utils.installer_utils.installer_cli import install_clis
install_clis(clis_names=["btop", "fd", "bat"])

# Install package group
from machineconfig.utils.installer_utils.installer_cli import install_group
install_group(package_group="termabc")

# Interactive installation
from machineconfig.utils.installer_utils.installer_cli import install_interactively
install_interactively()

# Install if not present
from machineconfig.utils.installer_utils.installer_cli import install_if_missing
install_if_missing("git")  # Returns True if available after call

# Check if tool exists
from machineconfig.utils.installer_utils.installer_locator_utils import check_tool_exists
exists = check_tool_exists("fd")

# Get all installers for platform
from machineconfig.utils.installer_utils.installer_runner import get_installers
installers = get_installers(os="linux", arch="amd64", which_cats=None)

# Get installed CLI apps
from machineconfig.utils.installer_utils.installer_runner import get_installed_cli_apps
apps = get_installed_cli_apps()

# Install from GitHub URL
from machineconfig.utils.installer_utils.install_from_url import install_from_github_url
install_from_github_url("https://github.com/user/repo")

# Install from binary URL
from machineconfig.utils.installer_utils.install_from_url import install_from_binary_url
install_from_binary_url("https://example.com/tool.tar.gz")

from machineconfig.utils.schemas.installer.installer_types import (
    InstallerData,           # Package definition
    InstallerDataFiles,      # installer_data.json structure
    CPU_ARCHITECTURES,       # "amd64" | "arm64"
    OPERATING_SYSTEMS,       # "windows" | "linux" | "macos"
    get_os_name,             # Get current OS
    get_normalized_arch,     # Get current architecture
)