machineconfig 7.50__py3-none-any.whl → 8.14__py3-none-any.whl

machineconfig/utils/installer_utils/installer_helper.py

@@ -0,0 +1,129 @@
+from machineconfig.jobs.installer.package_groups import PACKAGE_GROUP2NAMES
+from machineconfig.utils.schemas.installer.installer_types import InstallerData
+from pathlib import Path
+from machineconfig.utils.path_extended import DECOMPRESS_SUPPORTED_FORMATS, PathExtended
+from machineconfig.utils.source_of_truth import INSTALL_TMP_DIR
+
+
+def get_group_name_to_repr() -> dict[str, str]:
+    # Build category options and maintain a mapping from display text to actual category name
+    category_display_to_name: dict[str, str] = {}
+    for group_name, group_values in PACKAGE_GROUP2NAMES.items():
+        display = f"📦 {group_name:<20}" + "   --   " + f"{'|'.join(group_values):<60}"
+        category_display_to_name[display] = group_name
+    return category_display_to_name
+
+
+def handle_installer_not_found(search_term: str, app_apps: list[InstallerData]) -> 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
+    all_names = sorted([inst["appName"] for inst in app_apps])
+    name_to_doc = {inst["appName"]: inst["doc"] for inst in app_apps}
+    all_descriptions = {f"{inst['appName']}: {inst['doc']}": inst["appName"] for inst in app_apps}
+
+    close_name_matches = get_close_matches(search_term, all_names, n=5, cutoff=0.4)
+    close_description_matches = get_close_matches(search_term, list(all_descriptions.keys()), n=5, cutoff=0.4)
+
+    search_lower = search_term.lower()
+    substring_matches = [
+        inst["appName"]
+        for inst in app_apps
+        if search_lower in inst["appName"].lower() or search_lower in inst["doc"].lower()
+    ]
+
+    ordered_matches: list[str] = list(
+        dict.fromkeys(
+            close_name_matches
+            + [all_descriptions[desc] for desc in close_description_matches]
+            + substring_matches
+        )
+    )
+    top_matches = ordered_matches[:10]
+    console = Console()
+
+    console.print(f"\n❌ '[red]{search_term}[/red]' was not found.", style="bold")
+    if top_matches:
+        console.print("🤔 Did you mean one of these?", style="yellow")
+        table = Table(show_header=True, header_style="bold", box=None, pad_edge=False)
+        table.add_column("#", justify="right", width=3)
+        table.add_column("Installer", style="green")
+        table.add_column("Description", style="dim", overflow="fold")
+        for i, match in enumerate(top_matches, 1):
+            table.add_row(f"[cyan]{i}[/cyan]", match, name_to_doc.get(match, ""))
+        console.print(table)
+    else:
+        console.print("📋 Here are some available options:", style="blue")
+        # Show first 10 installers as examples
+        if len(all_names) > 10:
+            sample_names = all_names[:10]
+        else:
+            sample_names = all_names
+        table = Table(show_header=True, header_style="bold", box=None, pad_edge=False)
+        table.add_column("#", justify="right", width=3)
+        table.add_column("Installer", style="green")
+        table.add_column("Description", style="dim", overflow="fold")
+        for i, name in enumerate(sample_names, 1):
+            table.add_row(f"[cyan]{i}[/cyan]", name, name_to_doc.get(name, ""))
+        console.print(table)
+        if len(all_names) > 10:
+            console.print(f"   [dim]... and {len(all_names) - 10} more[/dim]")
+
+    panel = Panel(f"[bold blue]💡 Use 'ia' to interactively browse all available installers.[/bold blue]\n[bold blue]💡 Use one of the categories: {list(PACKAGE_GROUP2NAMES.keys())}[/bold blue]", title="[yellow]Helpful Tips[/yellow]", border_style="yellow")
+    console.print(panel)
+
+
+def install_deb_package(downloaded: Path) -> None:
+    from rich import print as rprint
+    from rich.panel import Panel
+    print(f"📦 Installing .deb package: {downloaded}")
+    import platform
+    import subprocess
+    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"
+        sub_panels = []
+        if result.stdout:
+            sub_panels.append(Panel(result.stdout, title="STDOUT", style="blue"))
+        if result.stderr:
+            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...")
+    if downloaded.is_file():
+        downloaded.unlink(missing_ok=True)
+    elif downloaded.is_dir():
+        import shutil
+        shutil.rmtree(downloaded, ignore_errors=True)
+
+
+def download_and_prepare(download_url: str) -> PathExtended:
+    # archive_path = PathExtended(download_url).download(folder=INSTALL_TMP_DIR)
+    from machineconfig.scripts.python.helpers_utils.download import download
+    downloaded_object = download(download_url, output_dir=str(INSTALL_TMP_DIR))
+    if downloaded_object is None:
+        raise ValueError(f"Failed to download from URL: {download_url}")
+    archive_path = PathExtended(downloaded_object)
+    extracted_path = archive_path
+    if extracted_path.is_file() and any(ext in archive_path.suffixes for ext in DECOMPRESS_SUPPORTED_FORMATS):
+        extracted_path = archive_path.decompress()
+        # print(f"Decompressed {archive_path} to {extracted_path}")
+        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.is_file() and any(ex in nested_path.suffixes for ex in DECOMPRESS_SUPPORTED_FORMATS):
+                    extracted_path = nested_path.decompress()
+                    nested_path.delete(sure=True)
+    elif extracted_path.is_dir() and len(extracted_path.search("*", r=True)) == 1:
+        only_file_in = next(extracted_path.glob("*"))
+        if only_file_in.is_file() and any(ext in str(only_file_in) for ext in DECOMPRESS_SUPPORTED_FORMATS):  # further decompress
+            extracted_path = only_file_in.decompress()
+            only_file_in.delete(sure=True)
+    return extracted_path

machineconfig/utils/installer_utils/{installer_abc.py → installer_locator_utils.py}

@@ -7,23 +7,28 @@ import subprocess
 import platform
 
 
-def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optional[str] = None, delete: bool = True, rename_to: Optional[str] = None):
-    print("🔍 PROCESSING WINDOWS EXECUTABLE 🔍")
-    if exe_name is not None and ".exe" in exe_name:
-        exe_name = exe_name.replace(".exe", "")
+def find_move_delete_windows(downloaded_file_path: PathExtended, tool_name: Optional[str], delete: bool, rename_to: Optional[str]):
+    # print("🔍 PROCESSING WINDOWS EXECUTABLE 🔍")
+    # if exe_name is not None and len(exe_name.split("+")) > 1:
+    #     last_result = None
+    #     for a_binary in [x.strip() for x in exe_name.split("+") if x.strip() != ""]:
+    #         last_result = find_move_delete_windows(downloaded_file_path=downloaded_file_path, exe_name=a_binary, delete=delete, rename_to=rename_to)
+    #     return last_result
+    if tool_name is not None and ".exe" in tool_name:
+        tool_name = tool_name.replace(".exe", "")
     if downloaded_file_path.is_file():
         exe = downloaded_file_path
         print(f"📄 Found direct executable file: {exe}")
     else:
         print(f"🔎 Searching for executable in: {downloaded_file_path}")
-        if exe_name is None:
+        if tool_name is None:
             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)
+            tmp = downloaded_file_path.search(f"{tool_name}.exe", r=True)
             if len(tmp) == 1:
                 exe = tmp[0]
-                print(f"✅ Found exact match for {exe_name}.exe: {exe}")
+                print(f"✅ Found exact match for {tool_name}.exe: {exe}")
             else:
                 search_res = downloaded_file_path.search("*.exe", r=True)
                 if len(search_res) == 0:
@@ -52,7 +57,13 @@ def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optio
     return exe_new_location
 
 
-def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Optional[bool] = True, rename_to: Optional[str] = None):
+def find_move_delete_linux(downloaded: PathExtended, tool_name: Optional[str], delete: bool, rename_to: Optional[str]):
+    # if len(tool_name.split("+")) > 1:
+    #     last_result = None
+    #     for a_binary in [x.strip() for x in tool_name.split("+") if x.strip() != ""]:
+    #         last_result = find_move_delete_linux(downloaded=downloaded, tool_name=a_binary, delete=False, rename_to=rename_to)
+    #     return last_result
+
     print("🔍 PROCESSING LINUX EXECUTABLE 🔍")
     if downloaded.is_file():
         exe = downloaded
@@ -64,16 +75,24 @@ def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Opt
             exe = res[0]
             print(f"✅ Found match for pattern '*{tool_name}*': {exe}")
         else:
-            exe_search_res = downloaded.search(tool_name, folders=False, r=True)
-            if len(exe_search_res) == 0:
-                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[0]
-                print(f"✅ Found exact match for '{tool_name}': {exe}")
-            else:
-                exe = max(exe_search_res, key=lambda x: x.size("kb"))
+            if tool_name is None:  # no tool name provided, get the largest executable
+                search_res = downloaded.search("*", folders=False, files=True, r=True)
+                if len(search_res) == 0:
+                    print(f"❌ ERROR: No search results in `{downloaded}`")
+                    raise IndexError(f"No executable found in {downloaded}")
+                exe = max(search_res, key=lambda x: x.size("kb"))
                 print(f"✅ Selected largest executable ({exe.size('kb')} KB): {exe}")
+            else:
+                exe_search_res = downloaded.search(tool_name, folders=False, r=True)
+                if len(exe_search_res) == 0:
+                    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[0]
+                    print(f"✅ Found exact match for '{tool_name}': {exe}")
+                else:
+                    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:
         print(f"🏷️  Renaming '{exe.name}' to '{rename_to}'")
@@ -191,71 +210,3 @@ def check_if_installed_already(exe_name: str, version: Optional[str], use_cache:
     return ("⚠️ NotInstalled", "None", version or "unknown")
 
 
-def parse_apps_installer_linux(txt: str) -> dict[str, tuple[str, str]]:
-    """Parse Linux shell installation scripts into logical chunks.
-    
-    Splits scripts by # --GROUP:<name>:<description> comment signatures into a dictionary
-    mapping block names to (description, shell script content) tuples.
-    
-    Returns:
-        dict[str, tuple[str, str]]: Dictionary mapping block/section names to (description, installation_script) tuples
-    """
-    chunks = txt.split('# --GROUP:')
-    res: dict[str, tuple[str, str]] = {}
-    
-    for chunk in chunks[1:]:  # Skip first empty chunk before first group
-        lines = chunk.split('\n')
-        # First line contains the group name and description in format "NAME:DESCRIPTION"
-        group_line = lines[0].strip()
-        
-        # Extract group name and description
-        if ':' in group_line:
-            parts = group_line.split(':', 1)  # Split only on first colon
-            group_name = parts[0].strip()
-            group_description = parts[1].strip() if len(parts) > 1 else ""
-        else:
-            group_name = group_line
-            group_description = ""
-        
-        # Rest is the content
-        content = '\n'.join(lines[1:]).strip()
-        
-        if group_name and content:
-            res[group_name] = (group_description, content)
-    
-    return res
-
-
-def parse_apps_installer_windows(txt: str) -> dict[str, tuple[str, str]]:
-    """Parse Windows PowerShell installation scripts into logical chunks.
-    
-    Splits scripts by # --GROUP:<name>:<description> comment signatures into a dictionary
-    mapping block names to (description, PowerShell script content) tuples.
-    
-    Returns:
-        dict[str, tuple[str, str]]: Dictionary mapping block/section names to (description, installation_script) tuples
-    """
-    chunks = txt.split('# --GROUP:')
-    res: dict[str, tuple[str, str]] = {}
-    
-    for chunk in chunks[1:]:  # Skip first chunk before first group
-        lines = chunk.split('\n')
-        # First line contains the group name and description in format "NAME:DESCRIPTION"
-        group_line = lines[0].strip()
-        
-        # Extract group name and description
-        if ':' in group_line:
-            parts = group_line.split(':', 1)  # Split only on first colon
-            group_name = parts[0].strip()
-            group_description = parts[1].strip() if len(parts) > 1 else ""
-        else:
-            group_name = group_line
-            group_description = ""
-        
-        # Rest is the content
-        content = '\n'.join(lines[1:]).strip()
-        
-        if group_name and content:
-            res[group_name] = (group_description, content)
-    
-    return res

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

@@ -1,9 +1,9 @@
 """package manager"""
 
-from machineconfig.utils.installer_utils.installer_abc import check_if_installed_already, parse_apps_installer_linux, parse_apps_installer_windows
+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_GROUPS, PACKAGE_GROUP2NAMES
+from machineconfig.jobs.installer.package_groups import PACKAGE_GROUP2NAMES
 from machineconfig.utils.path_extended import PathExtended
 from machineconfig.utils.source_of_truth import INSTALL_VERSION_ROOT, LINUX_INSTALL_PATH
 from machineconfig.utils.io import read_json
@@ -18,7 +18,7 @@ from joblib import Parallel, delayed
 def check_latest():
     console = Console()  # Added console initialization
     console.print(Panel("🔍  CHECKING FOR LATEST VERSIONS", title="Status", expand=False))  # Replaced print with Panel
-    installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["ESSENTIAL"])
+    installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["termabc"])
     installers_github = []
     for inst__ in installers:
         app_name = inst__["appName"]
@@ -91,8 +91,12 @@ def get_installed_cli_apps():
     return apps
 
 
-def get_installers(os: OPERATING_SYSTEMS, arch: CPU_ARCHITECTURES, which_cats: Optional[list[PACKAGE_GROUPS]]) -> list[InstallerData]:
-    res_all = get_all_installer_data_files()
+def get_installers(os: OPERATING_SYSTEMS, arch: CPU_ARCHITECTURES, which_cats: Optional[list[str]]) -> list[InstallerData]:
+    import machineconfig.jobs.installer as module
+    from pathlib import Path
+    res_raw: InstallerDataFiles = read_json(Path(module.__file__).parent.joinpath("installer_data.json"))
+    res_all: list[InstallerData] = res_raw["installers"]
+
     acceptable_apps_names: list[str] | None = None
     if which_cats is not None:
         acceptable_apps_names = []
@@ -105,40 +109,17 @@ def get_installers(os: OPERATING_SYSTEMS, arch: CPU_ARCHITECTURES, which_cats: O
         if acceptable_apps_names is not None:
             if installer_data["appName"] not in acceptable_apps_names:
                 continue
-        if installer_data["fileNamePattern"][arch][os] is None:
-            continue
+        try:
+            if installer_data["fileNamePattern"][arch][os] is None:
+                continue
+        except KeyError as ke:
+            print(f"❌ ERROR: Missing key in installer data: {ke}")
+            print(f"Installer data: {installer_data}")
+            raise KeyError(f"Missing key in installer data: {ke}")
         all_installers.append(installer_data)
     return all_installers
 
 
-def get_all_installer_data_files() -> list[InstallerData]:
-    import machineconfig.jobs.installer as module
-    from pathlib import Path
-    res_raw: InstallerDataFiles = read_json(Path(module.__file__).parent.joinpath("installer_data.json"))
-    res_final: list[InstallerData] = res_raw["installers"]
-    return res_final
-
-
-def dynamically_extract_installers_system_groups_from_scripts():
-    res_final: list[InstallerData] = []
-    from platform import system
-    if system() == "Windows":
-        from machineconfig.setup_windows import APPS
-        options_system = parse_apps_installer_windows(APPS.read_text(encoding="utf-8"))
-    elif system() == "Linux":
-        from machineconfig.setup_linux import APPS
-        options_system = parse_apps_installer_linux(APPS.read_text(encoding="utf-8"))
-    elif system() == "Darwin":
-        from machineconfig.setup_mac import APPS
-        options_system = parse_apps_installer_linux(APPS.read_text(encoding="utf-8"))
-    else:
-        raise NotImplementedError(f"❌ System {system()} not supported")
-    os_name = get_os_name()
-    for group_name, (docs, script) in options_system.items():
-        item: InstallerData = {"appName": group_name, "doc": docs, "repoURL": "CMD", "fileNamePattern": {"amd64": {os_name: script}, "arm64": {os_name: script}}}
-        res_final.append(item)
-    return res_final
-
 
 def install_bulk(installers_data: list[InstallerData], safe: bool = False, jobs: int = 10, fresh: bool = False):
     print("🚀 BULK INSTALLATION PROCESS 🚀")
@@ -148,30 +129,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/io.py

@@ -1,4 +1,3 @@
-from __future__ import annotations
 
 from typing import Any, Union, Optional, Mapping
 from pathlib import Path

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)
@@ -55,6 +56,16 @@ def lambda_to_python_script(lmb: Callable[[], Any], in_global: bool, import_modu
     import types as _types
     from pathlib import Path as _Path
 
+    def _stringify_annotation(annotation: Any) -> Any:
+        if annotation is _inspect.Signature.empty or annotation is _inspect.Parameter.empty:
+            return annotation
+        if isinstance(annotation, str):
+            return annotation
+        try:
+            return _inspect.formatannotation(annotation)
+        except Exception:
+            return str(annotation)
+
     # sanity checks
     if not (callable(lmb) and isinstance(lmb, _types.LambdaType)):
         raise TypeError("Expected a lambda function object")
@@ -174,16 +185,18 @@ def lambda_to_python_script(lmb: Callable[[], Any], in_global: bool, import_modu
         else:
             new_default = param.default
 
-        # Recreate the Parameter (keeping annotation and kind)
+        normalized_annotation = _stringify_annotation(param.annotation)
+
         if new_default is _inspect.Parameter.empty:
-            new_param = _inspect.Parameter(name, param.kind, annotation=param.annotation)
+            new_param = _inspect.Parameter(name, param.kind, annotation=normalized_annotation)
         else:
             new_param = _inspect.Parameter(
-                name, param.kind, default=new_default, annotation=param.annotation
+                name, param.kind, default=new_default, annotation=normalized_annotation
             )
         new_params.append(new_param)
 
-    new_sig = _inspect.Signature(parameters=new_params, return_annotation=sig.return_annotation)
+    return_annotation = _stringify_annotation(sig.return_annotation)
+    new_sig = _inspect.Signature(parameters=new_params, return_annotation=return_annotation)
 
     # If in_global mode, return kwargs as global assignments + dedented body
     if in_global:
@@ -200,15 +213,11 @@ def lambda_to_python_script(lmb: Callable[[], Any], in_global: bool, import_modu
             
             # Build type annotation string if available
             if param.annotation is not _inspect.Parameter.empty:
-                # Try to get a nice string representation of the annotation
-                try:
-                    if hasattr(param.annotation, "__name__"):
-                        type_str = param.annotation.__name__
-                    else:
-                        type_str = str(param.annotation)
-                except Exception:
-                    type_str = str(param.annotation)
-                global_assignments.append(f"{name}: {type_str} = {repr(value)}")
+                annotation_literal = _stringify_annotation(param.annotation)
+                if isinstance(annotation_literal, str):
+                    global_assignments.append(f"{name}: {repr(annotation_literal)} = {repr(value)}")
+                else:
+                    global_assignments.append(f"{name} = {repr(value)}")
             else:
                 global_assignments.append(f"{name} = {repr(value)}")
         
@@ -233,10 +242,15 @@ def lambda_to_python_script(lmb: Callable[[], Any], in_global: bool, import_modu
 
     if "Optional" in result_text or "Any" in result_text or "Union" in result_text or "Literal" in result_text:
         result_text = "from typing import Optional, Any, Union, Literal\n\n" + result_text
-
     if import_prefix:
         result_text = f"{import_prefix}{result_text}"
     return result_text
 
 if __name__ == "__main__":
-    pass
+    from machineconfig.utils.code import print_code
+    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
+        )
+    print(res)

machineconfig/utils/options.py

@@ -1,36 +1,54 @@
+
 from pathlib import Path
-from machineconfig.utils.installer_utils.installer_abc import check_tool_exists
 from rich.text import Text
 from rich.panel import Panel
 from rich.console import Console
 import subprocess
 from typing import Optional, Union, Iterable, overload, Literal, cast
 
-
-# def strip_ansi_codes(text: str) -> str:
-#     """Remove ANSI color codes from text."""
-#     import re
-#     return re.sub(r'\x1b\[[0-9;]*[a-zA-Z]', '', text)
-
-
 @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, tv: 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, tv: 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, tv: 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]
     default_string = str(default) if default is not None else None
     console = Console()
-    fzf_exists = check_tool_exists("fzf")
-    # print("\n" * 10, f"{fzf=}, {fzf_exists=}", "\n" * 10)
-    if fzf and fzf_exists:
-        from pyfzf.pyfzf import FzfPrompt
-        fzf_prompt = FzfPrompt()
-        nl = "\n"
-        choice_string_multi: list[str] = fzf_prompt.prompt(choices=options_strings, fzf_options=("--multi" if multi else "") + f' --prompt "{prompt.replace(nl, " ")}" --ansi')  # --border-label={msg.replace(nl, ' ')}")
-        # --border=rounded doens't work on older versions of fzf installed at Ubuntu 20.04
+    from machineconfig.utils.installer_utils.installer_locator_utils import check_tool_exists
+    # from machineconfig.utils.installer_utils.installer_cli import check_tool_exists
+    # print("ch1")
+    if tv and check_tool_exists("tv"):
+        # from pyfzf.pyfzf import FzfPrompt
+        # fzf_prompt = FzfPrompt()
+        # nl = "\n"
+        # choice_string_multi: list[str] = fzf_prompt.prompt(choices=options_strings, fzf_options=("--multi" if multi else "") + f' --prompt "{prompt.replace(nl, " ")}" --ansi')  # --border-label={msg.replace(nl, ' ')}")
+        # print("ch2")
+        from machineconfig.utils.accessories import randstr
+        options_txt_path = Path.home().joinpath("tmp_results/tmp_files/choices_" + randstr(6) + ".txt")
+        options_txt_path.parent.mkdir(parents=True, exist_ok=True)
+        options_txt_path.write_text("\n".join(options_strings), encoding="utf-8")
+
+        # Run `tv` interactively so the user can make selections. We redirect tv's
+        # stdout to a temporary output file so we can read the chosen lines after
+        # the interactive session completes. Do not capture_output or redirect
+        # stdin/stderr here so `tv` stays attached to the terminal.
+        tv_out_path = options_txt_path.with_name(options_txt_path.stem + "_out.txt")
+        tv_cmd = f"""cat {options_txt_path} | tv  --preview-command "bat -n --color=always '{{}}'" --preview-size 30 --ansi true --source-output "{{strip_ansi}}" > {tv_out_path} """
+        res = subprocess.run(tv_cmd, shell=True)
+    
+        # If tv returned a non-zero code and there is no output file, treat it as an error.
+        if res.returncode != 0 and not tv_out_path.exists():
+            raise RuntimeError(f"Got error running tv command: {tv_cmd}\nreturncode: {res.returncode}")
+
+        # Read selections (if any) from the output file created by tv.
+        out_text = tv_out_path.read_text(encoding="utf-8") if tv_out_path.exists() else ""
+        choice_string_multi = [x for x in out_text.splitlines() if x.strip() != ""]
+
+        # Cleanup temporary files
+        options_txt_path.unlink(missing_ok=True)
+        tv_out_path.unlink(missing_ok=True)
         if not multi:
             try:
                 choice_one_string = choice_string_multi[0]
@@ -65,7 +83,7 @@ def choose_from_options[T](msg: str, options: Iterable[T], multi: bool, custom_i
         if choice_string == "":
             if default_string is None:
                 console.print(Panel("🧨 Default option not available!", title="Error", expand=False))
-                return choose_from_options(msg=msg, options=options, header=header, tail=tail, prompt=prompt, default=default, fzf=fzf, multi=multi, custom_input=custom_input)
+                return choose_from_options(msg=msg, options=options, header=header, tail=tail, prompt=prompt, default=default, tv=tv, multi=multi, custom_input=custom_input)
             choice_idx = options_strings.index(default_string)
             assert default is not None, "🧨 Default option not available!"
             choice_one: T = default
@@ -83,7 +101,7 @@ def choose_from_options[T](msg: str, options: Iterable[T], multi: bool, custom_i
                     _ = ie
                     # raise ValueError(f"Unknown choice. {choice_string}") from ie
                     console.print(Panel(f"❓ Unknown choice: '{choice_string}'", title="Error", expand=False))
-                    return choose_from_options(msg=msg, options=options, header=header, tail=tail, prompt=prompt, default=default, fzf=fzf, multi=multi, custom_input=custom_input)
+                    return choose_from_options(msg=msg, options=options, header=header, tail=tail, prompt=prompt, default=default, tv=tv, multi=multi, custom_input=custom_input)
             except (TypeError, ValueError) as te:  # int(choice_string) failed due to # either the number is invalid, or the input is custom.
                 if choice_string in options_strings:  # string input
                     choice_idx = options_strings.index(choice_one)  # type: ignore
@@ -94,7 +112,7 @@ def choose_from_options[T](msg: str, options: Iterable[T], multi: bool, custom_i
                     _ = te
                     # raise ValueError(f"Unknown choice. {choice_string}") from te
                     console.print(Panel(f"❓ Unknown choice: '{choice_string}'", title="Error", expand=False))
-                    return choose_from_options(msg=msg, options=options, header=header, tail=tail, prompt=prompt, default=default, fzf=fzf, multi=multi, custom_input=custom_input)
+                    return choose_from_options(msg=msg, options=options, header=header, tail=tail, prompt=prompt, default=default, tv=tv, multi=multi, custom_input=custom_input)
         console.print(Panel(f"✅ Selected option {choice_idx}: {choice_one}", title="Selected", expand=False))
         if multi:
             return [choice_one]
@@ -113,7 +131,7 @@ def choose_cloud_interactively() -> str:
         raise ValueError(f"Got {tmp} from rclone listremotes")
     if len(remotes) == 0:
         raise RuntimeError("You don't have remotes. Configure your rclone first to get cloud services access.")
-    cloud: str = choose_from_options(msg="WHICH CLOUD?", multi=False, options=list(remotes), default=remotes[0], fzf=True)
+    cloud: str = choose_from_options(msg="WHICH CLOUD?", multi=False, options=list(remotes), default=remotes[0], tv=True)
     console.print(Panel(f"✅ SELECTED CLOUD | {cloud}", border_style="bold blue", expand=False))
     return cloud
 
@@ -131,4 +149,4 @@ def choose_ssh_host(multi: Literal[False]) -> str: ...
 @overload
 def choose_ssh_host(multi: Literal[True]) -> list[str]: ...
 def choose_ssh_host(multi: bool):
-    return choose_from_options(msg="", options=get_ssh_hosts(), multi=multi, fzf=True)
+    return choose_from_options(msg="", options=get_ssh_hosts(), multi=multi, tv=True)