machineconfig 1.92__py3-none-any.whl → 1.94__py3-none-any.whl

machineconfig/cluster/script_notify_upon_completion.py

@@ -0,0 +1,63 @@
+
+"""
+Notify User Upon Completion
+"""
+
+from crocodile.comms.notification import Email
+from crocodile.core import Struct as S
+from crocodile.file_management import P
+from machineconfig.cluster.file_manager import FileManager
+from machineconfig.cluster.loader_runner import EmailParams
+
+
+error_message = ''
+exec_times = S()
+res_folder = P()
+
+email_params = EmailParams.from_empty()
+manager = FileManager.from_pickle(email_params.file_manager_path)
+
+print(f'SENDING notification email using `{email_params.email_config_name}` email configuration ...')
+
+sep = "\n" * 2  # SyntaxError: f-string expression part cannot include a backslash, keep it here outside fstring.
+msg = f'''
+
+Hi `{email_params.addressee}`, I'm `{email_params.speaker}`, this is a notification that I have completed running the script you sent to me.
+
+``` {email_params.executed_obj} ```
+
+
+#### Error Message:
+`{error_message}`
+#### Execution Times
+{exec_times.print(as_config=True, return_str=True)}
+#### Executed Shell Script:
+`{manager.shell_script_path}`
+#### Executed Python Script:
+`{manager.py_script_path}`
+
+#### Pull results using this script:
+`ftprx {email_params.ssh_conn_str} {res_folder.collapseuser().as_posix()} -r`
+Or, using croshell,
+
+```python
+
+ssh = SSH(r'{email_params.ssh_conn_str}')
+ssh.copy_to_here(r'{res_folder.collapseuser().as_posix()}', r=False, zip_first=False)
+
+```
+
+#### Results folder contents:
+```
+
+{res_folder.search().print(return_str=True, sep=sep)}
+
+```
+
+'''
+
+try:
+    Email.send_and_close(config_name=email_params.email_config_name, to=email_params.to_email,
+                         subject=f"Execution Completion Notification, job_id = {manager.job_id}", body=msg)
+    print(f'FINISHED sending notification email to `{email_params.to_email}`')
+except Exception as e: print(f"Error sending email: {e}")

machineconfig/cluster/self_ssh.py

@@ -0,0 +1,59 @@
+
+"""SelfSSh
+"""
+
+
+from crocodile.file_management import PLike
+from crocodile.meta import MACHINE, Terminal
+from typing import Optional, Any
+import getpass
+import platform
+import subprocess
+
+
+class SelfSSH:
+    """Instead of SSH'ing to the same machine, one can use this interface.
+    """
+    def __init__(self):
+        self.hostname = "localhost"
+        self._remote_machine: Optional[MACHINE] = None
+        self.remote_env_cmd = ". activate_ve"
+        self.sftp: Any
+    def __getstate__(self) -> object: return {}
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        """This behaviour makes SelfSSH dynamic, even if it was pickled from windows machine, when unpickled on Linux, it will behave as a Linux machine instance."""
+        _ = state
+        new_instance = SelfSSH()
+        self.__dict__.update(new_instance.__dict__)
+        return None
+    def run(self, cmd: str, desc: str = "", verbose: bool = False):
+        _ = desc, verbose
+        return Terminal().run(cmd, shell="powershell")
+    def run_py(self, cmd: str, verbose: bool = False, desc: str = ''):
+        _ = verbose, cmd, desc
+        exec(cmd)  # type: ignore # pylint: disable=exec-used
+        return None
+    def get_ssh_conn_str(self): return "ssh localhost"
+    def get_remote_machine(self) -> MACHINE:
+        if self._remote_machine is None:
+            self._remote_machine = "Windows" if (self.run("$env:OS").op.rstrip("\n") == "Windows_NT" or self.run("echo %OS%").op == "Windows_NT") else "Linux"
+        return self._remote_machine
+    def get_remote_repr(self, add_machine: bool = False):
+        _ = add_machine
+        host = f"{getpass.getuser()}@{platform.node()}"
+        return f"SelfSSH({host}) REMOTE"
+    def get_local_repr(self, add_machine: bool = False): return self.get_remote_repr(add_machine=add_machine).replace("REMOTE", "LOCAL")
+    def open_console(self, cmd: str = '', new_window: bool = True, terminal: Optional[str] = None, shell: str = "pwsh"):
+        _ = cmd, shell, new_window, terminal
+        # return Terminal().run_async("", new_window=True, shell=shell)
+        # Terminal().run_async(*(self.get_ssh_conn_str(cmd=cmd).split(" ")), new_window=new_window, terminal=terminal, shell=shell)
+        if platform.system() == "Windows":
+            subprocess.Popen(["wt", "--profile", "pwsh"], stdin=subprocess.PIPE, shell=True)
+        elif platform.system() == "Linux":
+            subprocess.Popen(["zellij --session haha"], shell=True, stdin=None, stdout=None, stderr=None)
+    def copy_to_here(self, source: PLike = '', target: Optional[str] = '', z: bool = True, r: bool = True, desc: str = '', overwrite: bool = False):
+        _ = source, target, z, r, desc, overwrite
+        return None
+    def copy_from_here(self, source: PLike = '', target: Optional[str] = '', z: bool = True, r: bool = True, desc: str = '', overwrite: bool = False):
+        _ = source, target, z, r, desc, overwrite
+        return None

machineconfig/cluster/session_managers.py

@@ -0,0 +1,183 @@
+
+"""
+Session Manager
+"""
+
+from machineconfig.cluster.self_ssh import SelfSSH
+from crocodile.core import List as L
+from crocodile.file_management import P, Save
+from crocodile.meta import SSH, Response, Terminal
+import time
+import subprocess
+from typing import Union
+
+
+class Zellij:
+    @staticmethod
+    def get_current_zellij_session() -> str:
+        try:
+            return L(Terminal().run("zellij ls --no-formatting").op.split("\n")).filter(lambda x: "(current)" in x).list[0].split(" [Created")[0]
+        except IndexError as ie:
+            print("""Fails if there is no zellij session running, fails if there is no (current) suffix against the session name.""")
+            raise ie
+    @staticmethod
+    def get_new_session_command(sess_name: str) -> str: return f"zellij attach {sess_name} -c "  # -c means create if not exists.
+    @staticmethod
+    def get_new_session_ssh_command(ssh: Union[SSH, SelfSSH], sess_name: str):
+        if isinstance(ssh, SelfSSH): return Zellij.get_new_session_command(sess_name=sess_name)
+        return f"{ssh.get_ssh_conn_str()} -t {Zellij.get_new_session_command(sess_name=sess_name)}"
+    @staticmethod
+    def open_console(ssh: Union[SSH, SelfSSH], sess_name: str):
+        if isinstance(ssh, SelfSSH):
+            # return Terminal().run_async(Zellij.get_new_session_command(sess_name=sess_name), shell="powershell")
+            # currently, there is a limitation in zellij on creating a detached sessions, there is no way to fix this now.
+            # this will get stuck in the new session and won't run parallel.
+            return subprocess.Popen(["zellij", "--session", sess_name], shell=True, stdin=None, stdout=None, stderr=None)
+        return Terminal().run_async(Zellij.get_new_session_ssh_command(ssh=ssh, sess_name=sess_name))
+    @staticmethod
+    def asssert_session_started(ssh: Union[SSH, SelfSSH], sess_name: str):
+        while True:
+            raw_resp = ssh.run("zellij ls --no-formatting", verbose=False).op.split("\n")
+            current_sessions = [item.split(" [Created")[0] for item in raw_resp if "EXITED" not in item]
+            if sess_name in current_sessions:
+                print(f"--> Session {sess_name} has started at the remote.")
+                time.sleep(6)
+                break
+            time.sleep(2)
+            print(f"--> Waiting for zellij session {sess_name} to start before sending fire commands ...")
+
+    @staticmethod
+    def close_tab(sess_name: str, tab_name: str):
+        cmd = f"""
+zellij --session {sess_name} action close-tab --tab-name '{tab_name}'
+zellij --session {sess_name} action new-tab --name '🖥️{tab_name}'
+zellij --session {sess_name} action new-tab --name '🔍{tab_name}'
+zellij --session {sess_name} action new-tab --name '🪪{tab_name}'
+zellij --session {sess_name} action new-tab --name '🧑‍💻{tab_name}'
+"""
+        print(f"Closing tab `{tab_name}` in zellij session `{sess_name}` with command \n{cmd}")
+        return Terminal().run_script(cmd)
+
+    @staticmethod
+    def setup_layout(ssh: Union[SSH, SelfSSH], sess_name: str, cmd: str = "", run: bool = False, job_wd: str = "$HOME/tmp_results/remote_machines", tab_name: str = "", compact: bool = False):
+        sleep = 0.9
+        if run:
+            if cmd.startswith(". "): cmd = cmd[2:]
+            elif cmd.startswith("source "): cmd = cmd[7:]
+            else: pass
+            exe = f"""
+zellij --session {sess_name} action new-tab --name '{tab_name}'; sleep {sleep}
+zellij --session {sess_name} run -d down -- /bin/bash {cmd}; sleep {sleep}
+zellij --session {sess_name} action move-focus up; sleep {sleep}
+zellij --session {sess_name} action close-pane; sleep {sleep}
+"""
+        else: exe = f"""
+zellij --session {sess_name} action write-chars "{cmd}"
+"""
+        if not compact: cmd = f"""
+zellij --session {sess_name} action new-tab --name '{tab_name}'; sleep {sleep}
+zellij --session {sess_name} action rename-tab '🖥️{tab_name}'; sleep {sleep}  # rename the focused first tab
+zellij --session {sess_name} action new-tab --name '🔍{tab_name}'; sleep {sleep}
+zellij --session {sess_name} action write-chars htop; sleep {sleep}
+
+zellij --session {sess_name} action new-tab --name '📁{tab_name}'; sleep {sleep}
+zellij --session {sess_name} run --direction down --cwd {job_wd} -- lf; sleep {sleep}
+zellij --session {sess_name} action move-focus up; sleep {sleep}
+zellij --session {sess_name} action close-pane; sleep {sleep}
+
+zellij --session {sess_name} action new-tab --name '🪪{tab_name}'; sleep {sleep}
+zellij --session {sess_name} run --direction down -- neofetch;cpufetch; sleep {sleep}
+zellij --session {sess_name} action move-focus up; sleep {sleep}
+zellij --session {sess_name} action close-pane; sleep {sleep}
+
+zellij --session {sess_name} action new-tab --name '🧑‍💻{tab_name}'; sleep {sleep}
+zellij --session {sess_name} action write-chars "cd {job_wd}"; sleep {sleep}
+zellij --session {sess_name} action go-to-tab 1; sleep {sleep}
+{exe}
+
+"""
+        else: cmd = exe
+        if isinstance(ssh, SelfSSH):
+            # print(1)
+            print(f"Setting up zellij layout `{sess_name}` on `{ssh.get_remote_repr()}` to run `{P(job_wd).name}`")
+            # return Terminal().run_script(cmd)  # Zellij not happy with launching scripts of zellij commands.
+            return Response.from_completed_process(subprocess.run(cmd, shell=True, check=True, capture_output=True, text=True))
+        # print(2)
+        return ssh.run(cmd, desc=f"Setting up zellij layout on `{ssh.get_remote_repr()}`", verbose=False)
+    @staticmethod
+    def kill_session(ssh: Union[SSH, SelfSSH], sess_name: str):
+        cmd = f'zellij kill-session {sess_name}'
+        return ssh.run(cmd, desc=f"Killing zellij session `{sess_name}` on `{ssh.get_remote_repr()}`", verbose=False)
+
+
+class WindowsTerminal:
+    @staticmethod
+    def kill_session(sess_name: str):
+        from machineconfig.utils.procs import ProcessManager
+        pm = ProcessManager()
+        pm.kill(commands=[sess_name])
+    @staticmethod
+    def open_reference(): P(r"https://learn.microsoft.com/en-us/windows/terminal/command-line-arguments?tabs=windows")()
+    @staticmethod
+    def get_new_session_command(sess_name: str): return f"wt -w {sess_name} -d ."
+    @staticmethod
+    def get_new_session_ssh_command(ssh: Union[SSH, SelfSSH], sess_name: str):
+        if isinstance(ssh, SelfSSH): return WindowsTerminal.get_new_session_command(sess_name=sess_name)
+        return f"{ssh.get_ssh_conn_str()} -t {WindowsTerminal.get_new_session_command(sess_name=sess_name)}"
+    @staticmethod
+    def open_console(ssh: Union[SSH, SelfSSH], sess_name: str):
+        if isinstance(ssh, SelfSSH):
+            # return Terminal().run_async(WindowsTerminal.get_new_session_command(sess_name=sess_name), shell="powershell")
+            return subprocess.Popen(["wt", "--window", sess_name], shell=True, stdin=None, stdout=None, stderr=None)
+        return Terminal().run_async(WindowsTerminal.get_new_session_ssh_command(ssh=ssh, sess_name=sess_name), shell="pwsh")
+    @staticmethod
+    def asssert_session_started(ssh: Union[SSH, SelfSSH], sess_name: str):
+        _ = sess_name, ssh
+        time.sleep(6)
+        return True
+    @staticmethod
+    def setup_layout(ssh: Union[SSH, SelfSSH], sess_name: str, tab_name: str = "", cmd: str = "", run: bool = True, job_wd: str = "$HOME/tmp_results/remote_machines", compact: bool = True):
+        if run:
+            if cmd.startswith(". "): cmd = cmd[2:]
+            elif cmd.startswith("source "): cmd = cmd[7:]
+            else: pass
+            exe: str = f"""
+wt --window {sess_name} new-tab --title '{tab_name}' pwsh -noExit -Command {cmd}
+"""
+        else: raise NotImplementedError("I don't know how to write-chars in Windows Terminal")  # exe = f""" wt --window {sess_name} action write-chars "{cmd}" """
+        sleep = 0.9
+        if compact: cmd = f"""
+wt --window {sess_name} new-tab --title '💻{tab_name}' htop `; split-pane --horizontal  --title '📁{tab_name}' --startingDirectory {job_wd} --profile pwsh lf `;  split-pane --vertical  --title '🪪{tab_name}' powershell -noExit "$HOME/scripts/neofetch.ps1" `; move-focus up `;  split-pane --vertical --startingDirectory {job_wd} --title '🧑‍💻{tab_name}' --profile pwsh
+"""  # when pane-splitting, the tab title goes to the last pane declared.
+        else: cmd = f"""'
+wt --window {sess_name} new-tab --title '💻{tab_name}' htop; sleep {sleep}
+wt --window {sess_name} new-tab --title '📁{tab_name}' --startingDirectory {job_wd} lf; sleep {sleep}
+wt --window {sess_name} new-tab --title '🪪{tab_name}' powershell -noExit "$HOME/scripts/neofetch.ps1"; sleep {sleep}
+wt --window {sess_name} new-tab --title '🧑‍💻{tab_name}' --startingDirectory {job_wd} --profile pwsh; sleep {sleep}
+"""
+        cmd = cmd + f"\nsleep {sleep};" + exe
+        # print(cmd)
+        if isinstance(ssh, SelfSSH):
+            print(f"Firing WindowsTerminal Session `{sess_name}` on `{ssh.get_remote_repr()}` to run `{P(job_wd).name}`")
+            return Terminal().run_script(cmd, shell="pwsh")
+        return ssh.run(cmd, desc=f"Setting up WindowsTerminal layout on `{ssh.get_remote_repr()}`", verbose=False)
+
+
+class Mprocs:
+    @staticmethod
+    def get_template():
+        import machineconfig
+        return P(machineconfig.__file__).parent.joinpath(r"settings/mprocs/windows/mprocs.yaml").readit()
+    # def get_new_session_name(self): return f"mprocs{self.id}"
+    @staticmethod
+    def get_ssh_command(): return ""
+    def open_console(self, cmd: str, shell: str = "powershell"):
+        _ = cmd, shell
+        return "wt -w 0 -d ."
+    def get_layout(self):
+        temp = self.get_template()
+        temp.procs['main']['shell']['windows'] = "croshell"
+        _template_file = Save.yaml(obj=temp, path=P.tmpfile(suffix=".yaml"))
+    def asssert_session_started(self):
+        time.sleep(3)
+        return True

machineconfig/cluster/templates/cli_click.py

@@ -0,0 +1,104 @@
+
+# """Trogon
+# """
+
+# #
+# # from machineconfig.cluster.distribute import Cluster, WorkloadParams
+# from machineconfig.cluster.remote_machine import RemoteMachineConfig, RemoteMachine, CloudManager
+# from crocodile.file_management import Read
+# from machineconfig.cluster.templates.run_cloud import to_email_default, email_config_name_default, default_cloud
+# import click
+# # from trogon import tui
+# from typing import Any, Optional
+
+
+# @click.command()
+# @click.option('--file', prompt="Py File: ", help="The file to run.", default="")
+# @click.option('--function', prompt="Function: ", help="The function to run.", default=None)
+# @click.pass_context
+# def main2(ctx: Any, file: str, function: Optional[str] = None):
+#     ctx.obj = {'file': file, 'function': function}
+
+
+# # @tui()
+# # @click.group("gg")
+# @click.command()
+# @click.option('--file', prompt="Py File: ", help="The file to run.", default="")
+# @click.option('--function', prompt="Function: ", help="The function to run.", default=None)
+# @click.option('--description', prompt="Description of the job: ", default=f"Description of running func on remotes", help="Write something that describes what this job is about.")
+# @click.option('--update_repo', prompt="Update repo: ", default=False, help="Update the repo on the remote machine.")
+# @click.option('--update_essential_repos', prompt="Update essential repos: ", default=True, help="Update essential repos on the remote machine.")
+# @click.option('--cloud_name', prompt="Cloud name: ", default=default_cloud, help="The name of the cloud to use.")
+# @click.option('--notify_upon_completion', prompt="Notify upon completion: ", default=False, help="Send an email upon completion.")
+# @click.option('--to_email', prompt="To email: ", default=to_email_default, help="The email to send to.")
+# @click.option('--email_config_name', prompt="Email config name: ", default=email_config_name_default, help="The name of the email config to use.")
+# @click.option('--kill_on_completion', prompt="Kill on completion: ", default=False)
+# @click.option('--ipython', prompt="Use ipython: ", default=False)
+# @click.option('--interactive', prompt="Interactive: ", default=False)
+# @click.option('--pdb', prompt="Use pdb: ", default=False)
+# @click.option('--pudb', prompt="Use pudb: ", default=False)
+# @click.option('--wrap_in_try_except', prompt="Wrap in try except: ", default=False)
+# @click.option('--lock_resources', prompt="Lock resources: ", default=False)
+# @click.option('--max_simulataneous_jobs', prompt="Max simultaneous jobs: ", default=2)
+# @click.option('--split', prompt="Split: ", default=1)
+# @click.option('--reset_cloud', prompt="Reset cloud: ", default=False)
+# @click.option('--reset_local', prompt="Reset local: ", default=False)
+# # @click.pass_context
+# def main(
+#          file: str, function: Optional[str],
+#          description: str, update_repo: bool, update_essential_repos: bool, cloud_name: str,
+#          notify_upon_completion: bool, to_email: str, email_config_name: str, kill_on_completion: bool, ipython: bool, interactive: bool,
+#          pdb: bool, pudb: bool, wrap_in_try_except: bool, lock_resources: bool, max_simulataneous_jobs: bool,
+#          split: int, reset_cloud: bool, reset_local: bool,
+#           ) -> Any:
+
+#     # function = ctx.obj['function']
+#     # description = ctx.obj['file']
+#     from machineconfig.cluster.self_ssh import SelfSSH
+#     config = RemoteMachineConfig(
+#         # connection
+#         ssh_obj=SelfSSH(),
+#         # ssh_params=None,
+#         description=description,
+#         # job_id=, base_dir="",
+#         # data
+#         copy_repo=False,  # copy_repo,
+#         update_repo=update_repo,
+#         install_repo=True,  # install_repo,
+#         update_essential_repos=update_essential_repos,
+#         data=[],
+#         transfer_method="cloud",  # "transfer_method,
+#         cloud_name=cloud_name,
+#         # remote machine behaviour
+#         # open_console=open_console,
+#         notify_upon_completion=notify_upon_completion,
+#         to_email=to_email,
+#         email_config_name=email_config_name,
+#         kill_on_completion=kill_on_completion,
+#         workload_params=None,
+#         launch_method="cloud_manager",
+#         # execution behaviour
+#         ipython=ipython,
+#         interactive=interactive,
+#         pdb=pdb,
+#         pudb=pudb,
+#         wrap_in_try_except=wrap_in_try_except,
+#         # resources
+#         lock_resources=lock_resources,
+#         max_simulataneous_jobs=max_simulataneous_jobs,
+#         parallelize=False,  # parallelize,
+#     )
+
+#     if function is not None:
+#         module: dict[str, Any] = Read.py(file)
+#         func = module[function]
+#     else: func = file
+#     m = RemoteMachine(func=func, func_kwargs=None, config=config)
+#     res = m.submit_to_cloud(split=split, cm=CloudManager(max_jobs=0, reset_local=reset_local), reset_cloud=reset_cloud)
+#     return res
+
+
+# if __name__ == '__main__':
+#     # conf = get_options(standalone_mode=False)  # type: ignore  # pylint: disable=no-value-for-parameter
+#     # main2()  # type: ignore
+#     main()  # type: ignore

machineconfig/cluster/templates/cli_gooey.py

@@ -0,0 +1,119 @@
+
+"""Gooey
+"""
+
+from argparse import ArgumentParser
+# from gooey import Gooey  #, GooeyParser
+from crocodile.core import install_n_import
+from crocodile.file_management import Read
+# from machineconfig.cluster.distribute import Cluster, WorkloadParams
+from machineconfig.cluster.remote_machine import RemoteMachineConfig
+# from machineconfig.cluster.utils import expensive_function
+from machineconfig.utils.utils import DEFAULTS_PATH
+# from typing import Any, Optional
+
+Gooey = install_n_import("gooey").Gooey
+
+
+@Gooey(program_name="Cluster Launcher", program_description='Cofigure remote cluster and launch jobs.')  # type: ignore
+def main() -> RemoteMachineConfig:
+    # parser = GooeyParser(description='Example of Gooey\'s basic functionality')
+    parser = ArgumentParser(description='Cluster Launcher')
+    from machineconfig.scripts.python.cloud_mount import get_rclone_config
+    cloud_names = get_rclone_config().sections()
+    #     job_id=, base_dir="",
+    parser.add_argument('Description', help='The file you want to process', default="Description of running func on remotes")
+
+    # # execution behaviour
+    # wrap_in_try_except=True
+    parser.add_argument('-w', '--wrap_in_try_except', help='Wrap in try except', action='store_true', default=False)
+    # pudb=False
+    parser.add_argument('-p', '--pudb', help='Use pudb', action='store_true', default=False)
+    # pdb=False
+    parser.add_argument('-d', '--pdb', help='Use pdb', action='store_true', default=False)
+    # interactive=True
+    parser.add_argument('-i', '--interactive', help='Interactive', action='store_true', default=False)
+    # ipython=True
+    parser.add_argument('-y', '--ipython', help='Use ipython', action='store_true', default=False)
+
+    # # resources
+    # lock_resources=True
+    parser.add_argument('-l', '--lock_resources', help='Lock resources', action='store_true', default=False)
+    # max_simulataneous_jobs=2
+    parser.add_argument('-m', '--max_simulataneous_jobs', help='Max simultaneous jobs', type=int, default=2)
+    # parallelize=False
+    # parser.add_argument('-a', '--parallelize', help='Parallelize', action='store_true', default=False)
+
+    # # data
+    # copy_repo = True
+    # parser.add_argument('-c', '--copy_repo', help='Copy repo', action='store_true', default=True)
+    # update_repo=False
+    parser.add_argument('-u', '--update_repo', help='Update repo', action='store_true', default=False)
+    # install_repo=False
+    # parser.add_argument('-n', '--install_repo', help='Install repo', action='store_true', default=False)
+    # update_essential_repos=True
+    parser.add_argument('-e', '--update_essential_repos', help='Update essential repos', action='store_true', default=True)
+    # transfer_method="sftp"
+    # parser.add_argument('-t', '--transfer_method', help='Transfer method', choices=['sftp', 'cloud'], default='sftp')
+    # open_console=True
+    # parser.add_argument('-o', '--open_console', help='Open console', action='store_true', default=True)
+
+    # # remote machine behaviour
+    parser.add_argument('cloud_name', help='Cloud Rclone Config Name', default="oduq1", choices=cloud_names)
+    parser.add_argument('-v', '--notify_upon_completion', help='Notify upon completion', action='store_true', default=True)
+
+    try:
+        section = Read.ini(DEFAULTS_PATH)['general']
+        to_email = section['to_email']
+        email_config_name = section['email_config_name']
+    except (FileNotFoundError, KeyError, IndexError):
+        to_email = 'random@email.com'
+        email_config_name = 'enaut'
+
+    parser.add_argument('-z', '--to_email', help='To email', default=to_email)
+    parser.add_argument('-f', '--email_config_name', help='Email config name', default=email_config_name)
+    parser.add_argument('-k', '--kill_on_completion', help='Kill terminal tab/pane for this job on completion', action='store_true', default=False)
+    parser.add_argument('split', help='How many jobs to split into', type=int, default=3)
+
+    # https://github.com/chriskiehl/GooeyExamples/blob/master/examples/FilterableDropdown.py
+    args = parser.parse_args()
+
+    from machineconfig.cluster.self_ssh import SelfSSH
+    config = RemoteMachineConfig(
+        # connection
+        ssh_obj=SelfSSH(),
+        # ssh_params=None,
+        description=args.Description,
+        # job_id=, base_dir="",
+        # data
+        copy_repo=False,  # args.copy_repo,
+        update_repo=args.update_repo,
+        install_repo=True,  # args.install_repo,
+        update_essential_repos=args.update_essential_repos,
+        data=[],
+        transfer_method="cloud",  # "args.transfer_method,
+        cloud_name=args.cloud_name,
+        # remote machine behaviour
+        # open_console=args.open_console,
+        notify_upon_completion=args.notify_upon_completion,
+        to_email=args.to_email,
+        email_config_name=args.email_config_name,
+        kill_on_completion=args.kill_on_completion,
+        workload_params=None,
+        launch_method="cloud_manager",
+        # execution behaviour
+        ipython=args.ipython,
+        interactive=args.interactive,
+        pdb=args.pdb,
+        pudb=args.pudb,
+        wrap_in_try_except=args.wrap_in_try_except,
+        # resources
+        lock_resources=args.lock_resources,
+        max_simulataneous_jobs=args.max_simulataneous_jobs,
+        parallelize=False,  # args.parallelize,
+    )
+    return config
+
+
+if __name__ == '__main__':
+    main()

machineconfig/cluster/templates/cli_trogon.py

@@ -0,0 +1,21 @@
+
+# """Trogon
+# """
+
+# import click
+# from trogon import tui
+# from typing import Any
+
+
+# @tui()
+# @click.command()
+# @click.option('--description', prompt="Description of the job: ", default=f"Description of running func on remotes", help="Write something that describes what this job is about.")
+# @click.option('--update_repo', prompt="Update repo: ", default=False, help="Update the repo on the remote machine.")
+# @click.pass_context
+# def get_choices(ctx: Any, description: str, update_repo: bool):  # type: ignore
+#     return ctx
+
+
+# if __name__ == '__main__':
+#     res = get_choices(standalone_mode=False)  # type: ignore
+#     print(res)

machineconfig/cluster/templates/f.py

@@ -0,0 +1,4 @@
+
+from crocodile.core import func
+
+print(func(1, 2))

machineconfig/cluster/templates/run_cloud.py

@@ -0,0 +1,52 @@
+
+"""Run with sane defaults for a remote machine.
+"""
+
+from machineconfig.cluster.remote_machine import RemoteMachine, RemoteMachineConfig
+from machineconfig.cluster.cloud_manager import CloudManager
+from machineconfig.cluster.loader_runner import WorkloadParams
+from machineconfig.cluster.self_ssh import SelfSSH
+from crocodile.file_management import Read
+from machineconfig.utils.utils import DEFAULTS_PATH
+from typing import Any, Callable, Union
+
+_ = WorkloadParams
+
+
+try:
+    section = Read.ini(DEFAULTS_PATH)['general']
+    to_email_default = section['to_email']
+    email_config_name_default = section['email_config_name']
+except (FileNotFoundError, KeyError, IndexError):
+    to_email_default = 'random@email.com'
+    email_config_name_default = 'enaut'
+
+try: default_cloud: str = Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
+except (FileNotFoundError, KeyError, IndexError): default_cloud = 'gdrive'
+
+
+def run_on_cloud(func: Union[str, Callable[[WorkloadParams], Any]], split: int, reset_cloud: bool = False, reset_local: bool = False):
+    if hasattr(func, '__doc__'): description = str(func.__doc__)
+    else: description = "Description of running an expensive function"
+    config = RemoteMachineConfig(
+        # connection
+        ssh_obj=SelfSSH(),  # overrides ssh_params
+        description=description,  # job_id=, base_dir="",
+        # data
+        copy_repo=False, update_repo=True, install_repo=False, update_essential_repos=True, data=[], transfer_method="cloud", cloud_name=email_config_name_default,
+        # remote machine behaviour
+        open_console=True, notify_upon_completion=True, to_email=to_email_default, email_config_name=email_config_name_default,
+        kill_on_completion=True,
+        launch_method="cloud_manager",
+        # execution behaviour
+        ipython=False, interactive=False, pdb=False, pudb=False, wrap_in_try_except=True,
+        workload_params=None,  # to be added later per sub-job.
+        # resources
+        lock_resources=False, max_simulataneous_jobs=2, parallelize=False, )
+    m = RemoteMachine(func=func, func_kwargs=None, config=config)
+    res = m.submit_to_cloud(split=split, cm=CloudManager(max_jobs=0, reset_local=reset_local), reset_cloud=reset_cloud)
+    return res
+
+
+if __name__ == "__main__":
+    pass