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

machineconfig/cluster/job_params.py

@@ -1,148 +1,148 @@
 
 
 
-import git
-from crocodile.file_management import P
+# import git
 
-from typing import Optional, Callable, Union, Any
-from machineconfig.cluster.remote_machine import WorkloadParams
-from dataclasses import dataclass
-import getpass
-import platform
+# from typing import Optional, Callable, Union, Any
+# from machineconfig.cluster.remote_machine import WorkloadParams
+# from dataclasses import dataclass
+# import getpass
+# import platform
+# # from machineconfig.utils.utils2 import pprint
 
 
-@dataclass
-class JobParams:
-    """What Python script needs to run the job. This will be dynamically injected into the script. Notice that all attrs are either strings or integers."""
-    description: str
-    ssh_repr: str
-    ssh_repr_remote: str
-    error_message: str
-    session_name: str
-    tab_name: str
-    file_manager_path: str
+# @dataclass
+# class JobParams:
+#     """What Python script needs to run the job. This will be dynamically injected into the script. Notice that all attrs are either strings or integers."""
+#     description: str
+#     ssh_repr: str
+#     ssh_repr_remote: str
+#     error_message: str
+#     session_name: str
+#     tab_name: str
+#     file_manager_path: str
 
-    repo_path_rh: str
-    file_path_rh: str
-    file_path_r: str
-    func_module: str
-    func_class: Optional[str] = None  # the callable might be a function on its own, not a method of a class.
-    func_name: Optional[str] = None  # the job might be running a script as is, no particular method.
+#     repo_path_rh: str
+#     file_path_rh: str
+#     file_path_r: str
+#     func_module: str
+#     func_class: Optional[str] = None  # the callable might be a function on its own, not a method of a class.
+#     func_name: Optional[str] = None  # the job might be running a script as is, no particular method.
 
-    def auto_commit(self):
-        from git.repo import Repo
-        repo = Repo(P(self.repo_path_rh).expanduser(), search_parent_directories=True)
-        # do a commit if the repo is dirty
-        if repo.is_dirty():
-            repo.git.add(update=True)
-            repo.index.commit(f"CloudManager auto commit by {getpass.getuser()}@{platform.node()}")
-            print(f"⚠️ Repo {repo.working_dir} was dirty, auto-committed.")
-        else: print(f"✅ Repo {repo.working_dir} was clean, no auto-commit.")
+#     def auto_commit(self):
+#         from git.repo import Repo
+#         repo = Repo(PathExtended(self.repo_path_rh).expanduser(), search_parent_directories=True)
+#         # do a commit if the repo is dirty
+#         if repo.is_dirty():
+#             repo.git.add(update=True)
+#             repo.index.commit(f"CloudManager auto commit by {getpass.getuser()}@{platform.node()}")
+#             print(f"⚠️ Repo {repo.working_dir} was dirty, auto-committed.")
+#         else: print(f"✅ Repo {repo.working_dir} was clean, no auto-commit.")
 
-    def is_installabe(self) -> bool: return True if "setup.py" in P(self.repo_path_rh).expanduser().absolute().listdir().apply(str) else False
-    @staticmethod
-    def from_empty() -> 'JobParams':
-        return JobParams(repo_path_rh="", file_path_rh="", file_path_r="", func_module="", func_class="", func_name="", description="", ssh_repr="", ssh_repr_remote="", error_message="", session_name="", tab_name="", file_manager_path="")
-    @staticmethod
-    def from_func(func: Union[Callable[[Any], Any], P, str]) -> 'JobParams':
-        # if callable(self.func): executed_obj = f"""**{self.func.__name__}** from *{P(self.func.__code__.co_filename).collapseuser().as_posix()}*"""  # for email.
-        if callable(func) and not isinstance(func, P):
-            func_name = func.__name__
-            func_module = func.__module__
-            if func_module == "<run_path>":  # function imported through readpy module.
-                func_module = P(func.__globals__['__file__']).name
-            assert func_module != "__main__", f"Function must be defined in a module, not in __main__. Consider importing `{func.__name__}` or, restart this session and import the contents of this module."
-            if func.__name__ != func.__qualname__:
-                # print(f"Passed function {func} is a method of a class.")
-                func_file, func_class = P(func.__code__.co_filename), func.__qualname__.split(".")[0]
-            else:
-                # print(f"Passed function {func} is not a method of a class.")
-                func_file, func_class = P(func.__code__.co_filename), None
-        elif type(func) is str or type(func) is P:
-            func_file = P(func)
-            # func = None
-            func_class = None
-            func_name = None
-            func_module = func_file.stem
-        else: raise TypeError(f"Passed function {func} is not a callable or a path to a python file.")
-        try:
-            repo_path = P(git.Repo(func_file, search_parent_directories=True).working_dir)
-            func_relative_file = func_file.relative_to(repo_path)
-        except Exception as e:
-            print(e)
-            repo_path, func_relative_file = func_file.parent, func_file.name
-        return JobParams(repo_path_rh=repo_path.collapseuser().as_posix(), file_path_rh=repo_path.collapseuser().joinpath(func_relative_file).collapseuser().as_posix(),
-                         file_path_r=P(func_relative_file).as_posix(),
-                         func_module=func_module, func_class=func_class, func_name=func_name,
-                         description="", ssh_repr="", ssh_repr_remote="", error_message="",
-                         session_name="", tab_name="", file_manager_path="")
+#     def is_installabe(self) -> bool: return True if "setup.py" in PathExtended(self.repo_path_rh).expanduser().absolute().listdir().apply(str) else False
+#     @staticmethod
+#     def from_empty() -> 'JobParams':
+#         return JobParams(repo_path_rh="", file_path_rh="", file_path_r="", func_module="", func_class="", func_name="", description="", ssh_repr="", ssh_repr_remote="", error_message="", session_name="", tab_name="", file_manager_path="")
+#     @staticmethod
+#     def from_func(func: Union[Callable[[Any], Any], P, str]) -> 'JobParams':
+#         # if callable(self.func): executed_obj = f"""**{self.func.__name__}** from *{P(self.func.__code__.co_filename).collapseuser().as_posix()}*"""  # for email.
+#         if callable(func) and not isinstance(func, P):
+#             func_name = func.__name__
+#             func_module = func.__module__
+#             if func_module == "<run_path>":  # function imported through readpy module.
+#                 func_module = PathExtended(func.__globals__['__file__']).name
+#             assert func_module != "__main__", f"Function must be defined in a module, not in __main__. Consider importing `{func.__name__}` or, restart this session and import the contents of this module."
+#             if func.__name__ != func.__qualname__:
+#                 # print(f"Passed function {func} is a method of a class.")
+#                 func_file, func_class = PathExtended(func.__code__.co_filename), func.__qualname__.split(".")[0]
+#             else:
+#                 # print(f"Passed function {func} is not a method of a class.")
+#                 func_file, func_class = PathExtended(func.__code__.co_filename), None
+#         elif type(func) is str or type(func) is P:
+#             func_file = PathExtended(func)
+#             # func = None
+#             func_class = None
+#             func_name = None
+#             func_module = func_file.stem
+#         else: raise TypeError(f"Passed function {func} is not a callable or a path to a python file.")
+#         try:
+#             repo_path = PathExtended(git.Repo(func_file, search_parent_directories=True).working_dir)
+#             func_relative_file = func_file.relative_to(repo_path)
+#         except Exception as e:
+#             print(e)
+#             repo_path, func_relative_file = func_file.parent, func_file.name
+#         return JobParams(repo_path_rh=repo_path.collapseuser().as_posix(), file_path_rh=repo_path.collapseuser().joinpath(func_relative_file).collapseuser().as_posix(),
+#                          file_path_r=PathExtended(func_relative_file).as_posix(),
+#                          func_module=func_module, func_class=func_class, func_name=func_name,
+#                          description="", ssh_repr="", ssh_repr_remote="", error_message="",
+#                          session_name="", tab_name="", file_manager_path="")
 
-    def get_execution_line(self, workload_params: Optional[WorkloadParams], parallelize: bool, wrap_in_try_except: bool) -> str:
-        # P(self.repo_path_rh).name}.{self.file_path_r.replace(".py", '').replace('/', '.')#
-        # if func_module is not None:
-        #     # noinspection PyTypeChecker
-        #     module = __import__(func_module, fromlist=[None])
-        #     exec_obj = module.__dict__[func_name] if not bool(func_class) else getattr(module.__dict__[func_class], func_name)
-        # elif func_name is not None:
-        #     # This approach is not conducive to parallelization since "mymod" is not pickleable.
-        #     module = SourceFileLoader("mymod", P.home().joinpath(rel_full_path).as_posix()).load_module()  # loading the module assumes its not a script, there should be at least if __name__ == __main__ wrapping any script.
-        #     exec_obj = getattr(module, func_name) if not bool(func_class) else getattr(getattr(module, func_class), func_name)
-        # else:
-        #     module = P.home().joinpath(rel_full_path).readit()  # uses runpy to read .py files.
-        #     exec_obj = module  # for README.md generation.
+#     def get_execution_line(self, workload_params: Optional[WorkloadParams], parallelize: bool, wrap_in_try_except: bool) -> str:
+#         # PathExtended(self.repo_path_rh).name}.{self.file_path_r.replace(".py", '').replace('/', '.')#
+#         # if func_module is not None:
+#         #     # noinspection PyTypeChecker
+#         #     module = __import__(func_module, fromlist=[None])
+#         #     exec_obj = module.__dict__[func_name] if not bool(func_class) else getattr(module.__dict__[func_class], func_name)
+#         # elif func_name is not None:
+#         #     # This approach is not conducive to parallelization since "mymod" is not pickleable.
+#         #     module = SourceFileLoader("mymod", PathExtended.home().joinpath(rel_full_path).as_posix()).load_module()  # loading the module assumes its not a script, there should be at least if __name__ == __main__ wrapping any script.
+#         #     exec_obj = getattr(module, func_name) if not bool(func_class) else getattr(getattr(module, func_class), func_name)
+#         # else:
+#         #     module = PathExtended.home().joinpath(rel_full_path).readit()  # uses runpy to read .py files.
+#         #     exec_obj = module  # for README.md generation.
 
-        if workload_params is not None: base = f"""
-workload_params = WorkloadParams(**{workload_params.__dict__})
-repo_path = P(rf'{self.repo_path_rh}').expanduser().absolute()
-file_root = P(rf'{self.file_path_rh}').expanduser().absolute().parent
-tb.sys.path.insert(0, repo_path.str)
-tb.sys.path.insert(0, file_root.str)
-"""
-        else: base = ""
+#         if workload_params is not None: base = f"""
+# workload_params = WorkloadParams(**{workload_params.__dict__})
+# repo_path = PathExtended(rf'{self.repo_path_rh}').expanduser().absolute()
+# file_root = PathExtended(rf'{self.file_path_rh}').expanduser().absolute().parent
+# tb.sys.path.insert(0, repo_path.str)
+# tb.sys.path.insert(0, file_root.str)
+# """
+#         else: base = ""
 
-        # loading function ===============================================================
-        if self.func_name is not None:
-            if self.func_class is None: base += f"""
-from {self.func_module.replace('.py', '')} import {self.func_name} as func
-"""
-            elif self.func_class is not None:  # type: ignore
-                base += f"""
-from {self.func_module.replace('.py', '')} import {self.func_class} as {self.func_class}
-func = {self.func_class}.{self.func_name}
-"""
-        else: base = f"""
-res = None  # in case the file did not define it.
-# --------------------------------- SCRIPT AS IS
-{P(self.file_path_rh).expanduser().read_text()}
-# --------------------------------- END OF SCRIPT AS IS
-"""
+#         # loading function ===============================================================
+#         if self.func_name is not None:
+#             if self.func_class is None: base += f"""
+# from {self.func_module.replace('.py', '')} import {self.func_name} as func
+# """
+#             elif self.func_class is not None:  # type: ignore
+#                 base += f"""
+# from {self.func_module.replace('.py', '')} import {self.func_class} as {self.func_class}
+# func = {self.func_class}.{self.func_name}
+# """
+#         else: base = f"""
+# res = None  # in case the file did not define it.
+# # --------------------------------- SCRIPT AS IS
+# {P(self.file_path_rh).expanduser().read_text()}
+# # --------------------------------- END OF SCRIPT AS IS
+# """
 
-        if workload_params is not None and parallelize is False: base += """
-res = func(workload_params=workload_params, **func_kwargs)
-"""
-        elif workload_params is not None and parallelize is True: base += f"""
-kwargs_workload = {list(workload_params.split_to_jobs().apply(lambda a_kwargs: a_kwargs.__dict__))}
-workload_params = []
-for idx, x in enumerate(kwargs_workload):
-    S(x).print(as_config=True, title=f"Instance {{idx}}")
-    workload_params.append(WorkloadParams(**x))
-print("\n" * 2)
-res = L(workload_params).apply(lambda a_workload_params: func(workload_params=a_workload_params, **func_kwargs), jobs={workload_params.jobs})
-"""
-        else: base += """
-res = func(**func_kwargs)
-"""
+#         if workload_params is not None and parallelize is False: base += """
+# res = func(workload_params=workload_params, **func_kwargs)
+# """
+#         elif workload_params is not None and parallelize is True: base += f"""
+# kwargs_workload = {list([item.__dict__ for item in workload_params.split_to_jobs()])}
+# workload_params = []
+# for idx, x in enumerate(kwargs_workload):
+#             pprint(x, f"Instance {{idx}}")
+#     workload_params.append(WorkloadParams(**x))
+# print("\n" * 2)
+# res = L(workload_params).apply(lambda a_workload_params: func(workload_params=a_workload_params, **func_kwargs), jobs={workload_params.jobs})
+# """
+#         else: base += """
+# res = func(**func_kwargs)
+# """
 
-        if wrap_in_try_except:
-            import textwrap
-            base = textwrap.indent(base, " " * 4)
-            base = f"""
-try:
-{base}
-except Exception as e:
-    print(e)
-    params.error_message = str(e)
-    res = None
+#         if wrap_in_try_except:
+#             import textwrap
+#             base = textwrap.indent(base, " " * 4)
+#             base = f"""
+# try:
+# {base}
+# except Exception as e:
+#     print(e)
+#     params.error_message = str(e)
+#     res = None
 
-"""
-        return base
+# """
+#         return base

machineconfig/cluster/loader_runner.py

@@ -1,150 +1,184 @@
 
-"""
-Runner
-"""
-
-from rich.console import Console
-import pandas as pd
-
-from crocodile.core import List as L, Struct as S, randstr
-from crocodile.file_management_helpers.file4 import Read
-from crocodile.meta import SSH
-from machineconfig.cluster.self_ssh import SelfSSH
-
-from typing import Optional, Any, Literal, TypeAlias, Union
-from dataclasses import dataclass, field
-
-
-JOB_STATUS: TypeAlias = Literal["queued", "running", "completed", "failed"]
-TRANSFER_METHOD: TypeAlias = Literal["sftp", "transfer_sh", "cloud"]
-LAUNCH_METHOD: TypeAlias = Literal["remotely", "cloud_manager"]
-console = Console()
-
-
-@dataclass
-class WorkloadParams:
-    idx_min: int = 0
-    idx_max: int = 1000
-    idx_start: int = 0
-    idx_end: int = 1000
-    idx: int = 0
-    jobs: int = 3
-    job_id: str = ''
-    @property
-    def save_suffix(self) -> str: return f"machine_{self.idx_start}_{self.idx_end}"
-    def split_to_jobs(self, jobs: Optional[int] = None) -> L['WorkloadParams']:
-        # Note: like MachineLoadCalculator get_kwargs, the behaviour is to include the edge cases on both ends of subsequent intervals.
-        res = L(range(self.idx_start, self.idx_end, 1)).split(to=jobs or self.jobs).apply(lambda sub_list: WorkloadParams(idx_start=sub_list.list[0], idx_end=sub_list.list[-1] + 1, idx_max=self.idx_max, jobs=self.jobs))
-        for idx, item in enumerate(res): item.idx = idx
-        return res
-    def get_section_from_series(self, series: list[pd.Timestamp]):
-        from math import floor
-        min_idx_start = int(floor((len(series) - 1) * self.idx_start / self.idx_max))
-        min_idx_end = int(floor((len(series) - 1) * self.idx_end / self.idx_max))
-        min_start = series[min_idx_start]
-        min_end = series[min_idx_end]
-        return min_start, min_end
-    def print(self): S(self.__dict__).print(as_config=True, title="Job Workload")
-    def viz(self):
-        print(f"This machine will execute ({(self.idx_end - self.idx_start) / self.idx_max * 100:.2f}%) of total job workload.")
-        print(f"This share of workload will be split among {self.jobs} of threads on this machine.")
-
-
-@dataclass
-class JobStatus:
-    pid: int
-    job_id: str
-    status: Literal['locked', 'unlocked']
-    submission_time: pd.Timestamp
-    start_time: Optional[pd.Timestamp] = None
-
-
-@dataclass
-class EmailParams:
-    addressee: str
-    speaker: str
-    ssh_conn_str: str
-    executed_obj: str
-    email_config_name: str
-    to_email: str
-    file_manager_path: str
-    @staticmethod
-    def from_empty() -> 'EmailParams': return EmailParams(addressee="", speaker="", ssh_conn_str="", executed_obj="", email_config_name="", to_email="", file_manager_path="")
-
-
-@dataclass
-class LogEntry:
-    name: str
-    submission_time: str
-    start_time: Optional[str]
-    end_time: Optional[str]
-    run_machine: Optional[str]
-    session_name: Optional[str]
-    pid: Optional[int]
-    cmd: Optional[str]
-    source_machine: str
-    note: str
-    @staticmethod
-    def from_dict(a_dict: dict[str, Any]):
-        return LogEntry(name=a_dict["name"], submission_time=pd.to_datetime(a_dict["submission_time"]), start_time=pd.to_datetime(a_dict["start_time"]), end_time=pd.to_datetime(a_dict["end_time"]),
-                        run_machine=a_dict["run_machine"], source_machine=a_dict["source_machine"], note=a_dict["note"], pid=a_dict["pid"], cmd=a_dict["cmd"], session_name=a_dict["session_name"])
-
-
-
-@dataclass
-class RemoteMachineConfig:
-    # conn
-    job_id: str = field(default_factory=lambda: randstr(noun=True))
-    base_dir: str = "~/tmp_results/remote_machines/jobs"
-    description: str = ""
-    ssh_params: dict[str, Union[str, int]] = field(default_factory=lambda: {})
-    ssh_obj: Union[SSH, 'SelfSSH', None] = None
-
-    # data
-    copy_repo: bool = False
-    update_repo: bool = False
-    install_repo: bool = False
-    update_essential_repos: bool = True
-    data: Optional[list[Any]] = None
-    transfer_method: TRANSFER_METHOD = "sftp"
-    cloud_name: Optional[str] = None
-
-    # remote machine behaviour
-    allowed_remotes: Optional[list[str]] = None
-    open_console: bool = True
-    notify_upon_completion: bool = False
-    to_email: Optional[str] = None
-    email_config_name: Optional[str] = None
-
-    # execution behaviour
-    launch_method: LAUNCH_METHOD = "remotely"
-    kill_on_completion: bool = False
-    ipython: bool = False
-    interactive: bool = False
-    pdb: bool = False
-    pudb: bool = False
-    wrap_in_try_except: bool = False
-    parallelize: bool = False
-    lock_resources: bool = True
-    max_simulataneous_jobs: int = 1
-    workload_params: Optional[WorkloadParams] = None
-    def __post_init__(self) -> None:
-        if self.interactive and self.lock_resources: print("RemoteMachineConfig Warning: If interactive is ON along with lock_resources, the job might never end. ⚠️")
-        if self.transfer_method == "cloud": assert self.cloud_name is not None, "Cloud name is not provided. 🤷‍♂️"
-        if self.notify_upon_completion and self.to_email is None:
-            from machineconfig.utils.utils import DEFAULTS_PATH
-            try:
-                section = Read.ini(DEFAULTS_PATH)['general']
-                self.to_email = section['to_email']
-            except (FileNotFoundError, KeyError, IndexError) as err: raise ValueError(f"Email address is not provided. 🤷‍♂️ & default could not be read @ `{DEFAULTS_PATH}`") from err
-        if self.notify_upon_completion and self.email_config_name is None:
-            from machineconfig.utils.utils import DEFAULTS_PATH
-            try:
-                section = Read.ini(DEFAULTS_PATH)['general']
-                self.email_config_name = section['email_config_name']
-            except (FileNotFoundError, KeyError, IndexError) as err: raise ValueError(f"Email config name is not provided. 🤷‍♂️ & default could not be read @ `{DEFAULTS_PATH}`") from err
-
-
-
-if __name__ == '__main__':
-    pass
+# """
+# Runner
+# """
+
+# from rich.console import Console
+# from machineconfig.utils.utils2 import pprint, read_ini
+# from datetime import datetime
+
+# from machineconfig.utils.utils2 import randstr
+
+# from machineconfig.cluster.self_ssh import SelfSSH
+
+# from typing import Optional, Any, Literal, TypeAlias, Union
+# from dataclasses import dataclass, field
+
+
+# JOB_STATUS: TypeAlias = Literal["queued", "running", "completed", "failed"]
+# TRANSFER_METHOD: TypeAlias = Literal["sftp", "transfer_sh", "cloud"]
+# LAUNCH_METHOD: TypeAlias = Literal["remotely", "cloud_manager"]
+# console = Console()
+
+
+# @dataclass
+# class WorkloadParams:
+#     idx_min: int = 0
+#     idx_max: int = 1000
+#     idx_start: int = 0
+#     idx_end: int = 1000
+#     idx: int = 0
+#     jobs: int = 3
+#     job_id: str = ''
+#     @property
+#     def save_suffix(self) -> str: return f"machine_{self.idx_start}_{self.idx_end}"
+#     def split_to_jobs(self, jobs: Optional[int] = None) -> list['WorkloadParams']:
+#         # Evenly split the integer range [idx_start, idx_end) into contiguous chunks
+#         # and return a list of WorkloadParams describing each chunk.
+#         num_jobs = jobs or self.jobs or 1
+#         total_items = max(0, self.idx_end - self.idx_start)
+#         if total_items == 0:
+#             return []
+#         # Do not create more jobs than items to avoid empty chunks
+#         num_jobs = min(num_jobs, total_items)
+
+#         indices = list(range(self.idx_start, self.idx_end))
+#         result: list[WorkloadParams] = []
+#         for i in range(num_jobs):
+#             start_offset = (i * total_items) // num_jobs
+#             end_offset = ((i + 1) * total_items) // num_jobs
+#             chunk = indices[start_offset:end_offset]
+#             if not chunk:
+#                 continue
+#             result.append(
+#                 WorkloadParams(
+#                     idx_start=chunk[0],
+#                     idx_end=chunk[-1] + 1,  # make end exclusive
+#                     idx_max=self.idx_max,
+#                     jobs=self.jobs,
+#                 )
+#             )
+#         for idx, item in enumerate(result):
+#             item.idx = idx
+#         return result
+#     def get_section_from_series(self, series: list[datetime]):
+#         from math import floor
+#         min_idx_start = int(floor((len(series) - 1) * self.idx_start / self.idx_max))
+#         min_idx_end = int(floor((len(series) - 1) * self.idx_end / self.idx_max))
+#         min_start = series[min_idx_start]
+#         min_end = series[min_idx_end]
+#         return min_start, min_end
+#     def print(self): pprint(self.__dict__, "Job Workload")
+#     def viz(self):
+#         print(f"This machine will execute ({(self.idx_end - self.idx_start) / self.idx_max * 100:.2f}%) of total job workload.")
+#         print(f"This share of workload will be split among {self.jobs} of threads on this machine.")
+
+
+# @dataclass
+# class JobStatus:
+#     pid: int
+#     job_id: str
+#     status: Literal['locked', 'unlocked']
+#     submission_time: datetime
+#     start_time: Optional[datetime] = None
+
+
+# @dataclass
+# class EmailParams:
+#     addressee: str
+#     speaker: str
+#     ssh_conn_str: str
+#     executed_obj: str
+#     email_config_name: str
+#     to_email: str
+#     file_manager_path: str
+#     @staticmethod
+#     def from_empty() -> 'EmailParams': return EmailParams(addressee="", speaker="", ssh_conn_str="", executed_obj="", email_config_name="", to_email="", file_manager_path="")
+
+
+# @dataclass
+# class LogEntry:
+#     name: str
+#     submission_time: str
+#     start_time: Optional[str]
+#     end_time: Optional[str]
+#     run_machine: Optional[str]
+#     session_name: Optional[str]
+#     pid: Optional[int]
+#     cmd: Optional[str]
+#     source_machine: str
+#     note: str
+#     @staticmethod
+#     def from_dict(a_dict: dict[str, Any]):
+#         return LogEntry(
+#             name=a_dict["name"], 
+#             submission_time=str(a_dict["submission_time"]), 
+#             start_time=str(a_dict["start_time"]) if a_dict.get("start_time") else None, 
+#             end_time=str(a_dict["end_time"]) if a_dict.get("end_time") else None,
+#             run_machine=a_dict.get("run_machine"), 
+#             source_machine=a_dict.get("source_machine", ""), 
+#             note=a_dict.get("note", ""), 
+#             pid=a_dict.get("pid"), 
+#             cmd=a_dict.get("cmd"), 
+#             session_name=a_dict.get("session_name")
+#         )
+
+
+
+# @dataclass
+# class RemoteMachineConfig:
+#     # conn
+#     job_id: str = field(default_factory=lambda: randstr(noun=True))
+#     base_dir: str = "~/tmp_results/remote_machines/jobs"
+#     description: str = ""
+#     ssh_params: dict[str, Union[str, int]] = field(default_factory=lambda: {})
+#     ssh_obj: Union[SSH, 'SelfSSH', None] = None
+
+#     # data
+#     copy_repo: bool = False
+#     update_repo: bool = False
+#     install_repo: bool = False
+#     update_essential_repos: bool = True
+#     data: Optional[list[Any]] = None
+#     transfer_method: TRANSFER_METHOD = "sftp"
+#     cloud_name: Optional[str] = None
+
+#     # remote machine behaviour
+#     allowed_remotes: Optional[list[str]] = None
+#     open_console: bool = True
+#     notify_upon_completion: bool = False
+#     to_email: Optional[str] = None
+#     email_config_name: Optional[str] = None
+
+#     # execution behaviour
+#     launch_method: LAUNCH_METHOD = "remotely"
+#     kill_on_completion: bool = False
+#     ipython: bool = False
+#     interactive: bool = False
+#     pdb: bool = False
+#     pudb: bool = False
+#     wrap_in_try_except: bool = False
+#     parallelize: bool = False
+#     lock_resources: bool = True
+#     max_simulataneous_jobs: int = 1
+#     workload_params: Optional[WorkloadParams] = None
+#     def __post_init__(self) -> None:
+#         if self.interactive and self.lock_resources: print("RemoteMachineConfig Warning: If interactive is ON along with lock_resources, the job might never end. ⚠️")
+#         if self.transfer_method == "cloud": assert self.cloud_name is not None, "Cloud name is not provided. 🤷‍♂️"
+#         if self.notify_upon_completion and self.to_email is None:
+#             from machineconfig.utils.utils import DEFAULTS_PATH
+#             try:
+#                 section = read_ini(DEFAULTS_PATH)['general']
+#                 self.to_email = section['to_email']
+#             except (FileNotFoundError, KeyError, IndexError) as err: raise ValueError(f"Email address is not provided. 🤷‍♂️ & default could not be read @ `{DEFAULTS_PATH}`") from err
+#         if self.notify_upon_completion and self.email_config_name is None:
+#             from machineconfig.utils.utils import DEFAULTS_PATH
+#             try:
+#                 section = read_ini(DEFAULTS_PATH)['general']
+#                 self.email_config_name = section['email_config_name']
+#             except (FileNotFoundError, KeyError, IndexError) as err: raise ValueError(f"Email config name is not provided. 🤷‍♂️ & default could not be read @ `{DEFAULTS_PATH}`") from err
+
+
+
+# if __name__ == '__main__':
+#     pass