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

machineconfig/utils/meta.py

@@ -1,166 +1,256 @@
 """Metaprogramming utilities for analyzing and serializing Python functions."""
 
-import ast
-import inspect
-import textwrap
-from types import FunctionType, ModuleType
+from collections.abc import Callable
 from typing import Any
 
 
-def function_to_script(func: FunctionType, call_with_args: tuple[Any, ...] | None = None, call_with_kwargs: dict[str, Any] | None = None) -> str:
-    """Convert a function to a standalone executable Python script.
-    
-    This function analyzes a given function and generates a complete Python script
-    that includes all necessary imports, global variables, the function definition,
-    and optionally a function call.
+def get_import_module_string(py_file: str) -> str:
+    from machineconfig.scripts.python.helpers_fire_command.file_wrangler import get_import_module_code
+    from machineconfig.utils.accessories import get_repo_root
+    from pathlib import Path
+    repo_root = get_repo_root(Path(py_file))
+    import_line = get_import_module_code(py_file)
+    if repo_root is not None:
+        repo_root_add = f"""sys.path.append(r'{repo_root}')"""
+    else:
+        repo_root_add = ""
+    txt: str = f"""
+try:
+    {import_line}
+except (ImportError, ModuleNotFoundError) as ex:
+    print(fr"❌ Failed to import `{py_file}` as a module: {{ex}} ")
+    print(fr"⚠️ Attempting import with ad-hoc `$PATH` manipulation. DO NOT pickle any objects in this session as correct deserialization cannot be guaranteed.")
+    import sys
+    sys.path.append(r'{Path(py_file).parent}')
+    {repo_root_add}
+    from {Path(py_file).stem} import *
+    print(fr"✅ Successfully imported `{py_file}`")
+"""
+    return txt
+
+
+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)
+    type hint in kwargs has nothing that is not built in, e.g. Optional will not work as it requires an import.
+
+    Given a no-arg lambda like `lambda: func(a=var1, b=var2)`,
+    return a string containing the full function definition of `func`
+    but with the defaults for the parameters provided in the call replaced
+    by the *actual* values (repr) taken from the lambda's globals.
+
+    All imports are local to this function.
     
     Args:
-        func: The function to convert to a script
-        call_with_args: Optional tuple of positional arguments to call the function with
-        call_with_kwargs: Optional dict of keyword arguments to call the function with
-    
-    Returns:
-        A complete Python script as a string that can be executed independently
-    
-    Raises:
-        ValueError: If the function cannot be inspected or analyzed
+        lmb: A lambda function with no arguments
+        in_global: If True, return kwargs as global variable assignments followed by dedented body.
+                   If False, return the full function definition with updated defaults.
+        import_module: When True, prepend module import bootstrap code for the function's source file.
     """
-    if not callable(func) or not hasattr(func, '__code__'):
-        raise ValueError(f"Expected a function, got {type(func)}")
-    
-    call_with_args = call_with_args or ()
-    call_with_kwargs = call_with_kwargs or {}
-    
-    imports = _extract_imports(func)
-    globals_needed = _extract_globals(func)
-    source_code = _get_function_source(func)
-    call_statement = _generate_call_statement(func, call_with_args, call_with_kwargs)
-    
-    script_parts: list[str] = []
-    
-    if imports:
-        script_parts.append(imports)
-        script_parts.append("")
-    
-    if globals_needed:
-        script_parts.append(globals_needed)
-        script_parts.append("")
-    
-    script_parts.append(source_code)
-    script_parts.append("")
-    
-    if call_statement:
-        script_parts.append("")
-        script_parts.append("if __name__ == '__main__':")
-        script_parts.append(f"    {call_statement}")
-    
-    return "\n".join(script_parts)
+    # local imports
+    import inspect as _inspect
+    import ast as _ast
+    import textwrap as _textwrap
+    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)
 
-def _get_function_source(func: FunctionType) -> str:
-    """Extract the source code of a function."""
-    try:
-        source = inspect.getsource(func)
-        return textwrap.dedent(source)
-    except (OSError, TypeError) as e:
-        raise ValueError(f"Cannot get source code for function {func.__name__}: {e}") from e
+    # sanity checks
+    if not (callable(lmb) and isinstance(lmb, _types.LambdaType)):
+        raise TypeError("Expected a lambda function object")
+
+    src = _inspect.getsource(lmb)
+    src = _textwrap.dedent(src)
+    tree = _ast.parse(src)
 
+    # find first Lambda node
+    lambda_node = None
+    for n in _ast.walk(tree):
+        if isinstance(n, _ast.Lambda):
+            lambda_node = n
+            break
+    if lambda_node is None:
+        raise ValueError("Could not find a lambda expression in source")
 
-def _extract_imports(func: FunctionType) -> str:
-    """Extract all import statements needed by the function."""
-    import_statements: set[str] = set()
+    body = lambda_node.body
+    if not isinstance(body, _ast.Call):
+        raise ValueError("Lambda body is not a call expression")
+
+    globals_dict = getattr(lmb, "__globals__", {})
     
-    source = _get_function_source(func)
-    func_globals = func.__globals__
+    # Also capture closure variables from the lambda
+    closure_dict: dict[str, Any] = {}
+    if lmb.__closure__:
+        code_obj = lmb.__code__
+        freevars = code_obj.co_freevars
+        for i, var_name in enumerate(freevars):
+            closure_dict[var_name] = lmb.__closure__[i].cell_contents
     
+    # Merge globals and closures (closures take precedence for shadowing)
+    eval_namespace = {**globals_dict, **closure_dict}
+
+    # resolve the function object being called
     try:
-        tree = ast.parse(source)
-    except SyntaxError as e:
-        raise ValueError(f"Failed to parse function source: {e}") from e
-    
-    used_names: set[str] = set()
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Name):
-            used_names.add(node.id)
-        elif isinstance(node, ast.Attribute):
-            if isinstance(node.value, ast.Name):
-                used_names.add(node.value.id)
-    
-    for name in used_names:
-        if name in func_globals:
-            obj = func_globals[name]
-            
-            if isinstance(obj, ModuleType):
-                module_name = obj.__name__
-                if name == module_name.split('.')[-1]:
-                    import_statements.add(f"import {module_name}")
-                else:
-                    import_statements.add(f"import {module_name} as {name}")
-            
-            elif hasattr(obj, '__module__') and obj.__module__ != '__main__':
-                try:
-                    module_name = obj.__module__
-                    obj_name = obj.__name__ if hasattr(obj, '__name__') else name
-                    
-                    if module_name and module_name != 'builtins':
-                        if obj_name == name:
-                            import_statements.add(f"from {module_name} import {obj_name}")
-                        else:
-                            import_statements.add(f"from {module_name} import {obj_name} as {name}")
-                except AttributeError:
-                    pass
-    
-    return "\n".join(sorted(import_statements))
+        func_ref_src = _ast.unparse(body.func)
+    except AttributeError:
+        func_ref_src = _ast.get_source_segment(src, body.func) or ""
+    try:
+        func_obj = eval(func_ref_src, eval_namespace)
+    except Exception as e:
+        raise RuntimeError(f"Could not resolve function reference '{func_ref_src}': {e}")
 
+    if not callable(func_obj):
+        raise TypeError("Resolved object is not callable")
 
-def _extract_globals(func: FunctionType) -> str:
-    """Extract global variables needed by the function."""
-    global_assignments: list[str] = []
-    
-    source = _get_function_source(func)
-    func_globals = func.__globals__
-    
+    func_name = getattr(func_obj, "__name__", "<unknown>")
+
+    import_prefix: str = ""
+    if import_module:
+        module_file = _inspect.getsourcefile(func_obj)
+        module_path_candidate: str = module_file if module_file is not None else _inspect.getfile(func_obj)
+        import_prefix = get_import_module_string(str(_Path(module_path_candidate)))
+
+    # Evaluate each keyword argument value in the lambda's globals to get real Python objects
+    call_kwargs: dict[str, Any] = {}
+    for kw in body.keywords:
+        if kw.arg is None:
+            # **kwargs in call — evaluate to dict and merge
+            try:
+                val = eval(compile(_ast.Expression(kw.value), "<lambda_eval>", "eval"), eval_namespace)
+                if isinstance(val, dict):
+                    call_kwargs.update(val)
+                else:
+                    raise ValueError("Keyword expansion did not evaluate to a dict")
+            except Exception as e:
+                raise RuntimeError(f"Failed to evaluate **kwargs expression: {e}")
+        else:
+            try:
+                val = eval(compile(_ast.Expression(kw.value), "<lambda_eval>", "eval"), eval_namespace)
+                call_kwargs[kw.arg] = val
+            except Exception as e:
+                raise RuntimeError(f"Failed to evaluate value for kw '{kw.arg}': {e}")
+
+    # Try to get original source and dedent it for body extraction
     try:
-        tree = ast.parse(source)
-    except SyntaxError as e:
-        raise ValueError(f"Failed to parse function source: {e}") from e
-    
-    used_names: set[str] = set()
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Name):
-            used_names.add(node.id)
-        elif isinstance(node, ast.Attribute):
-            if isinstance(node.value, ast.Name):
-                used_names.add(node.value.id)
-    
-    for name in used_names:
-        if name in func_globals:
-            obj = func_globals[name]
+        orig_src = _inspect.getsource(func_obj)
+        ded = _textwrap.dedent(orig_src)
+        lines = ded.splitlines()
+        def_index = None
+        for i, ln in enumerate(lines):
+            if ln.lstrip().startswith(f"def {func_name}("):
+                def_index = i
+                break
+        if def_index is None:
+            body_lines = ded.splitlines()
+        else:
+            signature_end_index = None
+            for i in range(def_index, len(lines)):
+                line_no_comment = lines[i].split("#", 1)[0].rstrip()
+                if line_no_comment.endswith(":"):
+                    signature_end_index = i
+                    break
+            if signature_end_index is None:
+                body_lines = lines[def_index + 1 :]
+            else:
+                body_lines = lines[signature_end_index + 1 :]
+        # ensure we have a body, otherwise use pass
+        if not any(line.strip() for line in body_lines):
+            body_text = "    pass\n"
+        else:
+            joined_body = "\n".join(body_lines)
+            if not joined_body.endswith("\n"):
+                joined_body = f"{joined_body}\n"
+            body_text = joined_body
+    except (OSError, IOError, TypeError):
+        body_text = "    pass\n"
+
+    # Build a replaced signature using inspect.signature
+    sig = _inspect.signature(func_obj)
+    new_params: list[_inspect.Parameter] = []
+    for name, param in sig.parameters.items():
+        # If the call provided a value for this parameter, replace default
+        if name in call_kwargs:
+            new_default = call_kwargs[name]
+        else:
+            new_default = param.default
+
+        normalized_annotation = _stringify_annotation(param.annotation)
+
+        if new_default is _inspect.Parameter.empty:
+            new_param = _inspect.Parameter(name, param.kind, annotation=normalized_annotation)
+        else:
+            new_param = _inspect.Parameter(
+                name, param.kind, default=new_default, annotation=normalized_annotation
+            )
+        new_params.append(new_param)
+
+    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:
+        global_assignments: list[str] = []
+        for name, param in sig.parameters.items():
+            # Get the value from call_kwargs if provided, else use original default
+            if name in call_kwargs:
+                value = call_kwargs[name]
+            elif param.default is not _inspect.Parameter.empty:
+                value = param.default
+            else:
+                # No value provided and no default - skip this parameter
+                continue
             
-            if not isinstance(obj, (ModuleType, FunctionType, type)):
-                if not (hasattr(obj, '__module__') and hasattr(obj, '__name__')):
-                    try:
-                        repr_str = repr(obj)
-                        if len(repr_str) < 1000 and '\n' not in repr_str:
-                            global_assignments.append(f"{name} = {repr_str}")
-                    except Exception:
-                        global_assignments.append(f"# Warning: Could not serialize global variable '{name}'")
-    
-    return "\n".join(global_assignments)
+            # Build type annotation string if available
+            if param.annotation is not _inspect.Parameter.empty:
+                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)}")
+        
+        # Dedent the body text to remove function indentation
+        dedented_body = _textwrap.dedent(body_text).rstrip()
+        
+        # Combine global assignments and body
+        if global_assignments:
+            result_parts: list[str] = ["\n".join(global_assignments), "", dedented_body]
+            result_text = "\n".join(result_parts)
+        else:
+            result_text = dedented_body
+    else:
+        header = f"def {func_name}{new_sig}:\n"
+        result_text = header + body_text
 
+    if in_global:
+        lines = result_text.splitlines()
+        if lines[-1].startswith("return "):
+            lines[-1] = lines[-1].replace("return ", "# return ", 1)
+            result_text = "\n".join(lines)
 
-def _generate_call_statement(func: FunctionType, args: tuple[Any, ...], kwargs: dict[str, Any]) -> str:
-    """Generate a function call statement with the given arguments."""
-    if not args and not kwargs:
-        return f"{func.__name__}()"
-    
-    arg_parts: list[str] = []
-    
-    for arg in args:
-        arg_parts.append(repr(arg))
-    
-    for key, value in kwargs.items():
-        arg_parts.append(f"{key}={repr(value)}")
-    
-    args_str = ", ".join(arg_parts)
-    return f"{func.__name__}({args_str})"
+    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__":
+    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,38 +1,66 @@
+
 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
+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, 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, " ")}" ')  # --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]
+                if isinstance(list(options)[0], str): return cast(T, choice_one_string)
                 choice_idx = options_strings.index(choice_one_string)
                 return list(options)[choice_idx]
             except IndexError as ie:
                 print(f"❌ Error: {options=}, {choice_string_multi=}")
                 print(f"🔍 Available choices: {choice_string_multi}")
                 raise ie
+        if isinstance(list(options)[0], str):
+            return cast(list[T], choice_string_multi)
         choice_idx_s = [options_strings.index(x) for x in choice_string_multi]
         return [list(options)[x] for x in choice_idx_s]
     else:
@@ -55,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
@@ -73,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
@@ -84,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]
@@ -103,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
 
@@ -121,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)