machineconfig 7.98__py3-none-any.whl → 8.61__py3-none-any.whl

machineconfig/scripts/python/croshell.py

@@ -1,9 +1,6 @@
 #!/usr/bin/env -S uv run --no-dev --project
 
-"""
-croshell
-
-"""
+"""croshell - Cross-shell command execution."""
 
 from typing import Annotated, Optional
 import typer
@@ -17,155 +14,12 @@ def croshell(
     jupyter: Annotated[bool, typer.Option("--jupyter", "-j", help="run in jupyter interactive console")] = False,
     vscode: Annotated[bool, typer.Option("--vscode", "-c", help="open the script in vscode")] = False,
     visidata: Annotated[bool, typer.Option("--visidata", "-v", help="open data file in visidata")] = False,
-    # streamlit_viewer: Annotated[bool, typer.Option("--streamlit", "-s", help="view in streamlit app")] = False,
     python: Annotated[bool, typer.Option("--python", "-P", help="flag to use python over IPython.")] = False,
     profile: Annotated[Optional[str], typer.Option("--profile", "-r", help="ipython profile to use, defaults to default profile.")] = None,
-    
 ) -> None:
-    if uv_with is not None: user_uv_with_line = f"--with {uv_with} "
-    else: user_uv_with_line = ""
-
-    if project_path is not None:
-        uv_project_line = f'--project {project_path}'
-        uv_python_line = ""
-    else:
-        uv_project_line = ""
-        uv_python_line = "--python 3.14"
-
-    from machineconfig.scripts.python.helpers_croshell.crosh import get_read_python_file_pycode, get_read_data_pycode
-    from machineconfig.utils.meta import lambda_to_python_script
-    from pathlib import Path
-    from machineconfig.utils.accessories import randstr
-    from machineconfig.utils.ve import get_ve_path_and_ipython_profile
-    import json
-    from rich.console import Console
-    from rich.panel import Panel
-    console = Console()
-
-
-    # ==================================================================================
-    # flags processing
-    interactivity = "-i"
-    interpreter = "python" if python else "ipython"
-    ipython_profile: Optional[str] = profile
-    file_obj = Path.cwd()  # initialization value, could be modified according to args.
-    if path is not None:
-        from machineconfig.utils.path_helper import get_choice_file
-        choice_file = get_choice_file(path=path, suffixes={".*"})
-        if project_path is None:
-            ve_path, _ = get_ve_path_and_ipython_profile(choice_file)
-            if ve_path is not None:
-                ve_path_obj = Path(ve_path)
-                uv_project_line = f'--project {ve_path_obj.parent}'
-                uv_python_line = ""
-        if choice_file.suffix == ".py":
-            program = choice_file.read_text(encoding="utf-8")
-            text = f"📄 Selected file: {choice_file.name}"
-            console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-        else:
-            program = lambda_to_python_script(lambda: get_read_data_pycode(path=str(choice_file)),
-                                              in_global=True, import_module=False)
-            text = f"📄 Reading data from: {file_obj.name}"
-            console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-    else:  # if nothing is specified, then run in interactive mode.
-        program = ""
-
-    if Path.home().joinpath("code/machineconfig").exists() and uv_project_line == "":
-        uv_project_line = f'--project "{str(Path.home().joinpath("code/machineconfig"))}"'
-
-    preprogram = """
-#%%
-"""
-    def preprogram_func():
-        from machineconfig.utils.files.headers import print_header, print_logo
-        print_header()
-        print_logo("Machineconfig")
-        from pathlib import Path
-        from machineconfig.utils.path_extended import PathExtended
-        _ = Path, PathExtended  # avoid unused import warnings
-    import inspect, textwrap
-    from types import FunctionType
-    def get_body_simple_function_no_args(f: FunctionType):
-        return textwrap.dedent("\n".join(inspect.getsource(f).splitlines()[1:]))
-    preprogram += get_body_simple_function_no_args(preprogram_func)
-
-    from pathlib import Path
-    pyfile = Path.home().joinpath(f"tmp_results/tmp_scripts/python/croshell/{randstr()}/script.py")
-    pyfile.parent.mkdir(parents=True, exist_ok=True)
-    title = "Reading Data"
-    def_code = lambda_to_python_script(lambda: get_read_python_file_pycode(path=str(pyfile), title=title),
-                                       in_global=False, import_module=False)
-    # print(def_code)
-    python_program = preprogram + "\n\n" + def_code + program
-    pyfile.write_text(python_program, encoding="utf-8")
-    # ve_root_from_file, ipython_profile = get_ve_path_and_ipython_profile(PathExtended(file))
-    ipython_profile = ipython_profile if ipython_profile is not None else "default"
-    # ve_activateion_line = get_ve_activate_line(ve_name=args.ve or ve_profile_suggested, a_path=str(PathExtended.cwd()))
-
-    # prepare notebook target path (avoid relying on locals())
-    nb_target = pyfile.with_suffix(".ipynb")
-    if jupyter:
-        try:
-            nb_path = pyfile.with_suffix(".ipynb")
-            nb_content = {
-                "cells": [
-                    {
-                        "cell_type": "code",
-                        "metadata": {"language": "python"},
-                        "source": [python_program],
-                        "outputs": [],
-                        "execution_count": None,
-                    }
-                ],
-                "metadata": {},
-                "nbformat": 4,
-                "nbformat_minor": 5,
-            }
-            nb_path.write_text(json.dumps(nb_content), encoding="utf-8")
-            nb_target = nb_path
-        except Exception:
-            # if writing fails, fall back to the default nb_target already set
-            pass
-    if visidata:
-        if file_obj.suffix == ".json":
-            fire_line = f"uv run {uv_python_line} {user_uv_with_line} {uv_project_line} --with visidata vd {str(file_obj)}"
-        else:
-            fire_line = f"uv run {uv_python_line} {user_uv_with_line} {uv_project_line} --with visidata,pyarrow vd {str(file_obj)}"
-    elif marimo:
-        if Path.home().joinpath("code/machineconfig").exists():
-            requirements = f"""{user_uv_with_line} {uv_project_line} --with marimo  """
-        else: requirements = f"""{uv_python_line} {user_uv_with_line} {uv_project_line} --with "marimo,cowsay,machineconfig[plot]>=7.98" """
-        fire_line = f"""
-cd {str(pyfile.parent)}
-uv run {uv_python_line} --with "marimo" marimo convert {pyfile.name} -o marimo_nb.py
-uv run {requirements} marimo edit --host 0.0.0.0 marimo_nb.py
-"""
-    elif jupyter:
-        if Path.home().joinpath("code/machineconfig").exists():
-            requirements = f"""{user_uv_with_line}  {uv_project_line}  --with jupyterlab """
-        else: requirements = f"""{user_uv_with_line} {uv_project_line} --with "cowsay,machineconfig[plot]>=7.98" """
-        fire_line = f"uv run {requirements} {uv_project_line}  jupyter-lab {str(nb_target)}"
-    elif vscode:
-        user_uv_add = f"uv add {uv_with}" if uv_with is not None else ""
-        fire_line = f"""
-cd {str(pyfile.parent)}
-uv init {uv_python_line}
-uv venv
-uv add "cowsay,machineconfig[plot]>=7.98"
-uv add {user_uv_add}
-# code serve-web
-code --new-window {str(pyfile)}
-"""
-    else:
-        if interpreter == "ipython": profile = f" --profile {ipython_profile} --no-banner"
-        else: profile = ""
-        if Path.home().joinpath("code/machineconfig").exists():
-            ve_line = f"""{user_uv_with_line}  {uv_project_line} """
-        else: ve_line = f"""{uv_python_line} {user_uv_with_line} {uv_project_line} --with "cowsay,machineconfig[plot]>=7.98" """
-        fire_line = f"uv run {ve_line} {interpreter} {interactivity} {profile} {str(pyfile)}"
-
-    from machineconfig.utils.code import exit_then_run_shell_script
-    exit_then_run_shell_script(fire_line, strict=False)
+    """Cross-shell command execution."""
+    from machineconfig.scripts.python.helpers.helpers_croshell.croshell_impl import croshell as impl
+    impl(path=path, project_path=project_path, uv_with=uv_with, marimo=marimo, jupyter=jupyter, vscode=vscode, visidata=visidata, python=python, profile=profile)
 
 
 def main() -> None:
@@ -173,9 +27,4 @@ def main() -> None:
 
 
 if __name__ == "__main__":
-    # def func(flag: Annotated[bool, typer.Option("--flag/-nf", help="dummy flag for debugging", flag_value=False, is_flag=True)]=True):
-    #     console.print(f"flag: {flag}")
-    # app = typer.Typer()
-    # app.command()(func)
-    # app()
     main()

machineconfig/scripts/python/devops.py

@@ -1,14 +1,8 @@
-"""devops with emojis"""
+"""devops with emojis - lazy loading subcommands."""
 
 import typer
-from typing import Optional, Annotated
+from typing import Optional, Annotated, Literal
 
-import machineconfig.scripts.python.helpers_devops.cli_repos as cli_repos
-import machineconfig.scripts.python.helpers_devops.cli_config as cli_config
-import machineconfig.scripts.python.helpers_devops.cli_self as cli_self
-import machineconfig.scripts.python.helpers_devops.cli_data as cli_data
-import machineconfig.scripts.python.helpers_devops.cli_nw as cli_network
-import machineconfig.scripts.python.helpers.run_py_script as run_py_script_module
 
 def install(which: Annotated[Optional[str], typer.Argument(..., help="Comma-separated list of program names to install, or group name if --group flag is set.")] = None,
         group: Annotated[bool, typer.Option(..., "--group", "-g", help="Treat 'which' as a group name. A group is bundle of apps.")] = False,
@@ -19,44 +13,69 @@ def install(which: Annotated[Optional[str], typer.Argument(..., help="Comma-sepa
         installer_entry_point.main_installer_cli(which=which, group=group, interactive=interactive)
 
 
+def repos(ctx: typer.Context) -> None:
+    """📁 [r] Manage development repositories"""
+    import machineconfig.scripts.python.helpers.helpers_devops.cli_repos as cli_repos
+    cli_repos.get_app()(ctx.args, standalone_mode=False)
 
-# def get_app():
-#     app = typer.Typer(add_completion=False, no_args_is_help=True)
-#     app.command(name="scripts", help="define all scripts", no_args_is_help=False)(define_scripts)
-#     return app
 
-# def main():
-#     # return app
-#     app = get_app()
-#     app()
+def config(ctx: typer.Context) -> None:
+    """⚙️ [c] Configuration management"""
+    import machineconfig.scripts.python.helpers.helpers_devops.cli_config as cli_config
+    cli_config.get_app()(ctx.args, standalone_mode=False)
 
-#     define_app = get_define_app()
 
+def data(ctx: typer.Context) -> None:
+    """💾 [d] Data management"""
+    import machineconfig.scripts.python.helpers.helpers_devops.cli_data as cli_data
+    cli_data.get_app()(ctx.args, standalone_mode=False)
 
-def get_app():
 
-    cli_app = typer.Typer(help="🛠️ DevOps operations", no_args_is_help=True, add_help_option=False, add_completion=False)
-    cli_app.command("install", no_args_is_help=True, help="🛠️ [i] Install essential packages")(install)
-    cli_app.command("i", no_args_is_help=True, help="Install essential packages", hidden=True)(install)
+def self_cmd(ctx: typer.Context) -> None:
+    """🔧 [s] Self management"""
+    import machineconfig.scripts.python.helpers.helpers_devops.cli_self as cli_self
+    cli_self.get_app()(ctx.args, standalone_mode=False)
 
-    app_repos = cli_repos.get_app()
-    cli_app.add_typer(app_repos, name="repos")
-    cli_app.add_typer(app_repos, name="r", hidden=True)
-    app_config = cli_config.get_app()
-    cli_app.add_typer(app_config, name="config")
-    cli_app.add_typer(app_config, name="c", hidden=True)
-    app_data = cli_data.get_app()
-    cli_app.add_typer(app_data, name="data")
-    cli_app.add_typer(app_data, name="d", hidden=True)
-    app_self = cli_self.get_app()
-    cli_app.add_typer(app_self, name="self")
-    cli_app.add_typer(app_self, name="s", hidden=True)
-    app_nw = cli_network.get_app()
-    cli_app.add_typer(app_nw, name="network")
-    cli_app.add_typer(app_nw, name="n", hidden=True)
 
-    cli_app.command("python", no_args_is_help=True, help="🐍 [p] python scripts or command/file in the machineconfig environment", context_settings={"show_help_on_error": True})(run_py_script_module.run_py_script)
-    cli_app.command("p", no_args_is_help=True, help="RUN python scripts or command/file in the machineconfig environment", hidden=True)(run_py_script_module.run_py_script)
+def network(ctx: typer.Context) -> None:
+    """🌐 [n] Network management"""
+    import machineconfig.scripts.python.helpers.helpers_devops.cli_nw as cli_network
+    cli_network.get_app()(ctx.args, standalone_mode=False)
+
+
+def execute(
+    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:
+    """🚀 Execute python/shell scripts from pre-defined directories or as command."""
+    import machineconfig.scripts.python.helpers.helpers_devops.run_script as run_py_script_module
+    run_py_script_module.run_py_script(ctx=ctx, name=name, where=where, interactive=interactive, command=command, list_scripts=list_scripts)
+
+
+def get_app() -> typer.Typer:
+    cli_app = typer.Typer(help="🛠️ DevOps operations", no_args_is_help=True, add_help_option=True, add_completion=False)
+    ctx_settings: dict[str, object] = {"allow_extra_args": True, "allow_interspersed_args": True, "ignore_unknown_options": True, "help_option_names": []}
+
+    cli_app.command("install", no_args_is_help=True, help=install.__doc__, short_help="🛠️  [i] Install essential packages")(install)
+    cli_app.command("i", no_args_is_help=True, help=install.__doc__, hidden=True)(install)
+
+    cli_app.command("repos", help="📁 [r] Manage development repositories", context_settings=ctx_settings)(repos)
+    cli_app.command("r", hidden=True, context_settings=ctx_settings)(repos)
+    cli_app.command("config", help="🔩 [c] Configuration management", context_settings=ctx_settings)(config)
+    cli_app.command("c", hidden=True, context_settings=ctx_settings)(config)
+    cli_app.command("data", help="💾 [d] Data management", context_settings=ctx_settings)(data)
+    cli_app.command("d", hidden=True, context_settings=ctx_settings)(data)
+    cli_app.command("self", help="🔧 [s] Self management", context_settings=ctx_settings)(self_cmd)
+    cli_app.command("s", hidden=True, context_settings=ctx_settings)(self_cmd)
+    cli_app.command("network", help="🌐 [n] Network management", context_settings=ctx_settings)(network)
+    cli_app.command("n", hidden=True, context_settings=ctx_settings)(network)
+
+    cli_app.command("execute", no_args_is_help=True, short_help="🚀 [e] Execute python/shell scripts from pre-defined directories or as command")(execute)
+    cli_app.command("e", no_args_is_help=True, hidden=True)(execute)
 
     return cli_app
 

machineconfig/scripts/python/devops_navigator.py

@@ -1,6 +1,20 @@
-from machineconfig.scripts.python.helpers_navigator import CommandNavigatorApp
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "machineconfig>=8.61",
+#     "textual",
+# ]
+# ///
+
+"""Textual TUI for navigating `machineconfig` command structure."""
+
+
+def main() -> None:
+    from machineconfig.scripts.python.helpers.helpers_navigator.main_app import CommandNavigatorApp
+
+    CommandNavigatorApp().run()
 
 
 if __name__ == "__main__":
-    app = CommandNavigatorApp()
-    app.run()
+    main()

machineconfig/scripts/python/fire_jobs.py

@@ -1,187 +1,9 @@
-"""
-fire
-
-# https://github.com/pallets/click combine with fire. Consider
-# https://github.com/ceccopierangiolieugenio/pyTermTk for choose_from_options build TUI
-# https://github.com/chriskiehl/Gooey build commandline interface
-
-"""
+"""fire - Fire and manage jobs."""
 
 from typing import Optional, Annotated
 import typer
 
 
-def route(args: "FireJobArgs", fire_args: str = "") -> None:
-    from pathlib import Path
-    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:
-        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()}")
-        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)
-        return
-
-    # =========================  preparing kwargs_dict
-    if choice_file.suffix == ".py":
-        from machineconfig.scripts.python.helpers_fire_command.fire_jobs_args_helper import extract_kwargs
-        kwargs_dict = extract_kwargs(args)  # This now returns empty dict, but kept for compatibility
-    else:
-        kwargs_dict = {}
-
-    # =========================  choosing function to run
-    choice_function: Optional[str] = None  # Initialize to avoid unbound variable
-    if args.choose_function:
-        from machineconfig.scripts.python.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)
-    else:
-        choice_function = args.function
-
-    if choice_file.suffix == ".py":
-        with_project = f"--project {repo_root} " if repo_root is not None else ""
-        if args.streamlit:
-            from machineconfig.scripts.python.helpers_fire_command.fire_jobs_route_helper import get_command_streamlit
-            exe = get_command_streamlit(choice_file=choice_file, environment=args.environment, repo_root=repo_root)
-            exe = f"uv run {with_project} {exe} "
-        elif args.jupyter:
-            exe = f"uv run {with_project} jupyter-lab"
-        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"
-                exe = f"uv run {with_project} ipython -i --no-banner --profile {ipy_profile} "
-            else:
-                exe = f"uv run {with_project} python "
-    elif choice_file.suffix == ".ps1" or choice_file.suffix == ".sh":
-        exe = "."
-    elif choice_file.suffix == "":
-        exe = ""
-    else:
-        raise NotImplementedError(f"File type {choice_file.suffix} not supported, in the sense that I don't know how to fire it.")
-
-    if args.module or (args.debug and args.choose_function):
-        # because debugging tools do not support choosing functions and don't interplay with fire module. So the only way to have debugging and choose function options is to import the file as a module into a new script and run the function of interest there and debug the new script.
-        assert choice_file.suffix == ".py", f"File must be a python file to be imported as a module. Got {choice_file}"
-        from machineconfig.scripts.python.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,
-        )
-        # print(f"🧩 Preparing import code for module import:\n{import_code}")
-        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."""
-        choice_file = Path.home().joinpath(f"tmp_results/tmp_scripts/python/{Path(choice_file).parent.name}_{Path(choice_file).stem}_{randstr()}.py")
-        choice_file.parent.mkdir(parents=True, exist_ok=True)
-        choice_file.write_text(import_code_robust + "\n" + code_printing + "\n" + calling, encoding="utf-8")
-
-    # =========================  determining basic command structure: putting together exe & choice_file & choice_function & pdb
-    if args.debug:
-        import platform
-        if platform.system() == "Windows":
-            command = f"{exe} -m ipdb {choice_file} "  # pudb is not available on windows machines, use poor man's debugger instead.
-        elif platform.system() in ["Linux", "Darwin"]:
-            command = f"{exe} -m pudb {choice_file} "  # TODO: functions not supported yet in debug mode.
-        else:
-            raise NotImplementedError(f"Platform {platform.system()} not supported.")
-    elif args.module:
-        # both selected function and kwargs are mentioned in the made up script, therefore no need for fire module.
-        command = f"{exe} {choice_file} "
-    elif choice_function is not None and choice_file.suffix == ".py":
-        command = f"{exe} -m fire {choice_file} {choice_function} {fire_args}"
-    elif args.streamlit:
-        # for .streamlit config to work, it needs to be in the current directory.
-        if args.holdDirectory:
-            command = f"{exe} {choice_file}"
-        else:
-            command = f"cd {choice_file.parent}\n{exe} {choice_file.name}\ncd {Path.cwd()}"
-    elif args.cmd:
-        command = rf""" cd /d {choice_file.parent} & {exe} {choice_file.name} """
-    else:
-        if choice_file.suffix == "":
-            command = f"{exe} {choice_file} {fire_args}"
-        else:
-            command = f"{exe} {choice_file} "
-
-    if not args.cmd:
-        pass
-    else:
-        new_line = "\n"
-        command = rf"""start cmd -Argument "/k {command.replace(new_line, " & ")} " """  # this works from powershell
-    if args.submit_to_cloud:
-        command = f"""uv run python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
-        if choice_function is not None:
-            command += f"--function {choice_function} "
-
-    if args.optimized:
-        command = command.replace("python ", "python -OO ")
-
-    from rich.panel import Panel
-    from rich.console import Console
-    from rich.syntax import Syntax
-
-    console = Console()
-    if args.zellij_tab is not None:
-        comman_path__ = Path.home().joinpath(f"tmp_results/tmp_scripts/zellij_commands/{choice_file.stem}_{randstr()}.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(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_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.")
-    from machineconfig.utils.code import exit_then_run_shell_script
-    exit_then_run_shell_script(script=command, strict=False)
-
-
 def fire(
     ctx: typer.Context,
     path: Annotated[str, typer.Argument(help="Path to the Python file to run")] = ".",
@@ -195,23 +17,22 @@ def fire(
     jupyter: Annotated[bool, typer.Option("--jupyter", "-j", help="Open in a jupyter notebook")] = False,
     marimo: Annotated[bool, typer.Option("--marimo", "-M", help="Open in a marimo notebook")] = False,
     module: Annotated[bool, typer.Option("--module", "-m", help="Launch the main file")] = False,
+    script: Annotated[bool, typer.Option("--script", "-s", help="Launch as a script without fire")] = False,
     optimized: Annotated[bool, typer.Option("--optimized", "-O", help="Run the optimized version of the function")] = False,
     zellij_tab: Annotated[Optional[str], typer.Option("--zellij-tab", "-z", help="Open in a new zellij tab")] = None,
     submit_to_cloud: Annotated[bool, typer.Option("--submit-to-cloud", "-C", help="Submit to cloud compute")] = False,
     remote: Annotated[bool, typer.Option("--remote", "-r", help="Launch on a remote machine")] = False,
     streamlit: Annotated[bool, typer.Option("--streamlit", "-S", help="Run as streamlit app")] = False,
     environment: Annotated[str, typer.Option("--environment", "-E", help="Choose ip, localhost, hostname or arbitrary url")] = "",
-    holdDirectory: Annotated[
-        bool, typer.Option("--holdDirectory", "-D", help="Hold current directory and avoid cd'ing to the script directory")
-    ] = False,
+    holdDirectory: Annotated[bool, typer.Option("--holdDirectory", "-D", help="Hold current directory and avoid cd'ing to the script directory")] = False,
     PathExport: Annotated[bool, typer.Option("--PathExport", "-P", help="Augment the PYTHONPATH with repo root")] = False,
     git_pull: Annotated[bool, typer.Option("--git-pull", "-g", help="Start by pulling the git repo")] = False,
     watch: Annotated[bool, typer.Option("--watch", "-w", help="Watch the file for changes")] = False,
 ) -> None:
     """Main function to process fire jobs arguments."""
+    from machineconfig.scripts.python.helpers.helpers_fire_command.fire_jobs_args_helper import FireJobArgs, parse_fire_args_from_context
+    from machineconfig.scripts.python.helpers.helpers_fire_command.fire_jobs_impl import route
 
-    # Get Fire arguments from context
-    from machineconfig.scripts.python.helpers_fire_command.fire_jobs_args_helper import FireJobArgs, parse_fire_args_from_context
     fire_args = parse_fire_args_from_context(ctx)
 
     args = FireJobArgs(
@@ -228,6 +49,7 @@ def fire(
         submit_to_cloud=submit_to_cloud,
         remote=remote,
         module=module,
+        script=script,
         streamlit=streamlit,
         environment=environment,
         holdDirectory=holdDirectory,
@@ -240,28 +62,23 @@ def fire(
     try:
         route(args, fire_args)
     except SystemExit:
-        # Re-raise SystemExit to preserve exit codes and allow clean exits
         raise
     except Exception as e:
-        # For other exceptions, print clean error message and exit
         import sys
-
         print(f"❌ Error: {e}", file=sys.stderr)
         sys.exit(1)
 
 
-def get_app():
-    from typer import Typer
-
-    app = Typer(add_completion=False)
+def get_app() -> typer.Typer:
+    app = typer.Typer(add_completion=False)
     app.command(context_settings={"allow_extra_args": True, "allow_interspersed_args": False})(fire)
     return app
 
 
-def main():
+def main() -> None:
     app = get_app()
     app()
 
 
 if __name__ == "__main__":
-    from machineconfig.scripts.python.helpers_fire_command.fire_jobs_args_helper import FireJobArgs
+    pass