machineconfig 8.14__py3-none-any.whl → 8.45__py3-none-any.whl

machineconfig/scripts/python/mcfg_entry.py

@@ -1,55 +1,140 @@
-
-from machineconfig.scripts.python.devops import get_app as get_devops_app
-from machineconfig.scripts.python.cloud import get_app as get_cloud_app
-from machineconfig.scripts.python.agents import get_app as get_agents_app
-from machineconfig.scripts.python.sessions import get_app as get_sessions_app
-from machineconfig.scripts.python.utils import get_app as get_utils_app
-
-from machineconfig.scripts.python.ftpx import ftpx as ftpx_func
-from machineconfig.scripts.python.croshell import croshell as croshell_func
-from machineconfig.scripts.python.fire_jobs import fire as get_fire_jobs_app
-from machineconfig.scripts.python.terminal import get_app as get_terminal_app
-
-def get_app():
-    import typer
-    app = typer.Typer(help="MachineConfig CLI - Manage your machine configurations and workflows", no_args_is_help=True, add_help_option=False, add_completion=False)
-    devops_app = get_devops_app()
-    app.add_typer(devops_app, name="devops", help="[d] DevOps related commands", no_args_is_help=True)
-    app.add_typer(devops_app, name="d", hidden=True)  # short alias
-
-    cloud_app = get_cloud_app()
-    app.add_typer(cloud_app, name="cloud", help="[c] Cloud management commands", no_args_is_help=True)
-    app.add_typer(cloud_app, name="c", hidden=True)  # short alias
-
-    sessions_app = get_sessions_app()
-    app.add_typer(sessions_app, name="sessions", help="[s] Session and layout management", no_args_is_help=True)
-    app.add_typer(sessions_app, name="s", hidden=True)  # short alias
-
-
-    agents_app = get_agents_app()
-    app.add_typer(agents_app, name="agents", help="[a] 🤖 AI Agents management commands", no_args_is_help=True)
-    app.add_typer(agents_app, name="a", hidden=True)  # short alias
-
-    app.command(name="fire", help="[f] Fire and manage jobs", no_args_is_help=False)(get_fire_jobs_app)
-    app.command(name="f", hidden=True, no_args_is_help=False)(get_fire_jobs_app)
-    app.command("ftpx", no_args_is_help=True, help="[ff] File transfer utility though SSH")(ftpx_func)
-    app.command("ff", no_args_is_help=True, hidden=True)(ftpx_func)  # short alias
-    app.command("croshell", no_args_is_help=False, help="[r] Cross-shell command execution")(croshell_func)
-    app.command("r", no_args_is_help=False, hidden=True)(croshell_func)  # short alias
-
-    utils_app = get_utils_app()
-    app.add_typer(utils_app, name="utils", help="[u] Utility commands", no_args_is_help=True)
-    app.add_typer(utils_app, name="u", hidden=True)  # short alias
-
-
-    terminal_app = get_terminal_app()
-    app.add_typer(terminal_app, name="terminal", help="[t] Terminal management commands", no_args_is_help=True)
-    app.add_typer(terminal_app, name="t", hidden=True)  # short alias
+"""Fast-loading CLI entry point using lazy imports.
+
+Submodules are only imported when their commands are actually invoked, not at startup.
+This makes `mcfg --help` much faster by avoiding loading heavy dependencies.
+"""
+from typing import Optional, Annotated
+import typer
+
+
+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,
+    ve: Annotated[str, typer.Option("--ve", "-v", help="Virtual environment name")] = "",
+    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,
+    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,
+    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,
+    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:
+    """Fire and manage jobs."""
+    from machineconfig.scripts.python.fire_jobs import fire as fire_impl
+    fire_impl(ctx=ctx, path=path, function=function, ve=ve, cmd=cmd, interactive=interactive, debug=debug,
+              choose_function=choose_function, loop=loop, jupyter=jupyter, marimo=marimo, module=module,
+              script=script, optimized=optimized, zellij_tab=zellij_tab, submit_to_cloud=submit_to_cloud,
+              remote=remote, streamlit=streamlit, environment=environment, holdDirectory=holdDirectory,
+              PathExport=PathExport, git_pull=git_pull, watch=watch)
+
+
+def ftpx(
+    source: Annotated[str, typer.Argument(help="Source path (machine:path)")],
+    target: Annotated[str, typer.Argument(help="Target path (machine:path)")],
+    recursive: Annotated[bool, typer.Option("--recursive", "-r", help="Send recursively.")] = False,
+    zipFirst: Annotated[bool, typer.Option("--zipFirst", "-z", help="Zip before sending.")] = False,
+    cloud: Annotated[bool, typer.Option("--cloud", "-c", help="Transfer through the cloud.")] = False,
+    overwrite_existing: Annotated[bool, typer.Option("--overwrite-existing", "-o", help="Overwrite existing files on remote when sending from local to remote.")] = False,
+) -> None:
+    """File transfer utility though SSH."""
+    from machineconfig.scripts.python.ftpx import ftpx as ftpx_impl
+    ftpx_impl(source=source, target=target, recursive=recursive, zipFirst=zipFirst, cloud=cloud, overwrite_existing=overwrite_existing)
+
+
+def croshell(
+    path: Annotated[Optional[str], typer.Argument(help="path of file to read.")] = None,
+    project_path: Annotated[Optional[str], typer.Option("--project", "-p", help="specify uv project to use")] = None,
+    uv_with: Annotated[Optional[str], typer.Option("--uv-with", "-w", help="specify uv with packages to use")] = None,
+    marimo: Annotated[bool, typer.Option("--marimo", "-m", help="open the notebook using marimo if available")] = False,
+    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,
+    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:
+    """Cross-shell command execution."""
+    from machineconfig.scripts.python.croshell import croshell as croshell_impl
+    croshell_impl(path=path, project_path=project_path, uv_with=uv_with, marimo=marimo, jupyter=jupyter, vscode=vscode, visidata=visidata, python=python, profile=profile)
+
+
+def devops(ctx: typer.Context) -> None:
+    """[d] DevOps related commands."""
+    from machineconfig.scripts.python.devops import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def cloud(ctx: typer.Context) -> None:
+    """[c] Cloud management commands."""
+    from machineconfig.scripts.python.cloud import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def sessions(ctx: typer.Context) -> None:
+    """[s] Session and layout management."""
+    from machineconfig.scripts.python.sessions import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def agents(ctx: typer.Context) -> None:
+    """[a] 🤖 AI Agents management commands."""
+    from machineconfig.scripts.python.agents import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def utils(ctx: typer.Context) -> None:
+    """[u] Utility commands."""
+    from machineconfig.scripts.python.utils import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def terminal(ctx: typer.Context) -> None:
+    """[t] Terminal management commands."""
+    from machineconfig.scripts.python.terminal import get_app
+    get_app()(ctx.args, standalone_mode=not ctx.args)
+
+
+def get_app() -> typer.Typer:
+    app = typer.Typer(help="MachineConfig CLI - Manage your machine configurations and workflows", 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": []}
+
+    app.command(name="devops", help="[d] DevOps related commands", context_settings=ctx_settings)(devops)
+    app.command(name="d", hidden=True, context_settings=ctx_settings)(devops)
+    app.command(name="cloud", help="[c] Cloud management commands", context_settings=ctx_settings)(cloud)
+    app.command(name="c", hidden=True, context_settings=ctx_settings)(cloud)
+    app.command(name="sessions", help="[s] Session and layout management", context_settings=ctx_settings)(sessions)
+    app.command(name="s", hidden=True, context_settings=ctx_settings)(sessions)
+    app.command(name="agents", help="[a] 🤖 AI Agents management commands", context_settings=ctx_settings)(agents)
+    app.command(name="a", hidden=True, context_settings=ctx_settings)(agents)
+    app.command(name="utils", help="[u] Utility commands", context_settings=ctx_settings)(utils)
+    app.command(name="u", hidden=True, context_settings=ctx_settings)(utils)
+    app.command(name="terminal", help="[t] Terminal management commands", context_settings=ctx_settings)(terminal)
+    app.command(name="t", hidden=True, context_settings=ctx_settings)(terminal)
+
+    app.command(name="fire", help="[f] Fire and manage jobs", no_args_is_help=False, context_settings={"allow_extra_args": True, "allow_interspersed_args": False})(fire)
+    app.command(name="f", hidden=True, no_args_is_help=False, context_settings={"allow_extra_args": True, "allow_interspersed_args": False})(fire)
+    app.command("ftpx", no_args_is_help=True, help="[ff] File transfer utility though SSH")(ftpx)
+    app.command("ff", no_args_is_help=True, hidden=True)(ftpx)
+    app.command("croshell", no_args_is_help=False, help="[r] Cross-shell command execution")(croshell)
+    app.command("r", no_args_is_help=False, hidden=True)(croshell)
 
     return app
 
 
-def main():
+def main() -> None:
     app = get_app()
     app()
 

machineconfig/scripts/python/msearch.py

@@ -1,72 +1,26 @@
+"""msearch - Machineconfig search helper."""
 
 import typer
 from typing import Annotated
 
 
 def machineconfig_search(
-        directory: Annotated[str, typer.Option(..., "--directory", "-d", help="The directory to search")] = ".",
-        ast: Annotated[bool, typer.Option(..., "--ast", "-a", help="The abstract syntax tree search/ tree sitter search of symbols")] = False,
-        symantic: Annotated[bool, typer.Option(..., "--symantic", "-s", help="The symantic search of symbols")] = False,
-        extension: Annotated[str, typer.Option(..., "--extension", "-e", help="File extension to filter by (e.g., .py, .js)")] = "",
-        file: Annotated[bool, typer.Option(..., "--file", "-f", help="File search using fzf")] = False,
-        no_dotfiles: Annotated[bool, typer.Option(..., "--no-dotfiles", "-D", help="Exclude dotfiles from search")] = False,
-        rga: Annotated[bool, typer.Option(..., "--rga", "-A", help="Use ripgrep-all for searching all (non text files) instead of ripgrep")] = False,
-        install_dependencies: Annotated[bool, typer.Option(..., "--install-req", "-p", help="Install required dependencies if missing")] = False
-        ):
-    """machineconfig search helper"""
-    if install_dependencies:
-        from machineconfig.utils.installer_utils.installer_cli import install_if_missing
-        install_if_missing("fzf")
-        install_if_missing("tv")
-        install_if_missing("bat")
-        install_if_missing("fd")
-        install_if_missing("rg")  # ripgrep
-        install_if_missing("rga")  # ripgrep-all
-        # install_if_missing("tree-sitter-cli")
-        return
-    if symantic:
-        script = ""
-        for an_ex in extension.split(","):
-            script = script + f"""\nparse *.{an_ex} """
-        from machineconfig.utils.code import run_shell_script
-        run_shell_script(script=script)
-        return
-    if ast:
-        from machineconfig.scripts.python.helpers.ast_search import get_repo_symbols
-        symbols = get_repo_symbols(directory)
-        from machineconfig.utils.options import choose_from_options
-        try:
-            res = choose_from_options(options=symbols, msg="Select a symbol to search for:", tv=True, multi=False)
-            from rich import print_json
-            import json
-            res_json = json.dumps(res, indent=4)
-            print_json(res_json)
-            return None
-        except Exception as e:
-            print(f"❌ Error during selection: {e}")
-            return None
-    if file:
-        script = """fzf --ansi --preview-window 'right:60%' --preview 'bat --color=always --style=numbers,grid,header --line-range :300 {}' """
-        if no_dotfiles:
-            script = "fd | " + script
-        from machineconfig.utils.code import run_shell_script
-        run_shell_script(script=script)
-        return
-    from machineconfig.scripts.python.helpers_msearch import FZFG_LINUX_PATH, FZFG_WINDOWS_PATH
-    import platform
-    if platform.system() == "Linux" or platform.system() == "Darwin":
-        script = FZFG_LINUX_PATH.read_text(encoding="utf-8")
-    elif platform.system() == "Windows":
-        script = FZFG_WINDOWS_PATH.read_text(encoding="utf-8")
-    else:
-        raise RuntimeError("Unsupported platform")
-    if rga:
-        script = script.replace("rg ", "rga ").replace("ripgrep", "ripgrep-all")
-    from machineconfig.utils.code import exit_then_run_shell_script
-    exit_then_run_shell_script(script=script, strict=False)
+    path: Annotated[str, typer.Argument(help="The directory/file to search")] = ".",
+    ast: Annotated[bool, typer.Option(..., "--ast", "-a", help="The abstract syntax tree search/ tree sitter search of symbols")] = False,
+    symantic: Annotated[bool, typer.Option(..., "--symantic", "-s", help="The symantic search of symbols")] = False,
+    extension: Annotated[str, typer.Option(..., "--extension", "-E", help="File extension to filter by (e.g., .py, .js)")] = "",
+    file: Annotated[bool, typer.Option(..., "--file", "-f", help="File search using fzf")] = False,
+    no_dotfiles: Annotated[bool, typer.Option(..., "--no-dotfiles", "-D", help="Exclude dotfiles from search")] = False,
+    rga: Annotated[bool, typer.Option(..., "--rga", "-A", help="Use ripgrep-all for searching all (non text files) instead of ripgrep")] = False,
+    edit: Annotated[bool, typer.Option(..., "--edit", "-e", help="Open selection in editor (helix)")] = False,
+    install_dependencies: Annotated[bool, typer.Option(..., "--install-req", "-i", help="Install required dependencies if missing")] = False,
+) -> None:
+    """Machineconfig search helper."""
+    from machineconfig.scripts.python.helpers.helpers_msearch.msearch_impl import machineconfig_search as impl
+    impl(path=path, ast=ast, symantic=symantic, extension=extension, file=file, no_dotfiles=no_dotfiles, rga=rga, edit=edit, install_dependencies=install_dependencies)
 
 
-def main():
+def main() -> None:
     app = typer.Typer(add_completion=False, no_args_is_help=True)
     app.command(name="msearch", help=machineconfig_search.__doc__, short_help="machineconfig search helper", no_args_is_help=False)(machineconfig_search)
     app()

machineconfig/scripts/python/sessions.py

@@ -1,205 +1,70 @@
+"""Sessions management commands - lazy loading subcommands."""
 
 from typing import Optional, Literal, Annotated
 import typer
 
 
-def balance_load(layout_path: Annotated[str, typer.Argument(..., help="Path to the layout.json file")],
-           max_thresh: Annotated[int, typer.Option(..., "--max-threshold", "-m", help="Maximum tabs per layout")],
-           thresh_type: Annotated[Literal['number', 'n', 'weight', 'w'], typer.Option(..., "--threshold-type", "-t", help="Threshold type")],
-           breaking_method: Annotated[Literal['moreLayouts', 'ml', 'combineTabs', 'ct'], typer.Option(..., "--breaking-method", "-b", help="Breaking method")],
-           output_path: Annotated[Optional[str], typer.Option(..., "--output-path", "-o", help="Path to write the adjusted layout.json file")] = None):
+def balance_load(
+    layout_path: Annotated[str, typer.Argument(..., help="Path to the layout.json file")],
+    max_thresh: Annotated[int, typer.Option(..., "--max-threshold", "-m", help="Maximum tabs per layout")],
+    thresh_type: Annotated[Literal["number", "n", "weight", "w"], typer.Option(..., "--threshold-type", "-t", help="Threshold type")],
+    breaking_method: Annotated[Literal["moreLayouts", "ml", "combineTabs", "ct"], typer.Option(..., "--breaking-method", "-b", help="Breaking method")],
+    output_path: Annotated[Optional[str], typer.Option(..., "--output-path", "-o", help="Path to write the adjusted layout.json file")] = None,
+) -> None:
     """Adjust layout file to limit max tabs per layout, etc."""
-    thresh_type_resolved: dict[str, Literal['number', 'weight']] = {
-        'number': 'number',
-        'n': 'number',
-        'weight': 'weight',
-        'w': 'weight'
-    }
-    breaking_method_resolved: dict[str, Literal['moreLayouts', 'combineTabs']] = {
-        'moreLayouts': 'moreLayouts',
-        'ml': 'moreLayouts',
-        'combineTabs': 'combineTabs',
-        'ct': 'combineTabs'
-    }
-    from pathlib import Path
-    layout_path_obj = Path(layout_path).expanduser().absolute()
-
-    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
-    import json
-    layoutfile: LayoutsFile = json.loads(layout_path_obj.read_text())
-    layout_configs = layoutfile["layouts"]
-    from machineconfig.cluster.sessions_managers.utils.load_balancer import limit_tab_num
-    new_layouts = limit_tab_num(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=thresh_type_resolved[thresh_type], breaking_method=breaking_method_resolved[breaking_method])
-    layoutfile["layouts"] = new_layouts
-    target_file = Path(output_path) if output_path is not None else layout_path_obj.parent / f'{layout_path_obj.stem}_adjusted_{max_thresh}_{thresh_type}_{breaking_method}.json'
-    target_file.parent.mkdir(parents=True, exist_ok=True)
-    target_file.write_text(data=json.dumps(layoutfile, indent=4), encoding="utf-8")
-    typer.echo(f"Adjusted layout saved to {target_file}")
-
-
-def select_layout(layouts_json_file: str, selected_layouts_names: Optional[list[str]], select_interactively: bool,
-                  subsitute_home: bool
-                  ) -> list["LayoutConfig"]:
-    import json
-    from machineconfig.utils.options import choose_from_options
-    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
-    from pathlib import Path
-    json_str = Path(layouts_json_file).read_text(encoding="utf-8")
-    if subsitute_home:
-        json_str = json_str.replace("~", str(Path.home())).replace("$HOME", str(Path.home()))
-        json_str = json_str.replace("""Command": "f """, """Command": "~/.config/machineconfig/scripts/wrap_mcfg fire """)
-        json_str = json_str.replace("""Command": "s """, """Command": "~/.config/machineconfig/scripts/wrap_mcfg sessions """)
-
-    layout_file: LayoutsFile = json.loads(json_str)
-    if len(layout_file["layouts"]) == 0:
-        raise ValueError(f"No layouts found in {layouts_json_file}")
-    if selected_layouts_names is None:  # choose all, or interactively
-        if not select_interactively:
-            return layout_file["layouts"]
-        options = [layout["layoutName"] for layout in layout_file["layouts"]]
-        from machineconfig.utils.options import choose_from_options
-        selected_layouts_names = choose_from_options(multi=True, options=options, prompt="Choose a layout configuration:", tv=True, msg="Choose one option")
-    print(f"Selected layout(s): {selected_layouts_names}")
-    # Extract the configs from the names:
-    layouts_chosen: list[LayoutConfig] = []
-    for name in selected_layouts_names:
-        layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"] == name), None)
-        if layout_chosen is None:
-            layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"].lower() == name.lower()), None)
-        if layout_chosen is None:
-            available_layouts = [layout["layoutName"] for layout in layout_file["layouts"]]
-            raise ValueError(f"Layout '{name}' not found. Available layouts: {available_layouts}")
-        layouts_chosen.append(layout_chosen)
-    return layouts_chosen
-
-
-def find_layout_file(layout_path: str, ) -> str:
-    from machineconfig.utils.path_helper import search_for_files_of_interest
-    from machineconfig.utils.options import choose_from_options
-    from machineconfig.utils.path_helper import match_file_name, sanitize_path
-    from pathlib import Path
-    path_obj = sanitize_path(layout_path)
-    if not path_obj.exists():
-        choice_file = match_file_name(sub_string=layout_path, search_root=Path.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, suffixes={".py", ".sh", ".ps1"})
-        print(f"🔍 Got #{len(files)} results.")
-        choice_file = choose_from_options(multi=False, options=files, tv=True, msg="Choose one option")
-        choice_file = Path(choice_file).expanduser().absolute()
-    else:
-        choice_file = path_obj
-    return str(choice_file)
-
-
-def run(ctx: typer.Context,
-           layout_path: Annotated[Optional[str], typer.Argument(..., help="Path to the layout.json file")] = None,
-        max_tabs: Annotated[int, typer.Option(..., "--max-tabs", "-mt", help="A Sanity checker that throws an error if any layout exceeds the maximum number of tabs to launch.")] = 10,
-        max_layouts: Annotated[int, typer.Option(..., "--max-layouts", "-ml", help="A Sanity checker that throws an error if the total number of *parallel layouts exceeds this number.")] = 10,
-        sleep_inbetween: Annotated[float, typer.Option(..., "--sleep-inbetween", "-si", help="Sleep time in seconds between launching layouts")] = 1.0,
-        monitor: Annotated[bool, typer.Option(..., "--monitor", "-m", help="Monitor the layout sessions for completion")] = False,
-        parallel: Annotated[bool, typer.Option(..., "--parallel", "-p", help="Launch multiple layouts in parallel")] = False,
-        kill_upon_completion: Annotated[bool, typer.Option(..., "--kill-upon-completion", "-k", help="Kill session(s) upon completion (only relevant if monitor flag is set)")] = False,
-        choose: Annotated[Optional[str], typer.Option(..., "--choose", "-c", help="Comma separated names of layouts to be selected from the layout file passed")] = None,
-        choose_interactively: Annotated[bool, typer.Option(..., "--choose-interactively", "-i", help="Select layouts interactively")] = False,
-        subsitute_home: Annotated[bool, typer.Option(..., "--substitute-home", "-sh", help="Substitute ~ and $HOME in layout file with actual home directory path")] = False,
-        ):
-    """
-    Launch terminal sessions based on a layout configuration file.
-    """
+    from machineconfig.scripts.python.helpers.helpers_sessions.sessions_impl import balance_load as impl
+    impl(layout_path=layout_path, max_thresh=max_thresh, thresh_type=thresh_type, breaking_method=breaking_method, output_path=output_path)
+
+
+def run(
+    ctx: typer.Context,
+    layout_path: Annotated[Optional[str], typer.Argument(..., help="Path to the layout.json file")] = None,
+    max_tabs: Annotated[int, typer.Option(..., "--max-tabs", "-mt", help="A Sanity checker that throws an error if any layout exceeds the maximum number of tabs to launch.")] = 10,
+    max_layouts: Annotated[int, typer.Option(..., "--max-layouts", "-ml", help="A Sanity checker that throws an error if the total number of *parallel layouts exceeds this number.")] = 10,
+    sleep_inbetween: Annotated[float, typer.Option(..., "--sleep-inbetween", "-si", help="Sleep time in seconds between launching layouts")] = 1.0,
+    monitor: Annotated[bool, typer.Option(..., "--monitor", "-m", help="Monitor the layout sessions for completion")] = False,
+    parallel: Annotated[bool, typer.Option(..., "--parallel", "-p", help="Launch multiple layouts in parallel")] = False,
+    kill_upon_completion: Annotated[bool, typer.Option(..., "--kill-upon-completion", "-k", help="Kill session(s) upon completion (only relevant if monitor flag is set)")] = False,
+    choose: Annotated[Optional[str], typer.Option(..., "--choose", "-c", help="Comma separated names of layouts to be selected from the layout file passed")] = None,
+    choose_interactively: Annotated[bool, typer.Option(..., "--choose-interactively", "-i", help="Select layouts interactively")] = False,
+    subsitute_home: Annotated[bool, typer.Option(..., "--substitute-home", "-sh", help="Substitute ~ and $HOME in layout file with actual home directory path")] = False,
+) -> None:
+    """Launch terminal sessions based on a layout configuration file."""
     if layout_path is None:
         typer.echo(ctx.get_help())
         raise typer.Exit()
-    layout_path_resolved = find_layout_file(layout_path=layout_path)
-    layouts_selected = select_layout(layouts_json_file=layout_path_resolved, selected_layouts_names=choose.split(",") if choose else None, select_interactively=choose_interactively, subsitute_home=subsitute_home)
-
-    # ============= Basic sanity checks =============
-    if parallel and len(layouts_selected) > max_layouts:
-        raise ValueError(f"Number of layouts {len(layouts_selected)} exceeds the maximum allowed {max_layouts}. Please adjust your layout file.")
-    for a_layout in layouts_selected:
-        if len(a_layout["layoutTabs"]) > max_tabs:
-            typer.echo(f"Layout '{a_layout.get('layoutName', 'Unnamed')}' has {len(a_layout['layoutTabs'])} tabs which exceeds the max of {max_tabs}.")
-            confirm = typer.confirm("Do you want to proceed with launching this layout?", default=False)
-            if not confirm:
-                typer.echo("Aborting launch.")
-                raise typer.Exit(0)
-    import time
-    import platform
-    if platform.system() == "Linux" or platform.system() == "Darwin":
-        from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
-        if not parallel: iterable = [[item] for item in layouts_selected]
-        else: iterable = [layouts_selected]
-        for i, a_layouts in enumerate(iterable):
-            manager = ZellijLocalManager(session_layouts=a_layouts)
-            manager.start_all_sessions(poll_interval=2, poll_seconds=2)
-            if monitor:
-                manager.run_monitoring_routine(wait_ms=2000)
-                if kill_upon_completion:
-                    manager.kill_all_sessions()
-            if i < len(layouts_selected) - 1:  # Don't sleep after the last layout
-                time.sleep(sleep_inbetween)
-    elif platform.system() == "Windows":
-        from machineconfig.cluster.sessions_managers.wt_local_manager import WTLocalManager
-        if not parallel: iterable = [[item] for item in layouts_selected]
-        else: iterable = [layouts_selected]
-        for i, a_layouts in enumerate(iterable):
-            manager = WTLocalManager(session_layouts=a_layouts)
-            manager.start_all_sessions()
-            if monitor:
-                manager.run_monitoring_routine(wait_ms=2000)
-                if kill_upon_completion:
-                    manager.kill_all_sessions()
-            if i < len(layouts_selected) - 1:  # Don't sleep after the last layout
-                time.sleep(sleep_inbetween)
-    else:
-        print(f"❌ Unsupported platform: {platform.system()}")
-
-
-def create_template(name: Annotated[Optional[str], typer.Argument(..., help="Name of the layout template to create")] = None,
-                    num_tabs: Annotated[int, typer.Option(..., "--num-tabs", "-t", help="Number of tabs to include in the template")] = 3,
-                    ):
+    from machineconfig.scripts.python.helpers.helpers_sessions.sessions_impl import run_layouts
+    try:
+        run_layouts(layout_path=layout_path, max_tabs=max_tabs, max_layouts=max_layouts, sleep_inbetween=sleep_inbetween, monitor=monitor, parallel=parallel, kill_upon_completion=kill_upon_completion, choose=choose, choose_interactively=choose_interactively, subsitute_home=subsitute_home)
+    except ValueError as e:
+        typer.echo(str(e))
+        raise typer.Exit(1) from e
+
+
+def create_template(
+    name: Annotated[Optional[str], typer.Argument(..., help="Name of the layout template to create")] = None,
+    num_tabs: Annotated[int, typer.Option(..., "--num-tabs", "-t", help="Number of tabs to include in the template")] = 3,
+) -> None:
     """Create a layout template file."""
-    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile, TabConfig
-    from pathlib import Path
-    tabs: list[TabConfig] = []
-    for i in range(1, num_tabs + 1):
-        tab: TabConfig = {
-            "tabName": f"Tab{i}",
-            "startDir": "~/" + str(Path.cwd().relative_to(Path.home())),
-            "command": "bash",
-        }
-        tabs.append(tab)
-    layouts: list[LayoutConfig] = [
-        {
-            "layoutName": f"{Path.cwd().name}Layout",
-            "layoutTabs": tabs,
-        }
-    ]
-    file: LayoutsFile = {
-        "$schema": "https://bit.ly/cfglayout",  # type: ignore
-        "version": "0.1",
-        "layouts": layouts
-    }
-    import json
-    json_string = json.dumps(file, indent=4)
-    if name is None:
-        layout_path = Path.cwd() / "layout.json"
-    else:
-        layout_path = Path.cwd() / (name.replace(".json", "") + ".json")
-    layout_path.parent.mkdir(parents=True, exist_ok=True)
-    if layout_path.exists():
-        print(f"❌ File {layout_path} already exists. Aborting to avoid overwriting.")
-        return
-    layout_path.write_text(json_string, encoding="utf-8")
-    print(f"✅ Created layout template at {layout_path}")
-
-
-def get_app():
-    layouts_app = typer.Typer(help="Layouts management subcommands", no_args_is_help=True, add_help_option=False, add_completion=False)
-    from machineconfig.scripts.python.helpers_sessions.sessions_multiprocess import create_from_function
-
-    layouts_app.command("create-from-function", no_args_is_help=True, help=create_from_function.__doc__, short_help="[c] Create a layout from a function")(create_from_function)
-    layouts_app.command("c", no_args_is_help=True, help=create_from_function.__doc__, hidden=True)(create_from_function)
+    from machineconfig.scripts.python.helpers.helpers_sessions.sessions_impl import create_template as impl
+    impl(name=name, num_tabs=num_tabs)
+
+
+def create_from_function(
+    num_process: Annotated[int, typer.Option(..., "--num-process", "-n", help="Number of parallel processes to run")],
+    path: Annotated[str, typer.Option(..., "--path", "-p", help="Path to a Python or Shell script file or a directory containing such files")] = ".",
+    function: Annotated[Optional[str], typer.Option(..., "--function", "-f", help="Function to run from the Python file. If not provided, you will be prompted to choose.")] = None,
+) -> None:
+    """Create a layout from a function to run in multiple processes."""
+    from machineconfig.scripts.python.helpers.helpers_sessions.sessions_multiprocess import create_from_function as impl
+    impl(num_process=num_process, path=path, function=function)
+
+
+def get_app() -> typer.Typer:
+    layouts_app = typer.Typer(help="Layouts management subcommands", no_args_is_help=True, add_help_option=True, add_completion=False)
+
+    layouts_app.command("create-from-function", no_args_is_help=True, short_help="[c] Create a layout from a function")(create_from_function)
+    layouts_app.command("c", no_args_is_help=True, hidden=True)(create_from_function)
 
     layouts_app.command("run", no_args_is_help=True, help=run.__doc__, short_help="[r] Run the selected layout(s)")(run)
     layouts_app.command("r", no_args_is_help=True, help=run.__doc__, hidden=True)(run)
@@ -212,10 +77,10 @@ def get_app():
     return layouts_app
 
 
-def main():
+def main() -> None:
     layouts_app = get_app()
     layouts_app()
 
 
 if __name__ == "__main__":
-    from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
+    pass