machineconfig 2.1__py3-none-any.whl → 2.3__py3-none-any.whl

machineconfig/scripts/python/fire_agents.py

@@ -1,4 +1,3 @@
-
 """Utility to launch multiple AI agent prompts in a Zellij session.
 
 Improved design notes:
@@ -16,19 +15,21 @@ from math import ceil
 from typing import Literal, TypeAlias, get_args, Iterable
 
 from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
+from machineconfig.cluster.sessions_managers.layout_types import TabConfig, LayoutConfig
 from machineconfig.utils.utils2 import randstr
 import random
 # import time
 
-AGENTS: TypeAlias = Literal["cursor-agent", "gemini", "crush", "q",
-                            # warp terminal
-                            ]
-TabConfig = dict[str, tuple[str, str]]  # tab name -> (cwd, command)
+AGENTS: TypeAlias = Literal[
+    "cursor-agent", "gemini", "crush", "q", "onlyPrepPromptFiles"
+    # warp terminal
+]
 DEFAULT_AGENT_CAP = 6
 
 
 def get_gemini_api_keys() -> list[str]:
     from machineconfig.utils.utils2 import read_ini
+
     config = read_ini(Path.home().joinpath("dotfiles/creds/llm/gemini/api_keys.ini"))
     res: list[str] = []
     for a_section_name in list(config.sections()):
@@ -45,12 +46,17 @@ def get_gemini_api_keys() -> list[str]:
 def _search_python_files(repo_root: Path, keyword: str) -> list[Path]:
     """Return all Python files under repo_root whose text contains keyword.
 
-    Errors reading individual files are ignored (decoded with 'ignore').
+    Notes:
+      - Skips any paths that reside under a directory named ".venv" at any depth.
+      - Errors reading individual files are ignored (decoded with 'ignore').
     """
     py_files = list(repo_root.rglob("*.py"))
     keyword_lower = keyword.lower()
     matches: list[Path] = []
     for f in py_files:
+        # Skip anything under a .venv directory anywhere in the path
+        if any(part == ".venv" for part in f.parts):
+            continue
         try:
             if keyword_lower in f.read_text(encoding="utf-8", errors="ignore").lower():
                 matches.append(f)
@@ -63,6 +69,8 @@ def _search_python_files(repo_root: Path, keyword: str) -> list[Path]:
 def _write_list_file(target: Path, files: Iterable[Path]) -> None:
     target.parent.mkdir(parents=True, exist_ok=True)
     target.write_text("\n".join(str(f) for f in files), encoding="utf-8")
+
+
 def _chunk_prompts(prompts: list[str], max_agents: int) -> list[str]:
     prompts = [p for p in prompts if p.strip() != ""]  # drop blank entries
     if len(prompts) <= max_agents:
@@ -73,6 +81,8 @@ def _chunk_prompts(prompts: list[str], max_agents: int) -> list[str]:
     for i in range(0, len(prompts), chunk_size):
         grouped.append("\nTargeted Locations:\n".join(prompts[i : i + chunk_size]))
     return grouped
+
+
 def _confirm(message: str, default_no: bool = True) -> bool:
     suffix = "[y/N]" if default_no else "[Y/n]"
     answer = input(f"{message} {suffix} ").strip().lower()
@@ -83,7 +93,7 @@ def _confirm(message: str, default_no: bool = True) -> bool:
     return False
 
 
-def launch_agents(repo_root: Path, prompts: list[str], agent: AGENTS, *, max_agents: int = DEFAULT_AGENT_CAP) -> TabConfig:
+def launch_agents(repo_root: Path, prompts: list[str], agent: AGENTS, *, max_agents: int = DEFAULT_AGENT_CAP) -> list[TabConfig]:
     """Create tab configuration for a set of agent prompts.
 
     If number of prompts exceeds max_agents, ask user for confirmation.
@@ -93,16 +103,12 @@ def launch_agents(repo_root: Path, prompts: list[str], agent: AGENTS, *, max_age
         raise ValueError("No prompts provided")
 
     if len(prompts) > max_agents:
-        proceed = _confirm(
-            message=(
-                f"You are about to launch {len(prompts)} agents which exceeds the cap ({max_agents}). Proceed?"
-            )
-        )
+        proceed = _confirm(message=(f"You are about to launch {len(prompts)} agents which exceeds the cap ({max_agents}). Proceed?"))
         if not proceed:
             print("Aborting per user choice.")
-            return {}
+            return []
 
-    tab_config: TabConfig = {}
+    tab_config: list[TabConfig] = []
     tmp_dir = repo_root / ".ai" / f"tmp_prompts/{randstr()}"
     tmp_dir.mkdir(parents=True, exist_ok=True)
 
@@ -145,6 +151,10 @@ crush run {prompt_path}
             case "q":
                 cmd = f"""
 q chat --no-interactive --trust-all-tools {prompt_path}
+"""
+            case "onlyPrepPromptFiles":
+                cmd = f"""
+echo "Prepared prompt file at {prompt_path}"
 """
             case _:
                 raise ValueError(f"Unsupported agent type: {agent}")
@@ -161,9 +171,9 @@ sleep 0.1
 sleep 0.1
 echo "---------END OF AGENT OUTPUT---------"
 """
-        cmd_path.write_text(cmd_prefix+cmd+cmd_postfix, encoding="utf-8")
+        cmd_path.write_text(cmd_prefix + cmd + cmd_postfix, encoding="utf-8")
         fire_cmd = f"bash {shlex.quote(str(cmd_path))}"
-        tab_config[f"Agent{idx}"] = (str(repo_root), fire_cmd)
+        tab_config.append(TabConfig(tabName=f"Agent{idx}", startDir=str(repo_root), command=fire_cmd))
 
     print(f"Launching a template with #{len(tab_config)} agents")
     return tab_config
@@ -208,20 +218,17 @@ def main():  # noqa: C901 - (complexity acceptable for CLI glue)
     combined_prompts = [prefix + "\n" + p for p in combined_prompts]
 
     from machineconfig.utils.options import choose_one_option
+
     agent_selected = choose_one_option(header="Select agent type", options=get_args(AGENTS))
 
-    tab_config = launch_agents(
-        repo_root=repo_root,
-        prompts=combined_prompts,
-        agent=agent_selected,
-        max_agents=DEFAULT_AGENT_CAP,
-    )
+    tab_config = launch_agents(repo_root=repo_root, prompts=combined_prompts, agent=agent_selected, max_agents=DEFAULT_AGENT_CAP)
     if not tab_config:
         return
 
     from machineconfig.utils.utils2 import randstr
+
     random_name = randstr(length=3)
-    manager = ZellijLocalManager(session2zellij_tabs={"Agents": tab_config}, session_name_prefix=random_name)
+    manager = ZellijLocalManager(session_layouts=[LayoutConfig(layoutName="Agents", layoutTabs=tab_config)], session_name_prefix=random_name)
     manager.start_all_sessions()
     manager.run_monitoring_routine()
 

machineconfig/scripts/python/fire_jobs.py

@@ -7,61 +7,34 @@ fire
 
 """
 
-
 from machineconfig.scripts.python.helpers.helpers4 import search_for_files_of_interest
 from machineconfig.scripts.python.helpers.helpers4 import convert_kwargs_to_fire_kwargs_str
 from machineconfig.scripts.python.helpers.helpers4 import parse_pyfile
 from machineconfig.scripts.python.helpers.helpers4 import get_import_module_code
 from machineconfig.utils.ve import get_repo_root, get_ve_activate_line, get_ve_path_and_ipython_profile
-from machineconfig.utils.utils import display_options, choose_one_option, PROGRAM_PATH, match_file_name, sanitize_path
+from machineconfig.utils.options import display_options, choose_one_option
+from machineconfig.utils.path import match_file_name, sanitize_path
+from machineconfig.utils.source_of_truth import PROGRAM_PATH
 from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from machineconfig.utils.io_save import save_toml
 from machineconfig.utils.utils2 import randstr, read_toml
+from machineconfig.scripts.python.fire_jobs_args_helper import get_args, FireJobArgs, extract_kwargs
 import platform
 from typing import Optional
-import argparse
 import os
 
 
-str2obj = {"True": True, "False": False, "None": None}
+def main(args: FireJobArgs) -> None:
+    if args.layout:
+        from machineconfig.scripts.python.fire_jobs_layout_helper import handle_layout_args
 
+        return handle_layout_args(args)
 
-def main() -> None:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("path",     nargs='?', type=str, help="The directory containing the jobs", default=".")
-    parser.add_argument("function", nargs='?', type=str, help="Fuction to run", default=None)
-    parser.add_argument("--ve",              "-v", type=str, help="virtual enviroment name", default="")
-    parser.add_argument("--cmd",             "-B", action="store_true", help="Create a cmd fire command to launch the the job asynchronously.")
-    parser.add_argument("--interactive",     "-i", action="store_true", help="Whether to run the job interactively using IPython")
-    parser.add_argument("--debug",           "-d", action="store_true", help="debug")
-    parser.add_argument("--choose_function", "-c", action="store_true", help="debug")
-    parser.add_argument("--loop",            "-l", action="store_true", help="infinite recusion (runs again after completion/interruption)")
-    parser.add_argument("--jupyter",         "-j", action="store_true", help="open in a jupyter notebook")
-    parser.add_argument("--submit_to_cloud", "-C", action="store_true", help="submit to cloud compute")
-    parser.add_argument("--remote",          "-r", action="store_true", help="launch on a remote machine")
-    parser.add_argument("--module",          "-m", action="store_true", help="launch the main file")
-    parser.add_argument("--streamlit",       "-S", action="store_true", help="run as streamlit app")
-    parser.add_argument("--environment",     "-E", type=str, help="Choose ip, localhost, hostname or arbitrary url", default="")
-    parser.add_argument("--holdDirectory",   "-D", action="store_true", help="hold current directory and avoid cd'ing to the script directory")
-    parser.add_argument("--PathExport",      "-P", action="store_true", help="augment the PYTHONPATH with repo root.")
-    parser.add_argument("--git_pull",        "-g", action="store_true", help="Start by pulling the git repo")
-    parser.add_argument("--optimized",       "-O", action="store_true", help="Run the optimized version of the function")
-    parser.add_argument("--Nprocess",        "-p", type=int, help="Number of processes to use", default=1)
-    parser.add_argument("--zellij_tab",      "-z", type=str, dest="zellij_tab", help="open in a new zellij tab")
-    parser.add_argument("--watch",           "-w", action="store_true", help="watch the file for changes")
-    parser.add_argument("--kw", nargs="*", default=None, help="keyword arguments to pass to the function in the form of k1 v1 k2 v2 ... (meaning k1=v1, k2=v2, etc)")
-    try:
-        args = parser.parse_args()
-    except Exception as ex:
-        print(f"❌ Failed to parse arguments: {ex}")
-        parser.print_help()
-        raise ex
     path_obj = sanitize_path(args.path)
-    # print(f"Passed path sanitied to {path_obj}")
     if not path_obj.exists():
-        path_obj = match_file_name(sub_string=args.path, search_root=PathExtended.cwd())
-    else: pass
-    if path_obj.is_dir():
+        suffixes = {".py", ".sh", ".ps1"}
+        choice_file = match_file_name(sub_string=args.path, search_root=PathExtended.cwd(), suffixes=suffixes)
+    elif path_obj.is_dir():
         print(f"🔍 Searching recursively for Python, PowerShell and Shell scripts in directory `{path_obj}`")
         files = search_for_files_of_interest(path_obj)
         print(f"🔍 Got #{len(files)} results.")
@@ -71,23 +44,13 @@ def main() -> None:
         choice_file = path_obj
     repo_root = get_repo_root(str(choice_file))
     print(f"💾 Selected file: {choice_file}.\nRepo root: {repo_root}")
-
     ve_root_from_file, ipy_profile = get_ve_path_and_ipython_profile(choice_file)
-    if ipy_profile is None: ipy_profile = "default"
-    activate_ve_line  = get_ve_activate_line(ve_root=args.ve or ve_root_from_file or "$HOME/code/machineconfig/.venv")
+    if ipy_profile is None:
+        ipy_profile = "default"
+    activate_ve_line = get_ve_activate_line(ve_root=args.ve or ve_root_from_file or "$HOME/code/machineconfig/.venv")
 
-    # Convert args.kw to dictionary
     if choice_file.suffix == ".py":
-        if args.kw is not None:
-            assert len(args.kw) % 2 == 0, f"args.kw must be a list of even length. Got {len(args.kw)}"
-            kwargs = dict(zip(args.kw[::2], args.kw[1::2]))
-            for key, value in kwargs.items():
-                if value in str2obj:
-                    kwargs[key] = str2obj[value]
-            if args.function is None:  # if user passed arguments and forgot to pass function, then assume they want to run the main function.
-                args.choose_function = True
-        else:
-            kwargs = {}
+        kwargs = extract_kwargs(args)
     else:
         kwargs = {}
 
@@ -99,19 +62,23 @@ def main() -> None:
             choice_function_tmp = display_options(msg="Choose a function to run", options=options, fzf=True, multi=False)
             assert isinstance(choice_function_tmp, str), f"choice_function must be a string. Got {type(choice_function_tmp)}"
             choice_index = options.index(choice_function_tmp)
-            choice_function = choice_function_tmp.split(' -- ')[0]
+            choice_function = choice_function_tmp.split(" -- ")[0]
             choice_function_args = func_args[choice_index]
 
-            if choice_function == "RUN AS MAIN": choice_function = None
+            if choice_function == "RUN AS MAIN":
+                choice_function = None
             if len(choice_function_args) > 0 and len(kwargs) == 0:
                 for item in choice_function_args:
                     kwargs[item.name] = input(f"Please enter a value for argument `{item.name}` (type = {item.type}) (default = {item.default}) : ") or item.default
         elif choice_file.suffix == ".sh":  # in this case, we choos lines.
             options = []
             for line in choice_file.read_text(encoding="utf-8").splitlines():
-                if line.startswith("#"): continue
-                if line == "": continue
-                if line.startswith("echo"): continue
+                if line.startswith("#"):
+                    continue
+                if line == "":
+                    continue
+                if line.startswith("echo"):
+                    continue
                 options.append(line)
             chosen_lines = display_options(msg="Choose a line to run", options=options, fzf=True, multi=True)
             choice_file = PathExtended.tmpfile(suffix=".sh")
@@ -124,9 +91,10 @@ def main() -> None:
     if choice_file.suffix == ".py":
         if args.streamlit:
             import socket
+
             s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
             try:
-                s.connect(('8.8.8.8', 1))
+                s.connect(("8.8.8.8", 1))
                 local_ip_v4 = s.getsockname()[0]
             except Exception:
                 local_ip_v4 = socket.gethostbyname(socket.gethostname())
@@ -140,7 +108,8 @@ def main() -> None:
                 toml_path = toml_path_maybe
             elif choice_file.parent.name == "pages":
                 toml_path_maybe = choice_file.parent.parent.joinpath(".streamlit/config.toml")
-                if toml_path_maybe.exists(): toml_path = toml_path_maybe
+                if toml_path_maybe.exists():
+                    toml_path = toml_path_maybe
             if toml_path is not None:
                 print(f"📄 Reading config.toml @ {toml_path}")
                 config = read_toml(toml_path)
@@ -152,10 +121,14 @@ def main() -> None:
                     secrets_template_path = PathExtended.home().joinpath(f"dotfiles/creds/streamlit/{PathExtended(repo_root).name}/{choice_file.name}/secrets.toml")
                     if args.environment != "" and not secrets_path.exists() and secrets_template_path.exists():
                         secrets_template = read_toml(secrets_template_path)
-                        if args.environment == "ip": host_url = f"http://{local_ip_v4}:{port}/oauth2callback"
-                        elif args.environment == "localhost": host_url = f"http://localhost:{port}/oauth2callback"
-                        elif args.environment == "hostname": host_url = f"http://{computer_name}:{port}/oauth2callback"
-                        else: host_url = f"http://{args.environment}:{port}/oauth2callback"
+                        if args.environment == "ip":
+                            host_url = f"http://{local_ip_v4}:{port}/oauth2callback"
+                        elif args.environment == "localhost":
+                            host_url = f"http://localhost:{port}/oauth2callback"
+                        elif args.environment == "hostname":
+                            host_url = f"http://{computer_name}:{port}/oauth2callback"
+                        else:
+                            host_url = f"http://{args.environment}:{port}/oauth2callback"
                         try:
                             secrets_template["auth"]["redirect_uri"] = host_url
                             secrets_template["auth"]["cookie_secret"] = randstr(35)
@@ -167,11 +140,14 @@ def main() -> None:
             message = f"🚀 Streamlit app is running @:\n1- http://{local_ip_v4}:{port}\n2- http://{computer_name}:{port}\n3- http://localhost:{port}"
             from rich.panel import Panel
             from rich import print as rprint
+
             rprint(Panel(message))
             exe = f"streamlit run --server.address 0.0.0.0 --server.headless true --server.port {port}"
             # exe = f"cd '{choice_file.parent}'; " + exe
-        elif args.interactive is False: exe = "python"
-        elif args.jupyter: exe = "jupyter-lab"
+        elif args.interactive is False:
+            exe = "python"
+        elif args.jupyter:
+            exe = "jupyter-lab"
         else:
             exe = f"ipython -i --no-banner --profile {ipy_profile} "
     elif choice_file.suffix == ".ps1" or choice_file.suffix == ".sh":
@@ -181,7 +157,9 @@ def main() -> None:
     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.
+    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}"
         import_line = get_import_module_code(str(choice_file))
         if repo_root is not None:
@@ -201,11 +179,15 @@ except (ImportError, ModuleNotFoundError) as ex:
     print(fr"✅ Successfully imported `{choice_file}`")
 """
         if choice_function is not None:
-            txt = txt + f"""
-res = {choice_function}({('**' + str(kwargs)) if kwargs else ''})
+            txt = (
+                txt
+                + f"""
+res = {choice_function}({("**" + str(kwargs)) if kwargs else ""})
 """
+            )
 
-        txt = f"""
+        txt = (
+            f"""
 try:
     from rich.panel import Panel
     from rich.console import Console
@@ -214,8 +196,10 @@ try:
     console.print(Panel(Syntax(code=r'''{txt}''', lexer='python'), title='Import Script'), style="bold red")
 except ImportError as _ex:
     print(r'''{txt}''')
-""" + txt
-        choice_file = PathExtended.tmp().joinpath(f'tmp_scripts/python/{PathExtended(choice_file).parent.name}_{PathExtended(choice_file).stem}_{randstr()}.py')
+"""
+            + txt
+        )
+        choice_file = PathExtended.tmp().joinpath(f"tmp_scripts/python/{PathExtended(choice_file).parent.name}_{PathExtended(choice_file).stem}_{randstr()}.py")
         choice_file.parent.mkdir(parents=True, exist_ok=True)
         choice_file.write_text(txt, encoding="utf-8")
 
@@ -225,7 +209,8 @@ except ImportError as _ex:
             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.")
+        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} "
@@ -249,15 +234,19 @@ except ImportError as _ex:
             # command = f"cd {choice_file.parent}\n{exe} {choice_file.name}\ncd {PathExtended.cwd()}"
             command = f"{exe} {choice_file} "
     if not args.cmd:
-        if "ipdb" in command: command = f"pip install ipdb\n{command}"
-        if "pudb" in command: command = f"pip install pudb\n{command}"
+        if "ipdb" in command:
+            command = f"pip install ipdb\n{command}"
+        if "pudb" in command:
+            command = f"pip install pudb\n{command}"
         command = f"{activate_ve_line}\n{command}"
     else:
         # CMD equivalent
-        if "ipdb" in command: command = f"pip install ipdb & {command}"
-        if "pudb" in command: command = f"pip install pudb & {command}"
+        if "ipdb" in command:
+            command = f"pip install ipdb & {command}"
+        if "pudb" in command:
+            command = f"pip install pudb & {command}"
         new_line = "\n"
-        command = fr"""start cmd -Argument "/k {activate_ve_line.replace(".ps1", ".bat").replace(". ", "")} & {command.replace(new_line, " & ")} " """  # this works from powershell
+        command = rf"""start cmd -Argument "/k {activate_ve_line.replace(".ps1", ".bat").replace(". ", "")} & {command.replace(new_line, " & ")} " """  # this works from powershell
 
     if args.submit_to_cloud:
         command = f"""
@@ -267,21 +256,13 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
             command += f"--function {choice_function} "
 
     if args.Nprocess > 1:
-        # lines = [f""" zellij action new-tab --name nProcess{randstr(2)}"""]
-        # command = command.replace(". activate_ve", ". $HOME/scripts/activate_ve")
-        # for an_arg in range(args.Nprocess):
-        #     sub_command = f"{command} --idx={an_arg} --idx_max={args.Nprocess}"
-        #     if args.optimized:
-        #         sub_command = sub_command.replace("python ", "python -OO ")
-        #     sub_command_path = PathExtended.tmpfile(suffix=".sh").write_text(sub_command, encoding="utf-8")
-        #     lines.append(f"""zellij action new-pane -- bash {sub_command_path}  """)
-        #     lines.append("sleep 5")  # python tends to freeze if you launch instances within 1 microsecond of each other
-        # command = "\n".join(lines)
-        tab_config = {}
-        for an_arg in range(args.Nprocess):
-            tab_config[f"tab{an_arg}"] = (str(PathExtended.cwd()), f"uv run -m fire {choice_file} {choice_function} --idx={an_arg} --idx_max={args.Nprocess}")
         from machineconfig.cluster.sessions_managers.zellij_local import run_zellij_layout
-        run_zellij_layout(tab_config=tab_config, session_name=None)
+        from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
+
+        layout: LayoutConfig = {"layoutName": "fireNprocess", "layoutTabs": []}
+        for an_arg in range(args.Nprocess):
+            layout["layoutTabs"].append({"tabName": f"tab{an_arg}", "startDir": str(PathExtended.cwd()), "command": f"uv run -m fire {choice_file} {choice_function} --idx={an_arg} --idx_max={args.Nprocess}"})
+        run_zellij_layout(layout_config=layout)
         return None
 
     if args.optimized:
@@ -293,6 +274,7 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
     from rich.panel import Panel
     from rich.console import Console
     from rich.syntax import Syntax
+
     console = Console()
 
     if args.zellij_tab is not None:
@@ -301,17 +283,22 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
         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 = input("Please enter a new tab 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.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:
-        if platform.system() in ["Linux", "Darwin"]: export_line = f"""export PYTHONPATH="{repo_root}""" + """:${PYTHONPATH}" """
+        if platform.system() in ["Linux", "Darwin"]:
+            export_line = f"""export PYTHONPATH="{repo_root}""" + """:${PYTHONPATH}" """
         elif platform.system() == "Windows":
             # export_line = f"""set PYTHONPATH="{repo_root}""" + """:%PYTHONPATH%" """
             # powershell equivalent
@@ -327,8 +314,8 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
             command = command + "\nsleep 0.5"
         elif platform.system() == "Windows":
             # command = command + "timeout 0.5\n"
-            #pwsh equivalent
-            command ="$ErrorActionPreference = 'SilentlyContinue';\n" + command + "\nStart-Sleep -Seconds 0.5"
+            # pwsh equivalent
+            command = "$ErrorActionPreference = 'SilentlyContinue';\n" + command + "\nStart-Sleep -Seconds 0.5"
         else:
             raise NotImplementedError(f"Platform {platform.system()} not supported.")
         command = command + f"\n. {program_path}"
@@ -337,6 +324,7 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
     program_path.write_text(command, encoding="utf-8")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # options, func_args = parse_pyfile(file_path="C:/Users/aalsaf01/code/machineconfig/myresources/crocodile/core.py")
-    main()
+    args = get_args()
+    main(args)

machineconfig/scripts/python/fire_jobs_args_helper.py

@@ -0,0 +1,84 @@
+from dataclasses import dataclass
+from typing import Optional
+import argparse
+
+
+@dataclass
+class FireJobArgs:
+    """Type-safe dataclass for fire_jobs command line arguments."""
+
+    path: str = "."
+    function: Optional[str] = None
+    ve: str = ""
+    cmd: bool = False
+    interactive: bool = False
+    debug: bool = False
+    choose_function: bool = False
+    loop: bool = False
+    jupyter: bool = False
+    submit_to_cloud: bool = False
+    remote: bool = False
+    module: bool = False
+    streamlit: bool = False
+    environment: str = ""
+    holdDirectory: bool = False
+    PathExport: bool = False
+    git_pull: bool = False
+    optimized: bool = False
+    Nprocess: int = 1
+    zellij_tab: Optional[str] = None
+    watch: bool = False
+    kw: Optional[list[str]] = None
+    layout: bool = False
+
+
+def get_args() -> FireJobArgs:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("path", nargs="?", type=str, help="The directory containing the jobs", default=".")
+    parser.add_argument("function", nargs="?", type=str, help="Fuction to run", default=None)
+    parser.add_argument("--ve", "-v", type=str, help="virtual enviroment name", default="")
+    parser.add_argument("--cmd", "-B", action="store_true", help="Create a cmd fire command to launch the the job asynchronously.")
+    parser.add_argument("--interactive", "-i", action="store_true", help="Whether to run the job interactively using IPython")
+    parser.add_argument("--debug", "-d", action="store_true", help="debug")
+    parser.add_argument("--choose_function", "-c", action="store_true", help="debug")
+    parser.add_argument("--loop", "-l", action="store_true", help="infinite recusion (runs again after completion/interruption)")
+    parser.add_argument("--jupyter", "-j", action="store_true", help="open in a jupyter notebook")
+    parser.add_argument("--submit_to_cloud", "-C", action="store_true", help="submit to cloud compute")
+    parser.add_argument("--remote", "-r", action="store_true", help="launch on a remote machine")
+    parser.add_argument("--module", "-m", action="store_true", help="launch the main file")
+    parser.add_argument("--streamlit", "-S", action="store_true", help="run as streamlit app")
+    parser.add_argument("--environment", "-E", type=str, help="Choose ip, localhost, hostname or arbitrary url", default="")
+    parser.add_argument("--holdDirectory", "-D", action="store_true", help="hold current directory and avoid cd'ing to the script directory")
+    parser.add_argument("--PathExport", "-P", action="store_true", help="augment the PYTHONPATH with repo root.")
+    parser.add_argument("--git_pull", "-g", action="store_true", help="Start by pulling the git repo")
+    parser.add_argument("--optimized", "-O", action="store_true", help="Run the optimized version of the function")
+    parser.add_argument("--Nprocess", "-p", type=int, help="Number of processes to use", default=1)
+    parser.add_argument("--zellij_tab", "-z", type=str, dest="zellij_tab", help="open in a new zellij tab")
+    parser.add_argument("--watch", "-w", action="store_true", help="watch the file for changes")
+    parser.add_argument("--kw", nargs="*", default=None, help="keyword arguments to pass to the function in the form of k1 v1 k2 v2 ... (meaning k1=v1, k2=v2, etc)")
+    parser.add_argument("--layout", "-L", action="store_true", help="use layout configuration (Zellij Or WindowsTerminal)")
+
+    try:
+        args_raw = parser.parse_args()
+    except Exception as ex:
+        print(f"❌ Failed to parse arguments: {ex}")
+        parser.print_help()
+        raise ex
+    args = FireJobArgs(**vars(args_raw))
+    return args
+
+
+def extract_kwargs(args: FireJobArgs) -> dict[str, object]:
+    str2obj = {"True": True, "False": False, "None": None}
+    if args.kw is not None:
+        assert len(args.kw) % 2 == 0, f"args.kw must be a list of even length. Got {len(args.kw)}"
+        kwargs = dict(zip(args.kw[::2], args.kw[1::2]))
+        kwargs: dict[str, object]
+        for key, value in kwargs.items():
+            if value in str2obj:
+                kwargs[key] = str2obj[str(value)]
+        if args.function is None:  # if user passed arguments and forgot to pass function, then assume they want to run the main function.
+            args.choose_function = True
+    else:
+        kwargs = {}
+    return kwargs

machineconfig/scripts/python/fire_jobs_layout_helper.py

@@ -0,0 +1,66 @@
+from pathlib import Path
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig, LayoutsFile
+from typing import Optional, TYPE_CHECKING
+from machineconfig.scripts.python.helpers.helpers4 import search_for_files_of_interest
+from machineconfig.utils.options import choose_one_option
+from machineconfig.utils.path import match_file_name, sanitize_path
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
+
+if TYPE_CHECKING:
+    from machineconfig.scripts.python.fire_jobs_args_helper import FireJobArgs
+
+
+def select_layout(layouts_json_file: Path, layout_name: Optional[str]):
+    import json
+
+    layout_file: LayoutsFile = json.loads(layouts_json_file.read_text(encoding="utf-8"))
+    if len(layout_file["layouts"]) == 0:
+        raise ValueError(f"No layouts found in {layouts_json_file}")
+    if layout_name is None:
+        options = [layout["layoutName"] for layout in layout_file["layouts"]]
+        from machineconfig.utils.options import choose_one_option
+
+        layout_name = choose_one_option(options=options, prompt="Choose a layout configuration:", fzf=True)
+    print(f"Selected layout: {layout_name}")
+    layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"] == layout_name), None)
+    if layout_chosen is None:
+        layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"].lower() == layout_name.lower()), None)
+    if layout_chosen is None:
+        available_layouts = [layout["layoutName"] for layout in layout_file["layouts"]]
+        raise ValueError(f"Layout '{layout_name}' not found. Available layouts: {available_layouts}")
+    return layout_chosen
+
+
+def launch_layout(layout_config: LayoutConfig) -> Optional[Exception]:
+    import platform
+
+    if platform.system() == "Linux" or platform.system() == "Darwin":
+        print("🧑‍💻 Launching layout using Zellij terminal multiplexer...")
+        from machineconfig.cluster.sessions_managers.zellij_local import run_zellij_layout
+
+        run_zellij_layout(layout_config=layout_config)
+    elif platform.system() == "Windows":
+        print("🧑‍💻 Launching layout using Windows Terminal...")
+        from machineconfig.cluster.sessions_managers.wt_local import run_wt_layout
+
+        run_wt_layout(layout_config=layout_config)
+    else:
+        print(f"❌ Unsupported platform: {platform.system()}")
+    return None
+
+
+def handle_layout_args(args: "FireJobArgs") -> None:
+    # args.function = args.path
+    # args.path = "layout.json"
+    path_obj = sanitize_path(args.path)
+    if not path_obj.exists():
+        choice_file = match_file_name(sub_string=args.path, search_root=PathExtended.cwd(), suffixes={".json"})
+    elif path_obj.is_dir():
+        print(f"🔍 Searching recursively for Python, PowerShell and Shell scripts in directory `{path_obj}`")
+        files = search_for_files_of_interest(path_obj)
+        print(f"🔍 Got #{len(files)} results.")
+        choice_file = choose_one_option(options=files, fzf=True)
+        choice_file = PathExtended(choice_file)
+    else:
+        choice_file = path_obj
+    launch_layout(layout_config=select_layout(layouts_json_file=choice_file, layout_name=args.function))