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

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  --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)

machineconfig/utils/options_tv.py

@@ -0,0 +1,119 @@
+
+
+#!/usr/bin/env python3
+import base64
+import pathlib
+import subprocess
+import tempfile
+import os
+
+
+def main(options_to_preview_mapping: dict[str, str]) -> str | None:
+    keys = list(options_to_preview_mapping.keys())
+    if not keys:
+        return None
+    with tempfile.TemporaryDirectory(prefix="tv_channel_") as tmpdir:
+        tempdir = pathlib.Path(tmpdir)
+        entries: list[str] = []
+        index_map: dict[int, str] = {}
+        preview_map_path = tempdir / "previews.tsv"
+        preview_rows: list[str] = []
+        for idx, key in enumerate(keys):
+            display_key = key.replace("\t", "    ").replace("\n", " ")
+            entries.append(f"{idx}\t{display_key}")
+            index_map[idx] = key
+            encoded_preview = base64.b64encode(options_to_preview_mapping[key].encode("utf-8")).decode("ascii")
+            preview_rows.append(f"{idx}\t{encoded_preview}")
+        preview_map_path.write_text("\n".join(preview_rows), encoding="utf-8")
+        entries_path = tempdir / "entries.tsv"
+        entries_path.write_text("\n".join(entries), encoding="utf-8")
+        preview_script = tempdir / "preview.sh"
+        preview_script.write_text(
+            """#!/usr/bin/env bash
+set -euo pipefail
+
+idx="$1"
+script_dir="$(cd -- "$(dirname -- "$0")" && pwd)"
+previews_file="${script_dir}/previews.tsv"
+
+if [[ ! -f "${previews_file}" ]]; then
+    exit 0
+fi
+
+encoded_preview="$(awk -F '\t' -v idx="${idx}" '($1==idx){print $2; exit}' "${previews_file}" || true)"
+
+if [[ -z "${encoded_preview}" ]]; then
+    exit 0
+fi
+
+preview_content="$(printf '%s' "${encoded_preview}" | base64 --decode)"
+
+if command -v bat >/dev/null 2>&1; then
+    printf '%s' "${preview_content}" | glow -
+elif command -v bat >/dev/null 2>&1; then
+    printf '%s' "${preview_content}" | bat --language=markdown --color=always --style=plain --paging=never
+elif command -v glow >/dev/null 2>&1; then
+    printf '%s' "${preview_content}" | glow -
+else
+    printf '%s' "${preview_content}"
+fi
+""",
+            encoding="utf-8"
+        )
+        preview_script.chmod(0o755)
+        channel_config = f"""[metadata]
+name = "temp_options"
+description = "Temporary channel for selecting options"
+
+[source]
+command = "cat '{entries_path}'"
+display = "{{split:\\t:1}}"
+output = "{{split:\\t:0}}"
+
+[preview]
+command = "{preview_script} {{split:\\t:0}}"
+
+[ui.preview_panel]
+size = 50
+"""
+        channel_path = tempdir / "temp_options.toml"
+        channel_path.write_text(channel_config, encoding="utf-8")
+        env = os.environ.copy()
+        tv_config_dir = pathlib.Path.home() / ".config" / "television"
+        if not tv_config_dir.exists():
+            tv_config_dir = pathlib.Path(os.getenv("XDG_CONFIG_HOME", str(pathlib.Path.home() / ".config"))) / "television"
+        cable_dir = tv_config_dir / "cable"
+        cable_dir.mkdir(parents=True, exist_ok=True)
+        temp_channel_link = cable_dir / "temp_options.toml"
+        if temp_channel_link.exists() or temp_channel_link.is_symlink():
+            temp_channel_link.unlink()
+        temp_channel_link.symlink_to(channel_path)
+        output_file = tempdir / "selection.txt"
+        try:
+            result = subprocess.run(["tv", "temp_options"], check=False, stdout=output_file.open("w"), text=True, env=env)
+        finally:
+            if temp_channel_link.exists() or temp_channel_link.is_symlink():
+                temp_channel_link.unlink()
+        if result.returncode not in (0, 130):
+            raise SystemExit(result.returncode)
+        if result.returncode == 130:
+            return None
+        if not output_file.exists():
+            return None
+        selected = output_file.read_text().strip()
+        if not selected:
+            return None
+        try:
+            index = int(selected)
+        except ValueError:
+            return None
+        return index_map.get(index)
+
+
+if __name__ == "__main__":
+    demo_mapping = {
+        "Option 1": "# Option 1\nThis is the preview for option 1.",
+        "Option 2": "# Option 2\nThis is the preview for option 2.",
+        "Option 3": "# Option 3\nThis is the preview for option 3."
+    }
+    main(demo_mapping)