machineconfig 3.99__py3-none-any.whl → 7.66__py3-none-any.whl

machineconfig/scripts/python/fire_jobs.py

@@ -7,150 +7,65 @@ fire
 
 """
 
-from machineconfig.scripts.python.helpers.helpers4 import search_for_files_of_interest
-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_ve_activate_line, get_ve_path_and_ipython_profile
-from machineconfig.utils.options import choose_from_options
-from machineconfig.utils.path_helper import match_file_name, sanitize_path
-
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-from machineconfig.utils.accessories import get_repo_root, randstr
-from machineconfig.scripts.python.fire_jobs_args_helper import FireJobArgs, extract_kwargs, parse_fire_args_from_context
-import platform
 from typing import Optional, Annotated
-from pathlib import Path
-import tomllib
 import typer
-# import os
 
 
-def route(args: FireJobArgs, fire_args: str = "") -> None:
-    if args.layout:
-        from machineconfig.scripts.python.fire_jobs_layout_helper import handle_layout_args
-
-        return handle_layout_args(args)
-
-    path_obj = sanitize_path(args.path)
-    if not path_obj.exists():
-        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.")
-        choice_file = choose_from_options(multi=False, options=files, fzf=True, msg="Choose one option")
-        choice_file = PathExtended(choice_file)
-    else:
-        choice_file = path_obj
-    repo_root = get_repo_root(Path(choice_file))
+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}")
-    ve_root_from_file, ipy_profile = get_ve_path_and_ipython_profile(choice_file)
-    if ipy_profile is None:
-        ipy_profile = "default"
+    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":
-        kwargs = extract_kwargs(args)  # This now returns empty dict, but kept for compatibility
-        activate_ve_line = get_ve_activate_line(ve_root=args.ve or ve_root_from_file or "$HOME/code/machineconfig/.venv")
+        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:
-        activate_ve_line = ""
-        kwargs = {}
+        kwargs_dict = {}
 
     # =========================  choosing function to run
     choice_function: Optional[str] = None  # Initialize to avoid unbound variable
-    if args.choose_function or args.submit_to_cloud:
-        if choice_file.suffix == ".py":
-            options, func_args = parse_pyfile(file_path=str(choice_file))
-            choice_function_tmp = choose_from_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_args = func_args[choice_index]
-
-            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
-                options.append(line)
-            chosen_lines = choose_from_options(msg="Choose a line to run", options=options, fzf=True, multi=True)
-            choice_file = PathExtended.tmpfile(suffix=".sh")
-            choice_file.parent.mkdir(parents=True, exist_ok=True)
-            choice_file.write_text("\n".join(chosen_lines), encoding="utf-8")
-            choice_function = None
+    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":
+        from machineconfig.scripts.python.helpers_fire_command.fire_jobs_route_helper import get_command_streamlit
+
+        with_project = f"--project {repo_root} " if repo_root is not None else ""
         if args.streamlit:
-            import socket
-            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            try:
-                s.connect(("8.8.8.8", 1))
-                local_ip_v4 = s.getsockname()[0]
-            except Exception:
-                local_ip_v4 = socket.gethostbyname(socket.gethostname())
-            finally:
-                s.close()
-            computer_name = platform.node()
-            port = 8501
-            toml_path: Optional[PathExtended] = None
-            toml_path_maybe = choice_file.parent.joinpath(".streamlit/config.toml")
-            if toml_path_maybe.exists():
-                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 is not None:
-                print(f"📄 Reading config.toml @ {toml_path}")
-                config = tomllib.loads(toml_path.read_text(encoding="utf-8"))
-                if "server" in config:
-                    if "port" in config["server"]:
-                        port = config["server"]["port"]
-                secrets_path = toml_path.with_name("secrets.toml")
-                if repo_root is not 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 = tomllib.loads(secrets_template_path.read_text(encoding="utf-8"))
-                        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)
-                            secrets_template["auth"]["auth0"]["redirect_uri"] = host_url
-                            # save_toml(obj=secrets_template, path=secrets_path)
-                        except Exception as ex:
-                            print(ex)
-                            raise ex
-            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"
+            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 = "jupyter-lab"
+            exe = f"uv run {with_project} jupyter-lab"
         else:
-            exe = f"ipython -i --no-banner --profile {ipy_profile} "
+            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(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 == "":
@@ -158,54 +73,38 @@ def route(args: FireJobArgs, fire_args: str = "") -> 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:
-            repo_root_add = f"""sys.path.append(r'{repo_root}')"""
-        else:
-            repo_root_add = ""
-        txt: str = f"""
-try:
-    {import_line}
-except (ImportError, ModuleNotFoundError) as ex:
-    print(fr"❌ Failed to import `{choice_file}` as a module: {{ex}} ")
-    print(fr"⚠️ Attempting import with ad-hoc `$PATH` manipulation. DO NOT pickle any objects in this session as correct deserialization cannot be guaranteed.")
-    import sys
-    sys.path.append(r'{PathExtended(choice_file).parent}')
-    {repo_root_add}
-    from {PathExtended(choice_file).stem} import *
-    print(fr"✅ Successfully imported `{choice_file}`")
-"""
-        if choice_function is not None:
-            txt = (
-                txt
-                + f"""
-res = {choice_function}({("**" + str(kwargs)) if kwargs else ""})
-"""
-            )
-
-        txt = (
-            f"""
-try:
-    from rich.panel import Panel
-    from rich.console import Console
-    from rich.syntax import Syntax
-    console = Console()
-    console.print(Panel(Syntax(code=r'''{txt}''', lexer='python'), title='Import Script'), style="bold red")
-except ImportError as _ex:
-    print(r'''{txt}''')
-"""
-            + txt
+        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,
         )
-        choice_file = PathExtended.tmp().joinpath(f"tmp_scripts/python/{PathExtended(choice_file).parent.name}_{PathExtended(choice_file).stem}_{randstr()}.py")
+        # 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(txt, encoding="utf-8")
+        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"]:
@@ -215,69 +114,42 @@ except ImportError as _ex:
     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:
+    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 {PathExtended.cwd()}"
-
+            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"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}"
-        command = f"{activate_ve_line}\n{command}"
+        pass
     else:
-        # CMD equivalent
-        if "ipdb" in command:
-            command = f"pip install ipdb & {command}"
-        if "pudb" in command:
-            command = f"pip install pudb & {command}"
         new_line = "\n"
-        command = rf"""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 {command.replace(new_line, " & ")} " """  # this works from powershell
     if args.submit_to_cloud:
-        command = f"""
-{activate_ve_line}
-python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
+        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.Nprocess > 1:
-        from machineconfig.cluster.sessions_managers.zellij_local import run_zellij_layout
-        from machineconfig.utils.schemas.layouts.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:
-        # note that in ipython, optimization is meaningless.
         command = command.replace("python ", "python -OO ")
-    # if platform.system() == "Linux":
-    #     command = "timeout 1s aafire -driver slang\nclear\n" + command
 
     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__ = PathExtended.tmpfile(suffix=".sh")
+        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")
@@ -286,7 +158,6 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
         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
 
@@ -296,37 +167,25 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
     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}" """
-        elif platform.system() == "Windows":
-            # export_line = f"""set PYTHONPATH="{repo_root}""" + """:%PYTHONPATH%" """
-            # powershell equivalent
-            export_line = f"""$env:PYTHONPATH="{repo_root}""" + """:$env:PYTHONPATH" """
-        else:
-            raise NotImplementedError(f"Platform {platform.system()} not supported.")
-        command = export_line + "\n" + command
+        from machineconfig.scripts.python.helpers_fire_command.file_wrangler import add_to_path
 
-    # program_path = os.environ.get("op_script", None)
-    # program_path = PathExtended(program_path) if program_path is not None else PROGRAM_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 = command + "timeout 0.5\n"
-            # 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}"
-    console.print(Panel(Syntax(command, lexer="shell"), title=f"🔥 fire command @ {command}: "), style="bold red")
-    # program_path.parent.mkdir(parents=True, exist_ok=True)
-    # program_path.write_text(command, encoding="utf-8")
-    import subprocess
 
-    subprocess.run(command, shell=True, check=True)
+    from machineconfig.utils.code import exit_then_run_shell_script
+
+    exit_then_run_shell_script(script=command, strict=False)
 
 
-def main(
+def fire(
     ctx: typer.Context,
     path: Annotated[str, typer.Argument(help="Path to the Python file to run")] = ".",
     function: Annotated[Optional[str], typer.Argument(help="Function to run")] = None,
@@ -334,28 +193,30 @@ def main(
     cmd: Annotated[bool, typer.Option("--cmd", "-B", help="Create a cmd fire command to launch the job asynchronously")] = False,
     interactive: Annotated[bool, typer.Option("--interactive", "-i", help="Whether to run the job interactively using IPython")] = False,
     debug: Annotated[bool, typer.Option("--debug", "-d", help="Enable debug mode")] = False,
-    choose_function: Annotated[bool, typer.Option("--choose_function", "-c", help="Choose function interactively")] = False,
+    choose_function: Annotated[bool, typer.Option("--choose-function", "-c", help="Choose function interactively")] = False,
     loop: Annotated[bool, typer.Option("--loop", "-l", help="Infinite recursion (runs again after completion/interruption)")] = False,
     jupyter: Annotated[bool, typer.Option("--jupyter", "-j", help="Open in a jupyter notebook")] = False,
-    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,
+    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,
+    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,
-    optimized: Annotated[bool, typer.Option("--optimized", "-O", help="Run the optimized version of the function")] = False,
-    Nprocess: Annotated[int, typer.Option("--Nprocess", "-p", help="Number of processes to use")] = 1,
-    zellij_tab: Annotated[Optional[str], typer.Option("--zellij_tab", "-z", help="Open in a new zellij tab")] = None,
+    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,
-    layout: Annotated[bool, typer.Option("--layout", "-L", help="Use layout configuration (Zellij Or WindowsTerminal)")] = False,
 ) -> None:
     """Main function to process fire jobs arguments."""
-    
+
     # 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(
         path=path,
         function=function,
@@ -366,6 +227,7 @@ def main(
         choose_function=choose_function,
         loop=loop,
         jupyter=jupyter,
+        marimo=marimo,
         submit_to_cloud=submit_to_cloud,
         remote=remote,
         module=module,
@@ -375,10 +237,8 @@ def main(
         PathExport=PathExport,
         git_pull=git_pull,
         optimized=optimized,
-        Nprocess=Nprocess,
         zellij_tab=zellij_tab,
         watch=watch,
-        layout=layout,
     )
     try:
         route(args, fire_args)
@@ -388,21 +248,23 @@ def main(
     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 main_from_parser():
-    # from trogon.typer import init_tui
-    # from trogon.typer import init_tui
+def get_app():
     from typer import Typer
+
     app = Typer(add_completion=False)
-    app.command(context_settings={"allow_extra_args": True, "allow_interspersed_args": False})(main)
-    # typer.run(main)
-    # init_tui(app)
+    app.command(context_settings={"allow_extra_args": True, "allow_interspersed_args": False})(fire)
+    return app
+
+
+def main():
+    app = get_app()
     app()
 
 
 if __name__ == "__main__":
-    # options, func_args = parse_pyfile(file_path="C:/Users/aalsaf01/code/machineconfig/myresources/crocodile/core.py")
-    main_from_parser()
+    from machineconfig.scripts.python.helpers_fire_command.fire_jobs_args_helper import FireJobArgs