machineconfig 1.8__py3-none-any.whl → 1.9__py3-none-any.whl

machineconfig/scripts/python/cloud_repo_sync.py

@@ -20,6 +20,7 @@ def get_wt_cmd(wd1: P, wd2: P) -> str:
     ]
     return " `; ".join(lines)
 
+
 def get_zellij_cmd(wd1: P, wd2: P) -> str:
     lines = [f""" zellij action new-tab --name gitdiff""",
              f"""zellij action new-pane --direction down --name local --cwd ./data """,
@@ -65,38 +66,38 @@ def main(cloud: Optional[str] = None, path: Optional[str] = None, message: Optio
             return ""
     else: cloud_resolved = cloud
     # repo_root = P(args.repo).expanduser().absolute()
-    repo_root = P.cwd() if path is None else P(path).expanduser().absolute()
-    repo_obj = install_n_import("git", "gitpython").Repo(repo_root, search_parent_directories=True)
-    repo_root = P(repo_obj.working_dir)  # cwd might have been in a sub directory of repo_root, so its better to redefine it.
+    repo_local_root = P.cwd() if path is None else P(path).expanduser().absolute()
+    repo_local_obj = install_n_import("git", "gitpython").Repo(repo_local_root, search_parent_directories=True)
+    repo_local_root = P(repo_local_obj.working_dir)  # cwd might have been in a sub directory of repo_root, so its better to redefine it.
     CONFIG_PATH.joinpath("remote").create()
-    repo_sync_root = CONFIG_PATH.joinpath("remote", repo_root.rel2home())  # .delete(sure=True)
+    repo_remote_root = CONFIG_PATH.joinpath("remote", repo_local_root.rel2home())  # .delete(sure=True)
     try:
         print("\n", "=============================== Downloading Remote Repo ====================================")
-        remote_path = repo_root.get_remote_path(rel2home=True, os_specific=False, root="myhome") + ".zip.enc"
-        repo_sync_root.from_cloud(remotepath=remote_path, cloud=cloud_resolved, unzip=True, decrypt=True, rel2home=True, os_specific=False, pwd=pwd)
+        remote_path = repo_local_root.get_remote_path(rel2home=True, os_specific=False, root="myhome") + ".zip.enc"
+        repo_remote_root.from_cloud(remotepath=remote_path, cloud=cloud_resolved, unzip=True, decrypt=True, rel2home=True, os_specific=False, pwd=pwd)
     except AssertionError:
         print("Remote does not exist, creating it and exiting ... ")
-        repo_root.to_cloud(cloud=cloud_resolved, zip=True, encrypt=True, rel2home=True, pwd=pwd, os_specific=False)
+        repo_local_root.to_cloud(cloud=cloud_resolved, zip=True, encrypt=True, rel2home=True, pwd=pwd, os_specific=False)
         return ""
-    repo_sync_obj = install_n_import("git", "gitpython").Repo(repo_sync_root)
-    if repo_sync_obj.is_dirty():
-        print("=" * 50, '\n', f"WRANING: the remote `{repo_sync_root}` is dirty, please commit or stash changes before proceeding.", '\n', "=" * 50)
+    repo_remote_obj = install_n_import("git", "gitpython").Repo(repo_remote_root)
+    if repo_remote_obj.is_dirty():
+        print("=" * 50, '\n', f"WRANING: the remote `{repo_remote_root}` is dirty, please commit or stash changes before proceeding.", '\n', "=" * 50)
 
     script = f"""
 echo ""
 echo "=============================== Committing Local Changes ==================================="
-cd {repo_root}
+cd {repo_local_root}
 git status
 git add .
 git commit -am "{message}"
 echo ""
 echo ""
 echo "=============================== Pulling Latest From Remote ================================"
-cd {repo_root}
+cd {repo_local_root}
 echo '-> Trying to removing originEnc remote from local repo if it exists.'
 git remote remove originEnc
 echo '-> Adding originEnc remote to local repo'
-git remote add originEnc {repo_sync_root}
+git remote add originEnc {repo_remote_root}
 echo '-> Fetching originEnc remote.'
 git pull originEnc master
 
@@ -106,34 +107,41 @@ git pull originEnc master
 
     if res.is_successful(strict_err=True, strict_returcode=True):
         print("\n", "Pull succeeded, removing originEnc, the local copy of remote & pushing merged repo_root to remote ... ")
-        repo_sync_root.delete(sure=True)
+        repo_remote_root.delete(sure=True)
         from git.remote import Remote
-        Remote.remove(repo_obj, "originEnc")
+        Remote.remove(repo_local_obj, "originEnc")
         if push:
-            repo_root.to_cloud(cloud=cloud_resolved, zip=True, encrypt=True, rel2home=True, pwd=pwd, os_specific=False)
+            repo_local_root.to_cloud(cloud=cloud_resolved, zip=True, encrypt=True, rel2home=True, pwd=pwd, os_specific=False)
     else:
-        print(f"Failed to pull, keeping local copy of remote at {repo_sync_root} ... ")
+        print(f"Failed to pull, keeping local copy of remote at {repo_remote_root} ... ")
 
         if push:
             if skip_confirmation: resp = "y"
-            else: resp = input(f"Would you like to proceed syncing `{repo_root}` to `{cloud_resolved}` by pushing local changes to remote and deleting local copy of remote? y/[n] ") or "n"
+            else: resp = input(f"Would you like to proceed syncing `{repo_local_root}` to `{cloud_resolved}` by pushing local changes to remote and deleting local copy of remote? y/[n] ") or "n"
         else: resp = "n"
 
         if resp.lower() == "y":
-            delete_remote_repo_copy_and_push_local(remote_repo=repo_sync_root.str, local_repo=repo_root.str, cloud=cloud_resolved)
+            delete_remote_repo_copy_and_push_local(remote_repo=repo_remote_root.str, local_repo=repo_local_root.str, cloud=cloud_resolved)
         else:
             program = f"""
 from machineconfig.scripts.python.cloud_repo_sync import delete_remote_repo_copy_and_push_local as func
-func(remote_repo=r'{repo_sync_root.str}', local_repo=r'{repo_root.str}', cloud=r'{cloud_resolved}')
+func(remote_repo=r'{repo_remote_root.str}', local_repo=r'{repo_local_root.str}', cloud=r'{cloud_resolved}')
 """
             shell_file = get_shell_file_executing_python_script(python_script=program)
             print(f"When ready, use this snippet: \n. {shell_file}")
+            print(f"""
+Or, if you want to delete local repo and replace with remote, run the following bash commands:
+          
+rm -rfd {repo_local_root}
+mv {repo_remote_root} {repo_local_root}
+
+""")
             if platform.system() == "Windows":
-                program = get_wt_cmd(wd1=repo_root, wd2=repo_sync_root)
+                program = get_wt_cmd(wd1=repo_local_root, wd2=repo_remote_root)
                 write_shell_script(program=program, execute=True)
                 return None
             elif platform.system() == "Linux":
-                program = get_zellij_cmd(wd1=repo_root, wd2=repo_sync_root)
+                program = get_zellij_cmd(wd1=repo_local_root, wd2=repo_remote_root)
                 write_shell_script(program=program, execute=True)
                 return None
             else: raise NotImplementedError(f"Platform {platform.system()} not implemented.")

machineconfig/scripts/python/cloud_sync.py

@@ -5,14 +5,17 @@ TODO: use typer to make clis
 """
 
 from crocodile.file_management import P, Read, Struct
-from crocodile.core import install_n_import
+# from crocodile.core import install_n_import
 from machineconfig.utils.utils import PROGRAM_PATH, DEFAULTS_PATH
 from machineconfig.scripts.python.cloud_mount import get_mprocs_mount_txt
 import argparse
 import os
 from typing import Optional
 # from dataclasses import dataclass
+# install_n_import("pydantic")
 # from tap import Tap
+from pydantic.dataclasses import dataclass
+from pydantic import ConfigDict
 
 
 ES = "^"  # chosen carefully to not mean anything on any shell. `$` was a bad choice.
@@ -32,11 +35,6 @@ class ArgsDefaults:
     pwd = None
 
 
-install_n_import("pydantic")
-from pydantic.dataclasses import dataclass  # type: ignore # ruffle: ignore
-from pydantic import ConfigDict
-
-
 @dataclass(config=ConfigDict(extra="forbid", frozen=True))
 class Args():
     cloud: Optional[str] = None

machineconfig/scripts/python/croshell.py

@@ -8,7 +8,7 @@ import argparse
 # import subprocess
 # import platform
 from crocodile.file_management import P, randstr
-from machineconfig.utils.ve import get_ipython_profile, get_ve_profile
+from machineconfig.utils.ve import get_ipython_profile, get_ve_profile, get_ve_name_and_ipython_profile
 from machineconfig.utils.utils import PROGRAM_PATH, display_options
 
 
@@ -34,8 +34,8 @@ def get_read_data_pycode(path: str):
 p = P(r\'{path}\').absolute()
 try:
     dat = p.readit()
-    if type(dat) == Struct: dat.print(as_config=True, title=p.name)
-    else: print(f"Succcesfully read the file {{p.name}}")
+    if isinstance(dat, dict): Struct(dat).print(as_config=True, title=p.name)
+    else: print(f"Successfully read the file {{p.name}}")
 except Exception as e:
     print(e)
 
@@ -93,17 +93,23 @@ def build_parser():
         options = P.cwd().search("*.py", r=True).apply(str).list
         file = display_options(msg="Choose a python file to run", options=options, fzf=True, multi=False, )
         assert isinstance(file, str)
-        if profile is None: profile = profile = get_ipython_profile(P(file))
+        if profile is None:
+            profile = get_ipython_profile(P(file))
         program = P(file).read_text(encoding='utf-8')
 
     elif args.file != "":
         file = P(args.file.lstrip()).expanduser().absolute()
-        if profile is None: profile = profile = get_ipython_profile(P(file))
+        if profile is None:
+            profile = get_ipython_profile(P(file))
         program = get_read_pyfile_pycode(file, as_module=args.module, cmd=args.cmd)
 
     elif args.read != "":
         file = P(str(args.read).lstrip()).expanduser().absolute()
-        if profile is None: profile = profile = get_ipython_profile(P(file))
+        ve_name_from_file, ipy_profile_from_file = get_ve_name_and_ipython_profile(init_path=P(file))
+        # if profile is None:
+        #     profile = get_ipython_profile(P(file))
+        if profile is None: profile = ipy_profile_from_file
+        if args.ve is None: args.ve = ve_name_from_file
         program = get_read_data_pycode(str(file))
 
     else:  # just run croshell.py interactively
@@ -129,7 +135,9 @@ print_logo(logo="crocodile")
     total_program = preprogram + add_print_header_pycode(str(pyfile), title=title) + program
 
     pyfile.write_text(total_program, encoding='utf-8')
-    if profile is None: profile = "default"
+    if profile is None:
+        profile = get_ipython_profile(P.cwd())
+        # profile = "default"
 
     ve = get_ve_profile(P(file)) if args.ve is None else str(args.ve)
 
@@ -140,7 +148,8 @@ print_logo(logo="crocodile")
     if interpreter == "ipython": final_program += f"{interactivity} --profile {profile} --no-banner"
     final_program += f" {str(pyfile)}"
     print(f"🔥 sourcing  ... {pyfile}")
-    PROGRAM_PATH.write_text(final_program)
+    # print(f"Running ... {final_program}")
+    PROGRAM_PATH.write_text(data=final_program)
 
     # if platform.system() == "Windows":
         # return subprocess.run([f"powershell", "-Command", res], shell=True, capture_output=False, text=True, check=True)

machineconfig/scripts/python/devops_devapps_install.py

@@ -3,6 +3,7 @@
 """
 
 # import subprocess
+from tqdm import tqdm
 from crocodile.core import List as L
 from machineconfig.utils.utils import LIBRARY_ROOT, choose_multiple_options
 from machineconfig.utils.installer import get_installers, Installer, install_all
@@ -15,11 +16,10 @@ WHICH: TypeAlias = Literal["AllEssentials", "EssentialsAndOthers", "SystemInstal
 
 def main(which: Optional[str] = None):
     sys = system()
-    installers = get_installers(dev=False, system=sys) + get_installers(dev=True, system=sys)
+    installers = get_installers(dev=False, system=sys)  # + get_installers(dev=True, system=sys)
     default = "AllEssentials"
-    options = ["SystemInstallers", "OtherDevApps", "EssentialsAndOthers", "PrecheckedCloudInstaller"]
-    options = [default] + options
-    options = [x.get_description() for x in installers] + options
+    options = ["SystemInstallers", "OtherDevApps", "EssentialsAndOthers", "PrecheckedCloudInstaller", default]
+    options = [x.get_description() for x in tqdm(installers, desc="Checking installed programs")] + options
 
     if which is not None:
         return get_program(program_name=which, options=options, installers=list(installers))
@@ -41,7 +41,10 @@ def get_program(program_name: str, options: list[str], installers: list[Installe
         program = ""
     elif program_name == "SystemInstallers":
         if system() == "Windows": options_system = parse_apps_installer_windows(LIBRARY_ROOT.joinpath("setup_windows/apps.ps1").read_text())
-        elif system() == "Linux": options_system = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps.sh").read_text())
+        elif system() == "Linux":
+            options_system_1 = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps_dev.sh").read_text())
+            options_system_2 = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps.sh").read_text())
+            options_system = {**options_system_1, **options_system_2}
         else: raise NotImplementedError(f"System {system()} not supported")
         program_names = choose_multiple_options(msg="", options=sorted(list(options_system.keys())), header="CHOOSE DEV APP")
         program = ""
@@ -51,10 +54,12 @@ def get_program(program_name: str, options: list[str], installers: list[Installe
             program += "\n" + sub_program
     elif program_name == "OtherDevApps":
         installers = get_installers(dev=True, system=system())
-        options__: list[str] = [x.get_description() for x in installers]
+        options__: list[str] = [x.get_description() for x in tqdm(installers, desc="Checking installed programs")]
         program_names = choose_multiple_options(msg="", options=sorted(options__) + ["all"], header="CHOOSE DEV APP")
         if "all" in program_names: program_names = options__
         program = ""
+        print(f"Installing:")
+        L(program_names).print()
         for name in program_names:
             try:
                 idx = options__.index(name)
@@ -62,6 +67,7 @@ def get_program(program_name: str, options: list[str], installers: list[Installe
                 print(f"{name=}")
                 print(f"{options__=}")
                 raise ve
+            print(f"Installing {name}")
             sub_program = installers[idx].install_robust(version=None)  # finish the task
     elif program_name == "PrecheckedCloudInstaller":
         from machineconfig.jobs.python.check_installations import PrecheckedCloudInstaller

machineconfig/scripts/python/fire_jobs.py

@@ -1,14 +1,15 @@
 
 """
 fire
-"""
-
 
-from machineconfig.utils.utils import display_options, choose_one_option, PROGRAM_PATH, choose_ssh_host, match_file_name, sanitize_path
-# from crocodile.run import *
 # https://github.com/pallets/click combine with fire. Consider
 # https://github.com/ceccopierangiolieugenio/pyTermTk for display_options build TUI
 # https://github.com/chriskiehl/Gooey build commandline interface
+
+"""
+
+
+from machineconfig.utils.utils import display_options, choose_one_option, PROGRAM_PATH, choose_ssh_host, match_file_name, sanitize_path
 from crocodile.file_management import P, install_n_import
 from crocodile.core import Display, randstr
 import inspect
@@ -20,21 +21,23 @@ import argparse
 
 def main() -> None:
     parser = argparse.ArgumentParser()
-    parser.add_argument("path", nargs='?', type=str, help="The directory containing the jobs", default=".")
+    parser.add_argument("path",     nargs='?', type=str, help="The directory containing the jobs", default=".")
     parser.add_argument("function", nargs='?', type=str, help="Fuction to run", default=None)
     # parser.add_argument("--function", "-f", type=str, help="The function to run", default="")
-    parser.add_argument("--ve", "-v", type=str, help="virtual enviroment name", default="")
-    parser.add_argument("--cmd", "-B", action="store_true", help="Create a cmd fire command to launch the the job asynchronously.")
-    parser.add_argument("--interactive", "-i", action="store_true", help="Whether to run the job interactively using IPython")
-    parser.add_argument("--debug", "-d", action="store_true", help="debug")
+    parser.add_argument("--ve",              "-v", type=str, help="virtual enviroment name", default="")
+    parser.add_argument("--cmd",             "-B", action="store_true", help="Create a cmd fire command to launch the the job asynchronously.")
+    parser.add_argument("--interactive",     "-i", action="store_true", help="Whether to run the job interactively using IPython")
+    parser.add_argument("--debug",           "-d", action="store_true", help="debug")
     parser.add_argument("--choose_function", "-c", action="store_true", help="debug")
-    parser.add_argument("--loop", "-l", action="store_true", help="infinite recusion (runs again after completion)")
-    parser.add_argument("--jupyter", "-j", action="store_true", help="open in a jupyter notebook")
+    parser.add_argument("--loop",            "-l", action="store_true", help="infinite recusion (runs again after completion)")
+    parser.add_argument("--jupyter",         "-j", action="store_true", help="open in a jupyter notebook")
     parser.add_argument("--submit_to_cloud", "-C", action="store_true", help="submit to cloud compute")
-    parser.add_argument("--remote", "-r", action="store_true", help="launch on a remote machine")
-    parser.add_argument("--module", "-m", action="store_true", help="launch the main file")
-    parser.add_argument("--streamlit", "-S", action="store_true", help="run as streamlit app")
-    parser.add_argument("--history", "-H", action="store_true", help="choose from history")
+    parser.add_argument("--remote",          "-r", action="store_true", help="launch on a remote machine")
+    parser.add_argument("--module",          "-m", action="store_true", help="launch the main file")
+    parser.add_argument("--streamlit",       "-S", action="store_true", help="run as streamlit app")
+    parser.add_argument("--history",         "-H", action="store_true", help="choose from history")
+    # parser.add_argument("--git_pull",        "-g", action="store_true", help="Start by pulling the git repo")
+    parser.add_argument("--Nprocess",        "-p", type=int, help="Number of processes to use", default=1)
     parser.add_argument("--kw", nargs="*", default=None, help="keyword arguments to pass to the function in the form of k1 v1 k2 v2 ...")
 
     args = parser.parse_args()
@@ -47,12 +50,9 @@ def main() -> None:
 
     path_obj = sanitize_path(P(args.path))
     if not path_obj.exists():
-        print("This pathway")
         path_obj = match_file_name(args.path)
         print(path_obj)
-    else:
-        print("This directory")
-        print(path_obj)
+    else: pass
 
     if path_obj.is_dir():
         print(f"Seaching recursively for all python file in directory `{path_obj}`")
@@ -68,10 +68,9 @@ def main() -> None:
 
     if choice_file.suffix in [".ps1", ".sh"]:
         PROGRAM_PATH.write_text(f". {choice_file}")
-        return
+        return None
 
     if args.choose_function or args.submit_to_cloud:
-
         options, func_args = parse_pyfile(file_path=str(choice_file))
         choice_function_tmp = display_options(msg="Choose a function to run", options=options, fzf=True, multi=False)
         assert isinstance(choice_function_tmp, str), f"choice_function must be a string. Got {type(choice_function_tmp)}"
@@ -83,13 +82,21 @@ def main() -> None:
         if len(choice_function_args) > 0 and len(kwargs) == 0:
             for item in choice_function_args:
                 kwargs[item.name] = input(f"Please enter a value for argument `{item.name}` (type = {item.type}) (default = {item.default}) : ") or item.default
-    else: choice_function = args.function
+    else:
+        choice_function = args.function
 
     if args.ve == "":
         from machineconfig.utils.ve import get_ve_profile  # if file name is passed explicitly, then, user probably launched it from cwd different to repo root, so activate_ve can't infer ve from .ve_path, so we attempt to do that manually here
         args.ve = get_ve_profile(choice_file)
 
-    if args.streamlit: exe = "streamlit run --server.address 0.0.0.0 "
+    if args.streamlit:
+        import socket
+        try: local_ip_v4 = socket.gethostbyname(socket.gethostname() + ".local")  # without .local, in linux machines, '/etc/hosts' file content, you have an IP address mapping with '127.0.1.1' to your hostname
+        except Exception:
+            print(f"Warning: Could not get local_ip_v4. This is probably because you are running a WSL instance")  # TODO find a way to get the local_ip_v4 in WSL
+            local_ip_v4 = socket.gethostbyname(socket.gethostname())
+        print(f"🚀 Streamlit app is running at: http://{local_ip_v4}:8501")
+        exe = "streamlit run --server.address 0.0.0.0 --server.headless true"
     elif args.interactive is False: exe = "python"
     elif args.jupyter: exe = "jupyter-lab"
     else:
@@ -97,12 +104,13 @@ def main() -> None:
         exe = f"ipython -i --no-banner --profile {get_ipython_profile(choice_file)} "
 
     if args.module or (args.debug and args.choose_function):  # because debugging tools do not support choosing functions and don't interplay with fire module. So the only way to have debugging and choose function options is to import the file as a module into a new script and run the function of interest there and debug the new script.
+        import_line = get_import_module_code(str(choice_file))
         txt: str = f"""
 try:
-    {get_import_module_code(str(choice_file))}
+    {import_line}
 except (ImportError, ModuleNotFoundError) as ex:
-    print(fr"Failed to import {choice_file} the proper way. {{ex}} ")
-    print(fr"The way below is rather hacky and can cause issues in pickling.")
+    print(fr"Failed to import `{choice_file}` the proper way. {{ex}} ")
+    print(fr"Importing with an ad-hoc `$PATH` manipulation. DO NOT pickle any files in this session as there is no gaurantee of correct deserialization.")
     import sys
     sys.path.append(r'{P(choice_file).parent}')
     from {P(choice_file).stem} import *
@@ -110,11 +118,17 @@ except (ImportError, ModuleNotFoundError) as ex:
 """
         if choice_function is not None:
             txt = txt + f"""
-{choice_function}({('**' + str(kwargs)) if kwargs else ''})
+res = {choice_function}({('**' + str(kwargs)) if kwargs else ''})
 """
         txt = f"""
-from machineconfig.utils.utils import print_code
-print_code(code=r'''{txt}''', lexer='python', desc='Import Script')
+try:
+    from rich.panel import Panel
+    from rich.console import Console
+    from rich.syntax import Syntax
+    console = Console()
+    console.print(Panel(Syntax(code=r'''{txt}''', lexer='python'), title='Import Script'), style="bold red")
+except ImportError as _ex:
+    print(r'''{txt}''')
 """ + txt
         choice_file = P.tmp().joinpath(f'tmp_scripts/python/{P(choice_file).parent.name}_{P(choice_file).stem}_{randstr()}.py').create(parents_only=True).write_text(txt)
 
@@ -131,15 +145,19 @@ print_code(code=r'''{txt}''', lexer='python', desc='Import Script')
         if not kwargs:  # empty dict
             kwargs_str = ''
         else:
-            tmp_list: list[str] = []
-            for k, v in kwargs.items():
-                if v is not None:
-                    item = f'"{k}": "{v}"'
-                else:
-                    item = f'"{k}": None'
-                tmp_list.append(item)
-            tmp__ = ", ".join(tmp_list)
-            kwargs_str = "'{" + tmp__  + "}'"
+            if len(kwargs) == 1:
+                kwargs_str = f""" --{list(kwargs.keys())[0]} {list(kwargs.values())[0]} """
+            else:
+                # print(f"len(kwargs) = {len(kwargs)}")
+                tmp_list: list[str] = []
+                for k, v in kwargs.items():
+                    if v is not None:
+                        item = f'"{k}": "{v}"'
+                    else:
+                        item = f'"{k}": None'
+                    tmp_list.append(item)
+                tmp__ = ", ".join(tmp_list)
+                kwargs_str = "'{" + tmp__  + "}'"
         command = f"{exe} -m fire {choice_file} {choice_function} {kwargs_str}"
         # else:
         #     print(f"{kwargs=}")
@@ -152,19 +170,22 @@ print_code(code=r'''{txt}''', lexer='python', desc='Import Script')
         else:
             if not args.cmd:
                 # for .streamlit config to work, it needs to be in the current directory.
-                command = f"cd {choice_file.parent}; {exe} {choice_file.name}; cd {P.cwd()}"
+                command = f"cd {choice_file.parent}\n\n{exe} {choice_file.name}\n\ncd {P.cwd()}"
             else:
                 command = rf""" cd /d {choice_file.parent} & {exe} {choice_file.name} """
-            # command = f"cd {choice_file.parent}; {exe} {choice_file.name}; cd {P.cwd()}"
+            # command = f"cd {choice_file.parent}\n\n{exe} {choice_file.name}\n\ncd {P.cwd()}"
 
     # this installs in ve env, which is not execution env
     # if "ipdb" in command: install_n_import("ipdb")
     # if "pudb" in command: install_n_import("pudb")
 
     if not args.cmd:
-        if "ipdb" in command: command = f"pip install ipdb; {command}"
-        if "pudb" in command: command = f"pip install pudb; {command}"
-        command = f". activate_ve {args.ve}; {command}"
+        if "ipdb" in command: command = f"pip install ipdb\n\n{command}"
+        if "pudb" in command: command = f"pip install pudb\n\n{command}"
+        if platform.system() == "Windows":
+            command = f". activate_ve {args.ve}\n\n{command}"
+        else:
+            command = f". ~/scripts/activate_ve {args.ve}\n\n{command}"
     else:
         # CMD equivalent
         if "ipdb" in command: command = f"pip install ipdb & {command}"
@@ -183,7 +204,18 @@ python -m crocodile.cluster.templates.cli_click --file {choice_file} """
     if args.loop:
         command = command + f"\n" + f". {PROGRAM_PATH}"
 
+    if args.Nprocess > 1:
+        lines = [f""" zellij action new-tab --name nProcess{randstr(2)}"""]
+        command = command.replace(". activate_ve", ". ~/scripts/activate_ve")
+        for an_arg in range(args.Nprocess):
+            sub_command = f"{command} --idx={an_arg} --idx_max={args.Nprocess}"
+            sub_command_path = P.tmpfile(suffix=".sh").write_text(sub_command)
+            lines.append(f"""zellij action new-pane -- bash {sub_command_path}  """)
+            lines.append("sleep 1")  # python tends to freeze if you launch instances within 1 microsecond of each other
+        command = "\n".join(lines)
+
     # TODO: send this command to terminal history. In powershell & bash there is no way to do it with a command other than goiing to history file. In Mcfly there is a way but its linux only tool. # if platform.system() == "Windows": command = f" ({command}) | Add-History  -PassThru "
+    # mcfly add --exit 0 command
     print(f"🔥 command:\n{command}\n\n")
     # if platform.system() == "Linux":
     #     command = "timeout 1s aafire -driver slang\nclear\n" + command
@@ -235,11 +267,11 @@ def parse_pyfile(file_path: str):
     return options, func_args
 
 
-def get_attrs(obj: Any):
+def get_attrs_recursively(obj: Any):
     if hasattr(obj, '__dict__'):
         res = {}
         for k, v in obj.__dict__.items():
-            res[k] = get_attrs(v)
+            res[k] = get_attrs_recursively(v)
         return res
     return obj
 
@@ -281,25 +313,32 @@ def run_on_remote(func_file: str, args: argparse.Namespace):
     m.run()
 
 
-def find_root_path(start_path: str):
+def find_repo_root_path(start_path: str) -> Optional[str]:
     root_files = ['setup.py', 'pyproject.toml', '.git']
-    path = start_path
-    while path != '/':
+    path: str = start_path
+    trials = 0
+    root_path = os.path.abspath(os.sep)
+    while path != root_path and trials < 20:
         for root_file in root_files:
             if os.path.exists(os.path.join(path, root_file)):
+                print(f"Found repo root path: {path}")
                 return path
         path = os.path.dirname(path)
+        trials += 1
     return None
 
 
 def get_import_module_code(module_path: str):
-    root_path = find_root_path(module_path)
+    root_path = find_repo_root_path(module_path)
     if root_path is None:  # just make a desperate attempt to import it
         module_name = module_path.lstrip(os.sep).replace(os.sep, '.').replace('.py', '')
-        return f"from {module_path} import *"
-    relative_path = module_path.replace(root_path, '')
-    module_name = relative_path.lstrip(os.sep).replace(os.sep, '.').replace('.py', '')
-    module_name = module_name.replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("resources.", "").replace("source.", "")
+    else:
+        relative_path = module_path.replace(root_path, '')
+        module_name = relative_path.lstrip(os.sep).replace(os.sep, '.').replace('.py', '')
+        module_name = module_name.replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("resources.", "").replace("source.", "")
+    if any(char in module_name for char in "- :/\\"):
+        module_name = "IncorrectModuleName"
+    # TODO: use py_compile to check if the statement is valid code to avoid syntax errors that can't be caught.
     return f"from {module_name} import *"
 
 

machineconfig/scripts/python/ftpx.py

@@ -3,6 +3,7 @@
 
 TODO: add support for cases in which source or target has non 22 default port number and is defineda as user@host:port:path which makes 2 colons in the string.
 Currently, the only way to work around this is to predifine the host in ~/.ssh/config and use the alias in the source or target which is inconvenient when dealing with newly setup machines.
+
 """
 
 import argparse
@@ -19,6 +20,7 @@ def main():
     # FLAGS
     parser.add_argument("--recursive", "-r", help="Send recursively.", action="store_true")  # default is False
     parser.add_argument("--zipFirst", "-z", help="Zip before sending.", action="store_true")  # default is False
+    parser.add_argument("--cloud", "-c", help="Transfer through the cloud.", action="store_true")  # default is False
 
     args = parser.parse_args()
 
@@ -54,6 +56,7 @@ def main():
         raise ValueError("Either source or target must be a remote path (i.e. machine:path)")
 
     Struct({"source": str(source), "target": str(target), "machine": machine}).print(as_config=True, title="CLI Resolution")
+
     from paramiko.ssh_exception import AuthenticationException  # type: ignore
     try:
         ssh = SSH(rf'{machine}')
@@ -64,14 +67,21 @@ def main():
         pwd = getpass.getpass()
         ssh = SSH(rf'{machine}', pwd=pwd)
 
-    if source_is_remote:
-        assert source is not None, "source must be a remote path (i.e. machine:path)"
-        print(f"Running: received_file = ssh.copy_to_here(source={source}, target={target}, z={args.zipFirst}, r={args.recursive})")
-        received_file = ssh.copy_to_here(source=source, target=target, z=args.zipFirst, r=args.recursive)
+    if args.cloud:
+        print("Uploading from remote to cloud ...")
+        ssh.run(f"cloud_copy {source} :^", desc="Uploading from remote to the cloud.").print()
+        print("Downloading from cloud to local ...")
+        ssh.run_locally(f"cloud_copy :^ {target}").print()
+        received_file = P(target)  # type: ignore
     else:
-        assert source is not None, "target must be a remote path (i.e. machine:path)"
-        print(f"Running: received_file = ssh.copy_from_here(source={source}, target={target}, z={args.zipFirst}, r={args.recursive})")
-        received_file = ssh.copy_from_here(source=source, target=target, z=args.zipFirst, r=args.recursive)
+        if source_is_remote:
+            assert source is not None, "source must be a remote path (i.e. machine:path)"
+            print(f"Running: received_file = ssh.copy_to_here(source=r'{source}', target=r'{target}', z={args.zipFirst}, r={args.recursive})")
+            received_file = ssh.copy_to_here(source=source, target=target, z=args.zipFirst, r=args.recursive)
+        else:
+            assert source is not None, "target must be a remote path (i.e. machine:path)"
+            print(f"Running: received_file = ssh.copy_from_here(source=r'{source}', target=r'{target}', z={args.zipFirst}, r={args.recursive})")
+            received_file = ssh.copy_from_here(source=source, target=target, z=args.zipFirst, r=args.recursive)
     # ssh.print_summary()
     # if P(args.file).is_dir(): print(f"Use: cd {repr(P(args.file).expanduser())}")
     if source_is_remote and isinstance(received_file, P):

machineconfig/scripts/python/repos.py

@@ -1,5 +1,9 @@
 
 """Repos
+
+# TODO use gh api user --jq '.login' to get the username and use it to clone the repos.
+in the event that username@github.com is not mentioned in the remote url.
+
 """
 
 from rich import print as pprint
@@ -168,7 +172,7 @@ def install_repos(specs_path: str, clone: bool = True, checkout_to_recorded_comm
                     if preferred_remote is not None:
                         if preferred_remote in repo["remotes"]:
                             remote_name = preferred_remote
-                            remote_url: str = repo["remotes"][preferred_remote]
+                            remote_url = repo["remotes"][preferred_remote]
                         else:
                             print(f"⚠️ `{preferred_remote=}` not found in {repo['remotes']}.")
                             # preferred_remote = None

machineconfig/scripts/python/start_terminals.py

@@ -9,7 +9,7 @@ from typing import Literal
 
 COLOR_SCHEMES = ["Campbell", "Campbell Powershell", "Solarized Dark", "Ubuntu-ColorScheme", "Retro"]
 THEMES_ITER = cycle(COLOR_SCHEMES)
-INIT_COMMANDS = ["ls", "lf", "cpufetch", "neofetch", "btm"]
+INIT_COMMANDS = ["ls", "lf", "cpufetch", "fastfetch", "btm"]
 INIT_COMMANDS_ITER = cycle(INIT_COMMANDS)
 SIZE_ITER = cycle([0.6, 0.4, 0.3])
 ORIENTATION = ["vertical", "horizontal"]