machineconfig 1.95__py3-none-any.whl → 1.96__py3-none-any.whl

machineconfig/cluster/templates/cli_gooey.py

@@ -1,119 +1,117 @@
 
-"""Gooey
-"""
+# """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
+# from argparse import ArgumentParser
+# # from gooey import Gooey  #, GooeyParser
+# # 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 machineconfig.utils.utils2 import read_ini
+# # 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")
+# @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)
+#     # # 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)
+#     # # 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)
+#     # # 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)
+#     # # 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'
+#     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)
+#     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()
+#     # 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
+#     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()
+# if __name__ == '__main__':
+#     main()

machineconfig/cluster/templates/run_cloud.py

@@ -1,52 +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
+# """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 machineconfig.utils.utils import DEFAULTS_PATH
+# from machineconfig.utils.utils2 import read_ini
+# 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

machineconfig/cluster/templates/run_cluster.py

@@ -1,69 +1,113 @@
 
-"""
-Cluster Template
-"""
+# """
+# Cluster Template
+# """
 
-from crocodile.core import List as L
-from crocodile.file_management import P
-from machineconfig.cluster.distribute import WorkloadParams
-from machineconfig.cluster.distribute import RemoteMachineConfig, LoadCriterion, Cluster, ThreadLoadCalculator
-from typing import Any
 
+# from machineconfig.cluster.distribute import WorkloadParams
+# from machineconfig.cluster.distribute import RemoteMachineConfig, LoadCriterion, Cluster, ThreadLoadCalculator
+# from typing import Any, List
 
-class ExpensiveComputation:
-    @staticmethod
-    def func_single_job(workload_params: WorkloadParams, *args: Any, **kwargs: Any) -> P:
-        from machineconfig.cluster.templates.utils import expensive_function
-        res = expensive_function(workload_params=workload_params, *args, **kwargs)
-        return res
 
-    @staticmethod
-    def func(workload_params: WorkloadParams, **kwargs: Any) -> P:
-        per_job_workload_params = L(range(workload_params.idx_start, workload_params.idx_end, 1)).split(to=workload_params.jobs).apply(lambda sub_list: WorkloadParams(idx_start=sub_list.list[0], idx_end=sub_list.list[-1] + 1, idx_max=workload_params.idx_max, jobs=workload_params.jobs))
-        res: list[P] = L(per_job_workload_params).apply(lambda a_workload_params: ExpensiveComputation.func_single_job(workload_params=a_workload_params, **kwargs), jobs=workload_params.jobs).list
-        return res[0]
+# class ExpensiveComputation:
+#     @staticmethod
+#     def _split_into_chunks(items: List[int], num_chunks: int) -> List[List[int]]:
+#         """Split a list of integers into near-equal contiguous chunks.
 
-    @staticmethod
-    def submit():
-        config = RemoteMachineConfig(
-            # connection
-            ssh_params={}, description="Description of running an expensive function",  # job_id=, base_dir="",
-            # data
-            copy_repo=False, update_repo=False, install_repo=False, update_essential_repos=True, data=[],
-            transfer_method="sftp",
-            # remote machine behaviour
-            open_console=True, notify_upon_completion=True, to_email='random@email.com', email_config_name='enaut',
-            kill_on_completion=False,
-            # execution behaviour
-            ipython=True, interactive=True, pdb=False, pudb=False, wrap_in_try_except=True,
-            # resources
-            lock_resources=True, max_simulataneous_jobs=2, parallelize=True, )
-        ssh_params = [dict(host="thinkpad"), dict(host="p51s")]  # ,
-        # ssh_params = [dict(host="214676wsl"), dict(host="229234wsl")]
-        c = Cluster(func=ExpensiveComputation.func_single_job,
-                    func_kwargs=dict(sim_dict=dict(a=2, b=3)),
-                    ssh_params=ssh_params,
-                    remote_machine_config=config,
-                    thread_load_calc=ThreadLoadCalculator(num_jobs=3, load_criterion=LoadCriterion.cpu),  # if this machine can run 3 jobs at a time, how many can other machines do?
-                    )
-        c.run(run=True, machines_per_tab=len(ssh_params), window_number=354)
-        return c
+#         Ensures no empty chunks are returned even if num_chunks > len(items).
+#         """
+#         if num_chunks <= 0:
+#             return [items]
+#         n = len(items)
+#         if n == 0:
+#             return []
+#         base_size, remainder = divmod(n, num_chunks)
+#         chunks: List[List[int]] = []
+#         start_index = 0
+#         for chunk_index in range(num_chunks):
+#             current_size = base_size + (1 if chunk_index < remainder else 0)
+#             if current_size == 0:
+#                 # Skip empty chunk when num_chunks > n
+#                 continue
+#             end_index = start_index + current_size
+#             chunks.append(items[start_index:end_index])
+#             start_index = end_index
+#         return chunks
+#     @staticmethod
+#     def func_single_job(workload_params: WorkloadParams, *args: Any, **kwargs: Any) -> P:
+#         from machineconfig.cluster.templates.utils import expensive_function
+#         res = expensive_function(workload_params=workload_params, *args, **kwargs)
+#         return res
 
+#     @staticmethod
+#     def func(workload_params: WorkloadParams, **kwargs: Any) -> P:
+#         # Build contiguous near-equal chunks across the index range
+#         indices: List[int] = list(range(workload_params.idx_start, workload_params.idx_end, 1))
+#         chunks: List[List[int]] = ExpensiveComputation._split_into_chunks(indices, workload_params.jobs)
 
-def try_run_on_cluster():
-    import time
-    ExpensiveComputation.submit()
-    ExpensiveComputation.submit()
-    cluster = ExpensiveComputation.submit()
-    # later ...
-    time.sleep(50)
-    c = Cluster.load(cluster.job_id)
-    c.open_mux(machines_per_tab=1)
-    c.check_job_status()
-    c.download_results()
-    L(c.machines).delete_remote_results()
-    return c
+#         # Create per-job workload params from chunks
+#         per_job_workload_params: List[WorkloadParams] = [
+#             WorkloadParams(
+#                 idx_start=chunk[0],
+#                 idx_end=chunk[-1] + 1,
+#                 idx_max=workload_params.idx_max,
+#                 jobs=workload_params.jobs,
+#             )
+#             for chunk in chunks
+#             if len(chunk) > 0
+#         ]
 
+#         # Execute each job sequentially (replace former List.apply behavior)
+#         # If parallel execution is needed, consider a ThreadPool/ProcessPool
+#         results: List[PathExtended] = [
+#             ExpensiveComputation.func_single_job(workload_params=job_params, **kwargs)
+#             for job_params in per_job_workload_params
+#         ]
+#         return results[0]
 
-if __name__ == '__main__':
-    pass
+#     @staticmethod
+#     def submit():
+#         config = RemoteMachineConfig(
+#             # connection
+#             ssh_params={}, description="Description of running an expensive function",  # job_id=, base_dir="",
+#             # data
+#             copy_repo=False, update_repo=False, install_repo=False, update_essential_repos=True, data=[],
+#             transfer_method="sftp",
+#             # remote machine behaviour
+#             open_console=True, notify_upon_completion=True, to_email='random@email.com', email_config_name='enaut',
+#             kill_on_completion=False,
+#             # execution behaviour
+#             ipython=True, interactive=True, pdb=False, pudb=False, wrap_in_try_except=True,
+#             # resources
+#             lock_resources=True, max_simulataneous_jobs=2, parallelize=True, )
+#         ssh_params = [dict(host="thinkpad"), dict(host="p51s")]  # ,
+#         # ssh_params = [dict(host="214676wsl"), dict(host="229234wsl")]
+#         c = Cluster(func=ExpensiveComputation.func_single_job,
+#                     func_kwargs=dict(sim_dict=dict(a=2, b=3)),
+#                     ssh_params=ssh_params,
+#                     remote_machine_config=config,
+#                     thread_load_calc=ThreadLoadCalculator(num_jobs=3, load_criterion=LoadCriterion.cpu),  # if this machine can run 3 jobs at a time, how many can other machines do?
+#                     )
+#         c.run(run=True, machines_per_tab=len(ssh_params), window_number=354)
+#         return c
+
+
+# def try_run_on_cluster():
+#     import time
+#     ExpensiveComputation.submit()
+#     ExpensiveComputation.submit()
+#     cluster = ExpensiveComputation.submit()
+#     # later ...
+#     time.sleep(50)
+#     c = Cluster.load(cluster.job_id)
+#     c.open_mux(machines_per_tab=1)
+#     c.check_job_status()
+#     c.download_results()
+#     # Delete remote results on all machines
+#     for machine in c.machines:
+#         machine.delete_remote_results()
+#     return c
+
+
+# if __name__ == '__main__':
+#     pass

machineconfig/cluster/templates/run_remote.py

@@ -1,67 +1,66 @@
 
-"""
-This file contains a template for a remote machine. It is not meant to be run, but rather to be used as a template for
-"""
+# """
+# This file contains a template for a remote machine. It is not meant to be run, but rather to be used as a template for
+# """
 
 
-def run_on_remote():
-    from machineconfig.cluster.remote_machine import RemoteMachine, RemoteMachineConfig, WorkloadParams
-    from machineconfig.cluster.templates.utils import expensive_function
-    from crocodile.file_management import P
-    # from machineconfig.cluster.self_ssh import SelfSSH
-    data: list[P] = []
-    config = RemoteMachineConfig(
-        # connection
-        #        ssh_obj=SelfSSH(),  # overrides ssh_params
-        ssh_params=dict(host="ts"),  # dict(host="239wsl"),
-        description="Description of running an expensive function",  # job_id=, base_dir="",
-        # data
-        copy_repo=False, update_repo=True, install_repo=False, update_essential_repos=True, data=data, transfer_method="sftp",
-        # remote machine behaviour
-        open_console=True, notify_upon_completion=True, to_email=None, email_config_name=None, kill_on_completion=False,
-        # execution behaviour
-        ipython=True, interactive=True, pdb=False, pudb=False, wrap_in_try_except=True,
-        workload_params=None,  # this means no workload params object will be created in execution script, nor fed explicitil with workload_params=workload_params.
-        # resources
-        lock_resources=True, max_simulataneous_jobs=2, parallelize=False, )
-    m = RemoteMachine(func=expensive_function, func_kwargs=dict(sim_dict=dict(a=2, b=3), workload_params=WorkloadParams()),  # this way, workload_params go directory to the function with **func_kwargs pickle.
-                      config=config)
-    m.run()
-    return m
+# def run_on_remote():
+#     from machineconfig.cluster.remote_machine import RemoteMachine, RemoteMachineConfig, WorkloadParams
+#     from machineconfig.cluster.templates.utils import expensive_function
+#     # from machineconfig.cluster.self_ssh import SelfSSH
+#     data: list[PathExtended] = []
+#     config = RemoteMachineConfig(
+#         # connection
+#         #        ssh_obj=SelfSSH(),  # overrides ssh_params
+#         ssh_params=dict(host="ts"),  # dict(host="239wsl"),
+#         description="Description of running an expensive function",  # job_id=, base_dir="",
+#         # data
+#         copy_repo=False, update_repo=True, install_repo=False, update_essential_repos=True, data=data, transfer_method="sftp",
+#         # remote machine behaviour
+#         open_console=True, notify_upon_completion=True, to_email=None, email_config_name=None, kill_on_completion=False,
+#         # execution behaviour
+#         ipython=True, interactive=True, pdb=False, pudb=False, wrap_in_try_except=True,
+#         workload_params=None,  # this means no workload params object will be created in execution script, nor fed explicitil with workload_params=workload_params.
+#         # resources
+#         lock_resources=True, max_simulataneous_jobs=2, parallelize=False, )
+#     m = RemoteMachine(func=expensive_function, func_kwargs=dict(sim_dict=dict(a=2, b=3), workload_params=WorkloadParams()),  # this way, workload_params go directory to the function with **func_kwargs pickle.
+#                       config=config)
+#     m.run()
+#     return m
 
 
-def try_run_on_remote():
-    run_on_remote()
-    run_on_remote()
-    i3 = run_on_remote()
-    i3.check_job_status()
-    i3.download_results(r=True)
-    i3.delete_remote_results()
+# def try_run_on_remote():
+#     run_on_remote()
+#     run_on_remote()
+#     i3 = run_on_remote()
+#     i3.check_job_status()
+#     i3.download_results(r=True)
+#     i3.delete_remote_results()
 
 
-def run_on_cloud():
-    from machineconfig.cluster.remote_machine import RemoteMachine, RemoteMachineConfig, CloudManager
-    from machineconfig.cluster.templates.utils import expensive_function
-    from machineconfig.cluster.self_ssh import SelfSSH
-    config = RemoteMachineConfig(
-        # connection
-        ssh_obj=SelfSSH(),  # overrides ssh_params
-        description="Description of running an expensive function",  # job_id=, base_dir="",
-        # data
-        copy_repo=False, update_repo=True, install_repo=False, update_essential_repos=True, data=[], transfer_method="cloud", cloud_name="oduq1",
-        # remote machine behaviour
-        open_console=True, notify_upon_completion=True, to_email=None, email_config_name=None,
-        kill_on_completion=False,
-        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=True, max_simulataneous_jobs=2, parallelize=False, )
-    m = RemoteMachine(func=expensive_function, func_kwargs=dict(sim_dict=dict(a=2, b=3)), config=config)
-    res = m.submit_to_cloud(split=2, cm=CloudManager(max_jobs=1))
-    return res
+# def run_on_cloud():
+#     from machineconfig.cluster.remote_machine import RemoteMachine, RemoteMachineConfig, CloudManager
+#     from machineconfig.cluster.templates.utils import expensive_function
+#     from machineconfig.cluster.self_ssh import SelfSSH
+#     config = RemoteMachineConfig(
+#         # connection
+#         ssh_obj=SelfSSH(),  # overrides ssh_params
+#         description="Description of running an expensive function",  # job_id=, base_dir="",
+#         # data
+#         copy_repo=False, update_repo=True, install_repo=False, update_essential_repos=True, data=[], transfer_method="cloud", cloud_name="oduq1",
+#         # remote machine behaviour
+#         open_console=True, notify_upon_completion=True, to_email=None, email_config_name=None,
+#         kill_on_completion=False,
+#         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=True, max_simulataneous_jobs=2, parallelize=False, )
+#     m = RemoteMachine(func=expensive_function, func_kwargs=dict(sim_dict=dict(a=2, b=3)), config=config)
+#     res = m.submit_to_cloud(split=2, cm=CloudManager(max_jobs=1))
+#     return res
 
 
-if __name__ == '__main__':
-    pass
+# if __name__ == '__main__':
+#     pass