machineconfig 6.82__py3-none-any.whl → 8.51__py3-none-any.whl

machineconfig/scripts/python/helpers/helpers_devops/run_script.py

@@ -0,0 +1,197 @@
+
+
+"""run python/shell scripts from pre-defined directorys, or, run command/file in the machineconfig environment
+
+Recursively Searched Predefined Directories:
+
+
+* 'private' : $HOME/dotfiles/scripts
+
+* 'public'  : $HOME/.config/machineconfig/scripts
+
+* 'library' : $MACHINECONFIG_LIBRARY_ROOT/jobs/scripts
+
+* 'dynamic' : fetched from GitHub repository on the fly (relies on latest commit, rather than the version currently installed)
+
+* 'custom'  : custom directories from comma separated entry 'scripts' under 'general' section @ ~/dotfiles/machineconfig/defaults.ini
+
+"""
+
+
+import typer
+from typing import Annotated, Optional, Literal
+
+
+def run_py_script(ctx: typer.Context,
+                  name: Annotated[str, typer.Argument(help="Name of script to run, e.g., 'a' for a.py, or command to execute")] = "",
+                  where: Annotated[Literal["all", "a", "private", "p", "public", "b", "library", "l", "dynamic", "d", "custom", "c"], typer.Option("--where", "-w", help="Where to look for the script")] = "all",
+                  interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Interactive selection of scripts to run")] = False,
+                  command: Annotated[Optional[bool], typer.Option(..., "--command", "-c", help="Run as command")] = False,
+                  list_scripts: Annotated[bool, typer.Option(..., "--list", "-l", help="List available scripts in all locations")] = False,
+                ) -> None:
+    if command:
+        exec(name)
+        return
+
+    from pathlib import Path
+    if list_scripts:
+        from machineconfig.scripts.python.helpers.helpers_search.script_help import list_available_scripts
+        list_available_scripts(where=where)
+        return
+
+    if not interactive and not name:
+        typer.echo("❌ ERROR: You must provide a script name or use --interactive option to select a script.")
+        raise typer.Exit(code=1)
+    target_file: Optional[Path] = None
+
+    if where in ["dynamic", "d"]:
+        # src/machineconfig/jobs/scripts/python_scripts/a.py
+        if "." in name: resolved_names: list[str] = [name]
+        else: resolved_names = [f"{name}{a_suffix}" for a_suffix in [".py", ".sh", "", ".ps1", ".bat", ".cmd"]]
+        urls = [f"""https://raw.githubusercontent.com/thisismygitrepo/machineconfig/refs/heads/main/src/machineconfig/jobs/scripts_dynamic/{a_resolved_name}""" for a_resolved_name in resolved_names]
+        for a_url in urls:
+            try:
+                print(f"Fetching temporary script from {a_url} ...")
+                import requests
+                response = requests.get(a_url)
+                if response.status_code != 200:
+                    print(f"❌ ERROR: Could not fetch script '{name}.py' from repository. Status Code: {response.status_code}")
+                    raise RuntimeError(f"Could not fetch script '{name}.py' from repository.")
+                script_content = response.text
+                target_file = Path.home().joinpath("tmp_results", "tmp_scripts", "python", f"{name}.py")
+                target_file.parent.mkdir(parents=True, exist_ok=True)
+                target_file.write_text(script_content, encoding="utf-8")
+            except Exception as _e:
+                pass
+
+
+    if target_file is None and Path(name).is_file():
+        if name.endswith(".py"):
+            import machineconfig
+            import subprocess
+            import sys
+            subprocess.run([sys.executable, name], cwd=machineconfig.__path__[0])
+            return
+        else:
+            if Path(name).suffix in [".sh", ".ps1", ".bat", ".cmd", ""]:
+                target_file = Path(name)
+            else:
+                print(f"❌ Error: File '{name}' is not a recognized script type. Supported types are {'.py', '.sh', '.ps1', '.bat', '.cmd', ''}.")
+                raise typer.Exit(code=1)
+
+    from machineconfig.utils.source_of_truth import CONFIG_ROOT, LIBRARY_ROOT, DEFAULTS_PATH
+    private_root = Path.home().joinpath("dotfiles/scripts")  # local directory
+    public_root = CONFIG_ROOT.joinpath("scripts")  # local machineconfig directory
+    library_root = LIBRARY_ROOT.joinpath("jobs", "scripts")
+
+    def get_custom_roots() -> list[Path]:
+        custom_roots: list[Path] = []
+        if DEFAULTS_PATH.is_file():
+            from configparser import ConfigParser
+            config = ConfigParser()
+            config.read(DEFAULTS_PATH)
+            if config.has_section("general") and config.has_option("general", "scripts"):
+                custom_dirs = config.get("general", "scripts").split(",")
+                for custom_dir in custom_dirs:
+                    custom_path = Path(custom_dir.strip()).expanduser().resolve()
+                    if custom_path.is_dir():
+                        custom_roots.append(custom_path)
+        return custom_roots
+
+    roots: list[Path] = []
+    match where:
+        case "all" | "a":
+            roots = [private_root, public_root, library_root] + get_custom_roots()
+        case "private" | "p":
+            roots = [private_root]
+        case "public" | "b":
+            roots = [public_root]
+        case "library" | "l":
+            roots = [library_root]
+        case "dynamic" | "d":
+            roots = []
+        case "custom" | "c":
+            roots = get_custom_roots()
+
+    suffixes: list[str]
+    if "." in name:
+        suffixes = [""]
+    else:
+        import platform
+        if platform.system() == "Windows":
+            suffixes = [".py", ".bat", ".cmd", ".ps1"]
+        elif platform.system() == "Darwin" or platform.system() == "Linux":
+            suffixes = [""]  # files without suffix could be shell scripts, and that already cover files with .sh suffix without duplications
+        else:
+            suffixes = [".py"]
+
+    # Finding target file
+    potential_matches: list[Path] = []
+    if target_file is None:
+        for a_root in roots:
+            for a_suffix in suffixes:
+                if a_root.joinpath(f"{name}{a_suffix}").is_file():
+                    target_file = a_root.joinpath(f"{name}{a_suffix}")
+                    break  # perfect match
+                potential_matches += [a_file for a_file in a_root.rglob(f"*{name}*{a_suffix}") if a_file.is_file()]
+
+    if target_file is None:
+        if len(potential_matches) == 1:
+            target_file = potential_matches[0]
+        elif len(potential_matches) == 0:
+            typer.echo(ctx.get_help())
+            typer.echo()
+            typer.echo(typer.style(f"❌ ERROR: Could not find script '{name}'.", fg=typer.colors.RED, bold=True))
+            typer.echo("Searched in:")
+            for r in roots:
+                typer.echo(f"  - {r}")
+            raise typer.Exit(code=1)
+        else:
+            typer.echo(typer.style(f"Warning: Could not find script '{name}'. Checked {len(potential_matches)} candidate files, trying interactively:", fg=typer.colors.YELLOW))
+            from machineconfig.utils.options import choose_from_options
+            options = [str(p) for p in potential_matches]
+            chosen_file_part = choose_from_options(options, multi=False, msg="Select the script to run:", tv=True, preview="bat")
+            target_file = Path(chosen_file_part)
+
+    typer.echo(typer.style(f"✅ Found script at: {target_file}", fg=typer.colors.GREEN))
+    if target_file.suffix == ".py":
+        from machineconfig.utils.code import get_uv_command_executing_python_file, exit_then_run_shell_script
+        shell_script = get_uv_command_executing_python_file(python_file=str(target_file), uv_project_dir=None, uv_with=None, prepend_print=False)
+        exit_then_run_shell_script(script=shell_script)
+    else:
+        from machineconfig.utils.code import exit_then_run_shell_file
+        exit_then_run_shell_file(script_path=str(target_file), strict=True)
+
+
+def copy_script_to_local(ctx: typer.Context,
+                         name: Annotated[str, typer.Argument(help="Name of the temporary python script to copy, e.g., 'a' for a.py")],
+                         alias: Annotated[Optional[str], typer.Option("--alias", "-a", help="Whether to create call it a different name locally")] = None
+                         ) -> None:
+    """
+    Copy a temporary python script stored in machineconfig/scripts/python/helpers/tmp_py_scripts to the local machine.
+    """
+    url = f"""https://raw.githubusercontent.com/thisismygitrepo/machineconfig/refs/heads/main/src/machineconfig/scripts/python/helpers/tmp_py_scripts/{name}.py"""
+    import requests
+    response = requests.get(url)
+    if response.status_code != 200:
+        typer.echo(ctx.get_help())
+        typer.echo()
+        typer.echo(typer.style(f"❌ ERROR: Could not fetch script '{name}.py' from repository. Status Code: {response.status_code}", fg=typer.colors.RED, bold=True))
+        raise typer.Exit(code=1)
+    script_content = response.text
+    from machineconfig.utils.source_of_truth import CONFIG_ROOT
+    local_path = CONFIG_ROOT.joinpath(f"scripts_python/{alias or name}.py")
+    with open(local_path, "w") as f:
+        f.write(script_content)
+    typer.echo(typer.style(f"✅ Script '{name}.py' has been copied to '{local_path}'.", fg=typer.colors.GREEN))
+
+
+def get_app():
+    app = typer.Typer(
+        name="run-tmp-script",
+        help="Helper to run temporary python scripts stored in machineconfig/scripts/python/helpers/tmp_py_scripts",
+        no_args_is_help=True,
+    )
+    from machineconfig.jobs.scripts_dynamic import a
+    app.command()(a.main)
+    return app

machineconfig/scripts/python/helpers/helpers_devops/themes/choose_starship_theme.ps1

@@ -0,0 +1,41 @@
+$presets = @{
+    "nerd-font-symbols" = "Changes the symbols for each module to use Nerd Font symbols."
+    "no-nerd-font" = "Changes the symbols so that no Nerd Font symbols are used."
+    "bracketed-segments" = "Changes the format to show segments in brackets."
+    "plain-text-symbols" = "Changes the symbols for each module into plain text."
+    "no-runtime-versions" = "Hides the version of language runtimes."
+    "no-empty-icons" = "Does not show icons if the toolset is not found."
+    "pure-preset" = "Emulates the look and behavior of Pure."
+    "pastel-powerline" = "Inspired by M365Princess."
+    "tokyo-night" = "Inspired by tokyo-night-vscode-theme."
+    "gruvbox-rainbow" = "Inspired by Pastel Powerline and Tokyo Night."
+    "jetpack" = "Pseudo minimalist preset inspired by geometry and spaceship."
+}
+
+$input_list = $presets.Keys | ForEach-Object { "$_`t$($presets[$_])" }
+
+$preview_config = "$env:TEMP/starship_preview.toml"
+
+# Preview command for PowerShell
+# We need to split the line and get the first part.
+# tv replaces {} with the line.
+# We use powershell -c for the preview command to be safe and consistent.
+
+$preview_cmd = "powershell -c `"`$preset = '{}'.Split('`t')[0]; starship preset `$preset > $preview_config; `$env:STARSHIP_CONFIG='$preview_config'; `$env:STARSHIP_SHELL='powershell'; starship prompt`""
+
+if (Get-Command "tv" -ErrorAction SilentlyContinue) {
+    $selected_line = $input_list | tv --preview-command $preview_cmd --preview-size 50
+} elseif (Get-Command "fzf" -ErrorAction SilentlyContinue) {
+    # fzf fallback
+    $selected_line = $input_list | fzf --ansi --delimiter "`t" --with-nth 1,2 --preview "powershell -c `"`$preset = {1}; starship preset `$preset > $preview_config; `$env:STARSHIP_CONFIG='$preview_config'; `$env:STARSHIP_SHELL='powershell'; starship prompt`"" --preview-window bottom:50%
+} else {
+    Write-Host "Error: 'tv' or 'fzf' not found."
+    exit 1
+}
+
+if ($selected_line) {
+    $selected_preset = $selected_line.Split("`t")[0]
+    Write-Host "Applying $selected_preset..."
+    starship preset $selected_preset -o "$HOME/.config/starship.toml"
+    Write-Host "Done!"
+}

machineconfig/scripts/python/helpers/helpers_devops/themes/choose_starship_theme.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+
+# Ensure UTF-8 encoding for symbols and CLI tools
+export LANG=C.UTF-8
+export LC_ALL=C.UTF-8
+export LC_CTYPE=C.UTF-8
+export PYTHONIOENCODING=utf-8
+
+# Presets
+presets=(
+    "nerd-font-symbols    Changes the symbols for each module to use Nerd Font symbols."
+    "no-nerd-font    Changes the symbols so that no Nerd Font symbols are used."
+    "bracketed-segments    Changes the format to show segments in brackets."
+    "plain-text-symbols    Changes the symbols for each module into plain text."
+    "no-runtime-versions    Hides the version of language runtimes."
+    "no-empty-icons    Does not show icons if the toolset is not found."
+    "pure-preset    Emulates the look and behavior of Pure."
+    "pastel-powerline    Inspired by M365Princess."
+    "tokyo-night    Inspired by tokyo-night-vscode-theme."
+    "gruvbox-rainbow    Inspired by Pastel Powerline and Tokyo Night."
+    "jetpack    Pseudo minimalist preset inspired by geometry and spaceship."
+)
+
+# Join presets with newlines
+input_data=$(printf "%s\n" "${presets[@]}")
+
+preview_config="/tmp/starship_preview.toml"
+# Preview command needs to extract the first column (preset name) from the line
+# {} will be replaced by the selected line
+# We use awk to handle multiple spaces as delimiter
+preview_cmd="preset=\$(echo '{}' | awk '{print \$1}'); starship preset \"\$preset\" > $preview_config && LANG=C.UTF-8 LC_ALL=C.UTF-8 STARSHIP_CONFIG=$preview_config STARSHIP_SHELL=fish starship prompt"
+
+if command -v tv &> /dev/null; then
+    # tv requires input from stdin if no source-command is given
+    selected_line=$(printf "%s" "$input_data" | LANG=C.UTF-8 LC_ALL=C.UTF-8 tv --ansi --preview-command "$preview_cmd" --preview-size 50)
+elif command -v fzf &> /dev/null; then
+    selected_line=$(printf "%s" "$input_data" | LANG=C.UTF-8 LC_ALL=C.UTF-8 fzf --ansi --preview "preset=\$(echo {} | awk '{print \$1}'); starship preset \$preset > $preview_config && LANG=C.UTF-8 LC_ALL=C.UTF-8 STARSHIP_CONFIG=$preview_config STARSHIP_SHELL=fish starship prompt" --preview-window bottom:30%)
+else
+    echo "Error: 'tv' or 'fzf' not found."
+    exit 1
+fi
+
+if [ -n "$selected_line" ]; then
+    selected_preset=$(echo "$selected_line" | awk '{print $1}')
+    echo "Applying $selected_preset..."
+    starship preset "$selected_preset" -o ~/.config/starship.toml
+    echo "Done!"
+fi

machineconfig/scripts/python/{helpers_devops → helpers/helpers_devops}/themes/choose_wezterm_theme.py

@@ -3,7 +3,7 @@ Choose a theme for Wezterm
 """
 
 from machineconfig.utils.options import choose_from_options
-from machineconfig.utils.path_extended import PathExtended
+from pathlib import Path
 from typing import Any
 import time
 from rich.panel import Panel
@@ -45,21 +45,21 @@ schemes_list = [
 
 def main2():
     console.print(Panel("🎨 WezTerm Theme Selector", title_align="left", border_style="green"))
-    option = choose_from_options(multi=False, options=schemes_list, header="Choose a theme for Wezterm", fzf=True, msg="Use arrow keys to navigate, Enter to select a theme")
+    option = choose_from_options(multi=False, options=schemes_list, header="Choose a theme for Wezterm", tv=True, msg="Use arrow keys to navigate, Enter to select a theme")
     set_theme(option)
     print(f"✅ Theme set to: {option}")
 
 
 def set_theme(theme: str):
     print(f"🔄 Setting WezTerm theme to: {theme}")
-    txt_lines = PathExtended.home().joinpath(".config/wezterm/wezterm.lua").expanduser().read_text(encoding="utf-8").splitlines()
+    txt_lines = Path.home().joinpath(".config/wezterm/wezterm.lua").expanduser().read_text(encoding="utf-8").splitlines()
     res_lines = []
     for line in txt_lines:
         if "config.color_scheme = " in line:
             res_lines.append(f"config.color_scheme = '{theme}'")
         else:
             res_lines.append(line)
-    PathExtended.home().joinpath(".config/wezterm/wezterm.lua").expanduser().write_text("\n".join(res_lines), encoding="utf-8")
+    Path.home().joinpath(".config/wezterm/wezterm.lua").expanduser().write_text("\n".join(res_lines), encoding="utf-8")
     time.sleep(0.1)
     print("💾 Configuration saved")
 

machineconfig/scripts/python/{helpers_fire/helpers4.py → helpers/helpers_fire_command/file_wrangler.py}

@@ -1,24 +1,7 @@
-
 from typing import Optional
 import os
-from machineconfig.utils.path_extended import PathExtended
-
-
-def search_for_files_of_interest(path_obj: PathExtended):
-    if path_obj.joinpath(".venv").exists():
-        path_objects = path_obj.search("*", not_in=[".venv"])
-        files: list[PathExtended] = []
-        for a_path_obj in path_objects:
-            files += search_for_files_of_interest(path_obj=a_path_obj)
-        return files
-    if path_obj.is_file():
-        return [path_obj]
-    py_files = path_obj.search(pattern="*.py", not_in=["__init__.py"], r=True)
-    ps_files = path_obj.search(pattern="*.ps1", r=True)
-    sh_files = path_obj.search(pattern="*.sh", r=True)
-    files = py_files + ps_files + sh_files
-    return files
-
+from pathlib import Path
+import platform
 
 
 def parse_pyfile(file_path: str):
@@ -29,7 +12,7 @@ def parse_pyfile(file_path: str):
     func_args: list[list[args_spec]] = [[]]  # this firt prepopulated dict is for the option 'RUN AS MAIN' which has no args
     import ast
 
-    parsed_ast = ast.parse(PathExtended(file_path).read_text(encoding="utf-8"))
+    parsed_ast = ast.parse(Path(file_path).read_text(encoding="utf-8"))
     functions = [node for node in ast.walk(parsed_ast) if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))]
     module__doc__ = ast.get_docstring(parsed_ast)
     main_option = f"RUN AS MAIN -- {module__doc__ if module__doc__ is not None else 'NoDocs'}"
@@ -110,3 +93,57 @@ def get_import_module_code(module_path: str):
         module_name = "IncorrectModuleName"
     # TODO: use py_compile to check if the statement is valid code to avoid syntax errors that can't be caught.
     return f"from {module_name} import *"
+
+
+def wrap_import_in_try_except(import_line: str, pyfile: str, repo_root: Optional[str] = None) -> None:
+    try:
+        exec(import_line)  # type: ignore
+    except (ImportError, ModuleNotFoundError) as ex:
+        print(fr"❌ Failed to import `{pyfile}` as a module: {ex} ")
+        print("⚠️ Attempting import with ad-hoc `$PATH` manipulation. DO NOT pickle any objects in this session as correct deserialization cannot be guaranteed.")
+        import sys
+        from pathlib import Path
+        sys.path.append(str(Path(pyfile).parent))
+        if repo_root is not None:
+            sys.path.append(repo_root)
+        exec(f"from {Path(pyfile).stem} import *")
+        print(fr"✅ Successfully imported `{pyfile}`")
+
+
+def add_to_path(path_variable: str, directory: str) -> str:
+    """
+    Generate shell script to add directory to path_variable.
+    Handles both Windows (cmd) and Unix-like systems (bash/zsh).
+    Checks if variable exists before appending, otherwise creates it.
+    """
+    system = platform.system()
+    
+    if system == "Windows":
+        script = f"""# Check if {path_variable} is defined
+if (Test-Path env:{path_variable}) {{
+    Write-Host "Adding {directory} to existing {path_variable}"
+    $currentValue = [Environment]::GetEnvironmentVariable("{path_variable}", "User")
+    $newValue = "$currentValue;{directory}"
+    [Environment]::SetEnvironmentVariable("{path_variable}", $newValue, "User")
+    $env:{path_variable} = $newValue
+}} else {{
+    Write-Host "Creating new {path_variable} variable"
+    [Environment]::SetEnvironmentVariable("{path_variable}", "{directory}", "User")
+    $env:{path_variable} = "{directory}"
+}}
+Write-Host "{path_variable} is now: $env:{path_variable}\""""
+        return script
+    else:
+        script = f"""#!/bin/bash
+# Check if {path_variable} is defined and not empty
+if [ -z "${{{path_variable}}}" ]; then
+    echo "Creating new {path_variable} variable"
+    export {path_variable}="{directory}"
+else
+    echo "Adding {directory} to existing {path_variable}"
+    export {path_variable}="${{{path_variable}}}:{directory}"
+fi
+echo "{path_variable} is now: ${{{path_variable}}}"
+"""
+        return script
+

machineconfig/scripts/python/{helpers_fire_command → helpers/helpers_fire_command}/fire_jobs_args_helper.py

@@ -19,6 +19,7 @@ class FireJobArgs:
     submit_to_cloud: bool = False
     remote: bool = False
     module: bool = False
+    script: bool = False
     streamlit: bool = False
     environment: str = ""
     holdDirectory: bool = False

machineconfig/scripts/python/helpers/helpers_fire_command/fire_jobs_impl.py

@@ -0,0 +1,233 @@
+"""Pure Python implementation for fire_jobs route command - no typer dependencies."""
+
+from typing import Optional, Callable
+from pathlib import Path
+from machineconfig.scripts.python.helpers.helpers_fire_command.fire_jobs_args_helper import FireJobArgs
+
+RandStrFunc = Callable[[int], str]
+
+
+def route(args: FireJobArgs, fire_args: str) -> None:
+    """Route execution based on args configuration."""
+    from machineconfig.utils.path_helper import get_choice_file
+    from machineconfig.utils.accessories import get_repo_root, randstr
+
+    choice_file = get_choice_file(args.path, suffixes=None)
+    repo_root = get_repo_root(choice_file)
+    print(f"💾 Selected file: {choice_file}.\nRepo root: {repo_root}")
+
+    if args.marimo:
+        _handle_marimo(choice_file=choice_file, repo_root=repo_root, randstr_func=randstr)
+        return
+
+    kwargs_dict = _prepare_kwargs(args=args, choice_file=choice_file)
+    choice_function = _choose_function(args=args, choice_file=choice_file, kwargs_dict=kwargs_dict)
+    if isinstance(choice_function, tuple):
+        choice_function, choice_file, kwargs_dict = choice_function
+
+    command = _build_command(args=args, choice_file=choice_file, choice_function=choice_function, kwargs_dict=kwargs_dict, repo_root=repo_root, fire_args=fire_args, randstr_func=randstr)
+    command = _apply_command_modifiers(args=args, command=command, choice_file=choice_file, repo_root=repo_root, randstr_func=randstr)
+
+    from machineconfig.utils.code import exit_then_run_shell_script
+    exit_then_run_shell_script(script=command, strict=False)
+
+
+def _handle_marimo(choice_file: Path, repo_root: Optional[Path], randstr_func: RandStrFunc) -> None:
+    """Handle marimo notebook launch."""
+    print(f"🧽 Preparing to launch Marimo notebook for `{choice_file}`...")
+    tmp_dir = Path.home().joinpath(f"tmp_results/tmp_scripts/marimo/{choice_file.stem}_{randstr_func(10)}")
+    tmp_dir.mkdir(parents=True, exist_ok=True)
+    script = f"""
+cd {tmp_dir}
+uv run --python 3.14 --with marimo marimo convert {choice_file} -o marimo_nb.py
+uv run --project {repo_root} --with marimo marimo edit --host 0.0.0.0 marimo_nb.py
+"""
+    from machineconfig.utils.code import exit_then_run_shell_script
+    print(f"🚀 Launching Marimo notebook for `{choice_file}`...")
+    exit_then_run_shell_script(script)
+
+
+def _prepare_kwargs(args: FireJobArgs, choice_file: Path) -> dict[str, object]:
+    """Prepare kwargs dict from args."""
+    if choice_file.suffix == ".py":
+        from machineconfig.scripts.python.helpers.helpers_fire_command.fire_jobs_args_helper import extract_kwargs
+        return extract_kwargs(args)
+    return {}
+
+
+def _choose_function(args: FireJobArgs, choice_file: Path, kwargs_dict: dict[str, object]) -> Optional[str] | tuple[Optional[str], Path, dict[str, object]]:
+    """Choose function to run, possibly interactively."""
+    if args.choose_function:
+        from machineconfig.scripts.python.helpers.helpers_fire_command.fire_jobs_route_helper import choose_function_or_lines
+        choice_function, choice_file, kwargs_dict = choose_function_or_lines(choice_file, kwargs_dict)
+        return (choice_function, choice_file, kwargs_dict)
+    return args.function
+
+
+def _build_command(args: FireJobArgs, choice_file: Path, choice_function: Optional[str], kwargs_dict: dict[str, object], repo_root: Optional[Path], fire_args: str, randstr_func: RandStrFunc) -> str:
+    """Build the execution command."""
+    if choice_file.suffix == ".py":
+        exe_line = _build_python_exe_line(args=args, choice_file=choice_file, repo_root=repo_root)
+        choice_file_adjusted = _adjust_choice_file(args=args, choice_file=choice_file, repo_root=repo_root)
+
+        if args.script or (args.debug and args.choose_function):
+            choice_file = _create_import_script(choice_file=choice_file, choice_function=choice_function, kwargs_dict=kwargs_dict, repo_root=repo_root, randstr_func=randstr_func)
+            choice_file_adjusted = str(choice_file)
+
+        return _build_final_command(args=args, exe_line=exe_line, choice_file=choice_file, choice_file_adjusted=choice_file_adjusted, choice_function=choice_function, fire_args=fire_args)
+    elif choice_file.suffix in (".ps1", ".sh"):
+        return f". {choice_file}"
+    elif choice_file.suffix == "":
+        return str(choice_file)
+    else:
+        raise NotImplementedError(f"File type {choice_file.suffix} not supported, in the sense that I don't know how to fire it.")
+
+
+def _build_python_exe_line(args: FireJobArgs, choice_file: Path, repo_root: Optional[Path]) -> str:
+    """Build Python execution line."""
+    module_line = "-m" if args.module else ""
+    with_project = f"--project {repo_root} " if repo_root is not None else ""
+    interactive_line = "-i" if args.interactive else ""
+
+    if args.interactive:
+        from machineconfig.utils.ve import get_ve_path_and_ipython_profile
+        _ve_root_from_file, ipy_profile = get_ve_path_and_ipython_profile(init_path=choice_file)
+        if ipy_profile is None:
+            ipy_profile = "default"
+        ipython_line = f"--no-banner --profile {ipy_profile} "
+    else:
+        ipython_line = ""
+
+    if args.streamlit:
+        from machineconfig.scripts.python.helpers.helpers_fire_command.fire_jobs_route_helper import get_command_streamlit
+        interpreter_line = get_command_streamlit(choice_file=choice_file, environment=args.environment, repo_root=repo_root)
+    elif args.jupyter:
+        interpreter_line = "jupyter-lab"
+    else:
+        interpreter_line = "python" if not args.interactive else "ipython"
+
+    return f"uv run {with_project} {interpreter_line} {interactive_line} {module_line} {ipython_line}"
+
+
+def _adjust_choice_file(args: FireJobArgs, choice_file: Path, repo_root: Optional[Path]) -> str:
+    """Adjust choice file path for module mode."""
+    if args.module and choice_file.suffix == ".py":
+        if repo_root is not None:
+            return ".".join(Path(choice_file).relative_to(repo_root).parts).replace(".py", "")
+        else:
+            return ".".join(Path(choice_file).relative_to(Path.cwd()).parts).replace(".py", "")
+    return str(choice_file)
+
+
+def _create_import_script(choice_file: Path, choice_function: Optional[str], kwargs_dict: dict[str, object], repo_root: Optional[Path], randstr_func: RandStrFunc) -> Path:
+    """Create a script that imports the module and calls the function."""
+    from machineconfig.scripts.python.helpers.helpers_fire_command.file_wrangler import get_import_module_code, wrap_import_in_try_except
+    from machineconfig.utils.meta import lambda_to_python_script
+    from machineconfig.utils.code import print_code
+
+    import_code = get_import_module_code(str(choice_file))
+    import_code_robust = lambda_to_python_script(
+        lambda: wrap_import_in_try_except(
+            import_line=import_code, pyfile=str(choice_file), repo_root=str(repo_root) if repo_root is not None else None
+        ),
+        in_global=True,
+        import_module=False,
+    )
+    code_printing = 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(f"🧩 Preparing import code for module import:\n{import_code}")
+    if choice_function is not None:
+        calling = f"""res = {choice_function}({("**" + str(kwargs_dict)) if kwargs_dict else ""})"""
+    else:
+        calling = """# No function selected to call. You can add your code here."""
+    new_choice_file = Path.home().joinpath(f"tmp_results/tmp_scripts/python/{Path(choice_file).parent.name}_{Path(choice_file).stem}_{randstr_func(10)}.py")
+    new_choice_file.parent.mkdir(parents=True, exist_ok=True)
+    new_choice_file.write_text(import_code_robust + "\n" + code_printing + "\n" + calling, encoding="utf-8")
+    return new_choice_file
+
+
+def _build_final_command(args: FireJobArgs, exe_line: str, choice_file: Path, choice_file_adjusted: str, choice_function: Optional[str], fire_args: str) -> str:
+    """Build the final command string."""
+    if args.debug:
+        import platform
+        if platform.system() == "Windows":
+            return f"{exe_line} -m ipdb {choice_file_adjusted} "
+        elif platform.system() in ["Linux", "Darwin"]:
+            return f"{exe_line} -m pudb {choice_file_adjusted} "
+        else:
+            raise NotImplementedError(f"Platform {platform.system()} not supported.")
+    elif args.module:
+        return f"{exe_line} {choice_file_adjusted} "
+    elif choice_function is not None and choice_file.suffix == ".py":
+        return f"{exe_line} -m fire {choice_file_adjusted} {choice_function} {fire_args}"
+    elif args.streamlit:
+        if args.holdDirectory:
+            return f"{exe_line} {choice_file}"
+        else:
+            return f"cd {choice_file.parent}\n{exe_line} {choice_file.name}\ncd {Path.cwd()}"
+    elif args.cmd:
+        return rf""" cd /d {choice_file.parent} & {exe_line} {choice_file.name} """
+    elif choice_file.suffix == "":
+        return f"{exe_line} {choice_file} {fire_args}"
+    else:
+        return f"{exe_line} {choice_file} "
+
+
+def _apply_command_modifiers(args: FireJobArgs, command: str, choice_file: Path, repo_root: Optional[Path], randstr_func: RandStrFunc) -> str:
+    """Apply various command modifiers based on args."""
+    from rich.panel import Panel
+    from rich.console import Console
+    from rich.syntax import Syntax
+
+    console = Console()
+
+    if args.cmd:
+        new_line = "\n"
+        command = rf"""start cmd -Argument "/k {command.replace(new_line, " & ")} " """
+
+    if args.submit_to_cloud:
+        command = f"""uv run python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
+        if args.function is not None:
+            command += f"--function {args.function} "
+
+    if args.optimized:
+        command = command.replace("python ", "python -OO ")
+
+    if args.zellij_tab is not None:
+        comman_path__ = Path.home().joinpath(f"tmp_results/tmp_scripts/zellij_commands/{choice_file.stem}_{randstr_func(10)}.sh")
+        comman_path__.parent.mkdir(parents=True, exist_ok=True)
+        comman_path__.write_text(command, encoding="utf-8")
+        console.print(Panel(Syntax(command, lexer="shell"), title=f"🔥 fire command @ {comman_path__}: "), style="bold red")
+        import subprocess
+
+        existing_tab_names = subprocess.run(["zellij", "action", "query-tab-names"], capture_output=True, text=True, check=True).stdout.splitlines()
+        if args.zellij_tab in existing_tab_names:
+            print(f"⚠️ Tab name `{args.zellij_tab}` already exists. Please choose a different name.")
+            args.zellij_tab += f"_{randstr_func(3)}"
+        from machineconfig.cluster.sessions_managers.zellij_local import run_command_in_zellij_tab
+
+        command = run_command_in_zellij_tab(command=str(comman_path__), tab_name=args.zellij_tab, cwd=None)
+
+    if args.watch:
+        command = "watchexec --restart --exts py,sh,ps1 " + command
+
+    if args.git_pull:
+        command = f"\ngit -C {choice_file.parent} pull\n" + command
+
+    if args.PathExport:
+        from machineconfig.scripts.python.helpers.helpers_fire_command.file_wrangler import add_to_path
+        export_line = add_to_path(path_variable="PYTHONPATH", directory=str(repo_root))
+        command = export_line + "\n" + command
+
+    if args.loop:
+        import platform
+        if platform.system() in ["Linux", "Darwin"]:
+            command = command + "\nsleep 0.5"
+        elif platform.system() == "Windows":
+            command = "$ErrorActionPreference = 'SilentlyContinue';\n" + command + "\nStart-Sleep -Seconds 0.5"
+        else:
+            raise NotImplementedError(f"Platform {platform.system()} not supported.")
+
+    return command