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

machineconfig/scripts/python/fire_jobs.py

@@ -12,11 +12,11 @@ from machineconfig.scripts.python.helpers.helpers4 import search_for_files_of_in
 from machineconfig.scripts.python.helpers.helpers4 import convert_kwargs_to_fire_kwargs_str
 from machineconfig.scripts.python.helpers.helpers4 import parse_pyfile
 from machineconfig.scripts.python.helpers.helpers4 import get_import_module_code
-from machineconfig.utils.ve_utils.ve1 import get_repo_root
+from machineconfig.utils.ve import get_repo_root, get_ve_activate_line, get_ve_path_and_ipython_profile
 from machineconfig.utils.utils import display_options, choose_one_option, PROGRAM_PATH, match_file_name, sanitize_path
-from machineconfig.utils.ve_utils.ve1 import get_ve_activate_line, get_ve_name_and_ipython_profile
-from crocodile.file_management import P, Read, Save
-from crocodile.core import randstr
+from machineconfig.utils.path_reduced import P as PathExtended
+from machineconfig.utils.io_save import save_toml
+from machineconfig.utils.utils2 import randstr, read_toml
 import platform
 from typing import Optional
 import argparse
@@ -51,32 +51,29 @@ def main() -> None:
     parser.add_argument("--zellij_tab",      "-z", type=str, dest="zellij_tab", help="open in a new zellij tab")
     parser.add_argument("--watch",           "-w", action="store_true", help="watch the file for changes")
     parser.add_argument("--kw", nargs="*", default=None, help="keyword arguments to pass to the function in the form of k1 v1 k2 v2 ... (meaning k1=v1, k2=v2, etc)")
-
     try:
         args = parser.parse_args()
     except Exception as ex:
         print(f"❌ Failed to parse arguments: {ex}")
         parser.print_help()
         raise ex
-
-    path_obj = sanitize_path(P(args.path))
+    path_obj = sanitize_path(PathExtended(args.path))
     if not path_obj.exists():
-        path_obj = match_file_name(sub_string=args.path)
+        path_obj = match_file_name(sub_string=args.path, search_root=PathExtended.cwd())
     else: pass
-
     if path_obj.is_dir():
         print(f"🔍 Searching recursively for Python, PowerShell and Shell scripts in directory `{path_obj}`")
         files = search_for_files_of_interest(path_obj)
         choice_file = choose_one_option(options=files, fzf=True)
-        choice_file = P(choice_file)
+        choice_file = PathExtended(choice_file)
     else:
         choice_file = path_obj
     repo_root = get_repo_root(str(choice_file))
-    print(f"💾 Selected file: {choice_file}. Repo root: {repo_root}")
+    print(f"💾 Selected file: {choice_file}.\nRepo root: {repo_root}")
 
-    ve_name_suggested, ipy_profile = get_ve_name_and_ipython_profile(choice_file)
+    ve_root_from_file, ipy_profile = get_ve_path_and_ipython_profile(choice_file)
     if ipy_profile is None: ipy_profile = "default"
-    activate_ve_line  = get_ve_activate_line(ve_name=args.ve or ve_name_suggested, a_path=str(choice_file))
+    activate_ve_line  = get_ve_activate_line(ve_root=args.ve or ve_root_from_file or "$HOME/venvs/ve")
 
     # Convert args.kw to dictionary
     if choice_file.suffix == ".py":
@@ -94,13 +91,14 @@ def main() -> None:
         kwargs = {}
 
     # =========================  choosing function to run
+    choice_function: Optional[str] = None  # Initialize to avoid unbound variable
     if args.choose_function or args.submit_to_cloud:
         if choice_file.suffix == ".py":
             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)}"
             choice_index = options.index(choice_function_tmp)
-            choice_function: Optional[str] = choice_function_tmp.split(' -- ')[0]
+            choice_function = choice_function_tmp.split(' -- ')[0]
             choice_function_args = func_args[choice_index]
 
             if choice_function == "RUN AS MAIN": choice_function = None
@@ -114,19 +112,26 @@ def main() -> None:
                 if line == "": continue
                 if line.startswith("echo"): continue
                 options.append(line)
-            choice_line = choose_one_option(options=options, fzf=True)
-            choice_file = P.tmpfile(suffix=".sh").write_text(choice_line)
+            chosen_lines = display_options(msg="Choose a line to run", options=options, fzf=True, multi=True)
+            choice_file = PathExtended.tmpfile(suffix=".sh").write_text("\n".join(chosen_lines))
             choice_function = None
     else:
         choice_function = args.function
 
     if choice_file.suffix == ".py":
         if args.streamlit:
-            from crocodile.environment import get_network_addresses
-            local_ip_v4 = get_network_addresses()["local_ip_v4"]
+            import socket
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            try:
+                s.connect(('8.8.8.8', 1))
+                local_ip_v4 = s.getsockname()[0]
+            except Exception:
+                local_ip_v4 = socket.gethostbyname(socket.gethostname())
+            finally:
+                s.close()
             computer_name = platform.node()
             port = 8501
-            toml_path: Optional[P] = None
+            toml_path: Optional[PathExtended] = None
             toml_path_maybe = choice_file.parent.joinpath(".streamlit/config.toml")
             if toml_path_maybe.exists():
                 toml_path = toml_path_maybe
@@ -135,15 +140,15 @@ def main() -> None:
                 if toml_path_maybe.exists(): toml_path = toml_path_maybe
             if toml_path is not None:
                 print(f"📄 Reading config.toml @ {toml_path}")
-                config = Read.toml(toml_path)
+                config = read_toml(toml_path)
                 if "server" in config:
                     if "port" in config["server"]:
                         port = config["server"]["port"]
                 secrets_path = toml_path.with_name("secrets.toml")
                 if repo_root is not None:
-                    secrets_template_path = P.home().joinpath(f"dotfiles/creds/streamlit/{P(repo_root).name}/{choice_file.name}/secrets.toml")
+                    secrets_template_path = PathExtended.home().joinpath(f"dotfiles/creds/streamlit/{PathExtended(repo_root).name}/{choice_file.name}/secrets.toml")
                     if args.environment != "" and not secrets_path.exists() and secrets_template_path.exists():
-                        secrets_template = Read.toml(secrets_template_path)
+                        secrets_template = read_toml(secrets_template_path)
                         if args.environment == "ip": host_url = f"http://{local_ip_v4}:{port}/oauth2callback"
                         elif args.environment == "localhost": host_url = f"http://localhost:{port}/oauth2callback"
                         elif args.environment == "hostname": host_url = f"http://{computer_name}:{port}/oauth2callback"
@@ -152,7 +157,7 @@ def main() -> None:
                             secrets_template["auth"]["redirect_uri"] = host_url
                             secrets_template["auth"]["cookie_secret"] = randstr(35)
                             secrets_template["auth"]["auth0"]["redirect_uri"] = host_url
-                            Save.toml(obj=secrets_template, path=secrets_path)                        
+                            save_toml(obj=secrets_template, path=secrets_path)                        
                         except Exception as ex:
                             print(ex)
                             raise ex
@@ -187,9 +192,9 @@ except (ImportError, ModuleNotFoundError) as ex:
     print(fr"❌ Failed to import `{choice_file}` as a module: {{ex}} ")
     print(fr"⚠️ Attempting import with ad-hoc `$PATH` manipulation. DO NOT pickle any objects in this session as correct deserialization cannot be guaranteed.")
     import sys
-    sys.path.append(r'{P(choice_file).parent}')
+    sys.path.append(r'{PathExtended(choice_file).parent}')
     {repo_root_add}
-    from {P(choice_file).stem} import *
+    from {PathExtended(choice_file).stem} import *
     print(fr"✅ Successfully imported `{choice_file}`")
 """
         if choice_function is not None:
@@ -207,7 +212,9 @@ try:
 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)
+        choice_file = PathExtended.tmp().joinpath(f'tmp_scripts/python/{PathExtended(choice_file).parent.name}_{PathExtended(choice_file).stem}_{randstr()}.py')
+        choice_file.parent.mkdir(parents=True, exist_ok=True)
+        choice_file.write_text(txt)
 
     # =========================  determining basic command structure: putting together exe & choice_file & choice_function & pdb
     if args.debug:
@@ -227,7 +234,7 @@ except ImportError as _ex:
         if args.holdDirectory:
             command = f"{exe} {choice_file}"
         else:
-            command = f"cd {choice_file.parent}\n{exe} {choice_file.name}\ncd {P.cwd()}"
+            command = f"cd {choice_file.parent}\n{exe} {choice_file.name}\ncd {PathExtended.cwd()}"
 
     elif args.cmd:
         command = rf""" cd /d {choice_file.parent} & {exe} {choice_file.name} """
@@ -236,12 +243,8 @@ except ImportError as _ex:
             kwargs_raw = " ".join(args.kw) if args.kw is not None else ""
             command = f"{exe} {choice_file} {kwargs_raw}"
         else:
-            # command = f"cd {choice_file.parent}\n{exe} {choice_file.name}\ncd {P.cwd()}"
+            # command = f"cd {choice_file.parent}\n{exe} {choice_file.name}\ncd {PathExtended.cwd()}"
             command = f"{exe} {choice_file} "
-    # 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\n{command}"
         if "pudb" in command: command = f"pip install pudb\n{command}"
@@ -261,20 +264,23 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
         if choice_function is not None:
             command += f"--function {choice_function} "
 
-    # try: install_n_import("clipboard").copy(command)
-    # except Exception as ex: print(f"Failed to copy command to clipboard. {ex}")
-
     if args.Nprocess > 1:
-        lines = [f""" zellij action new-tab --name nProcess{randstr(2)}"""]
-        command = command.replace(". activate_ve", ". $HOME/scripts/activate_ve")
+        # lines = [f""" zellij action new-tab --name nProcess{randstr(2)}"""]
+        # command = command.replace(". activate_ve", ". $HOME/scripts/activate_ve")
+        # for an_arg in range(args.Nprocess):
+        #     sub_command = f"{command} --idx={an_arg} --idx_max={args.Nprocess}"
+        #     if args.optimized:
+        #         sub_command = sub_command.replace("python ", "python -OO ")
+        #     sub_command_path = PathExtended.tmpfile(suffix=".sh").write_text(sub_command)
+        #     lines.append(f"""zellij action new-pane -- bash {sub_command_path}  """)
+        #     lines.append("sleep 5")  # python tends to freeze if you launch instances within 1 microsecond of each other
+        # command = "\n".join(lines)
+        tab_config = {}
         for an_arg in range(args.Nprocess):
-            sub_command = f"{command} --idx={an_arg} --idx_max={args.Nprocess}"
-            if args.optimized:
-                sub_command = sub_command.replace("python ", "python -OO ")
-            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 5")  # python tends to freeze if you launch instances within 1 microsecond of each other
-        command = "\n".join(lines)
+            tab_config[f"tab{an_arg}"] = (str(PathExtended.cwd()), f"uv run python -m fire {choice_file} {choice_function} --idx={an_arg} --idx_max={args.Nprocess}")
+        from machineconfig.cluster.sessions_managers.zellij_local import run_zellij_layout
+        run_zellij_layout(tab_config=tab_config, session_name=None)
+        return None
 
     if args.optimized:
         # note that in ipython, optimization is meaningless.
@@ -288,7 +294,7 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
     console = Console()
 
     if args.zellij_tab is not None:
-        comman_path__ = P.tmpfile(suffix=".sh").write_text(command)
+        comman_path__ = PathExtended.tmpfile(suffix=".sh").write_text(command)
         console.print(Panel(Syntax(command, lexer="shell"), title=f"🔥 fire command @ {comman_path__}: "), style="bold red")
         import subprocess
         existing_tab_names = subprocess.run(["zellij", "action", "query-tab-names"], capture_output=True, text=True, check=True).stdout.splitlines()
@@ -296,27 +302,12 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
             print(f"⚠️ Tab name `{args.zellij_tab}` already exists. Please choose a different name.")
             # args.zellij_tab = input("Please enter a new tab name: ")
             args.zellij_tab += f"_{randstr(3)}"
-        command = f"""
-echo "Sleep 1 seconds to allow zellij to create a new tab"
-sleep 1
-zellij action new-tab --name {args.zellij_tab}
-echo "Sleep 2 seconds to allow zellij to go to the new tab"
-sleep 2
-zellij action go-to-tab-name {args.zellij_tab}
-echo "Sleep 2 seconds to allow zellij to start the new pane"
-sleep 2
-zellij action new-pane --direction down -- /bin/bash {comman_path__}
-echo "Sleep 2 seconds to allow zellij to start the new pane"
-sleep 1
-zellij action move-focus up; sleep 2
-echo "Sleep 2 seconds to allow zellij to close the pane"
-sleep 1
-zellij action close-pane; sleep 2
-"""
+        from machineconfig.cluster.sessions_managers.zellij_local import run_command_in_zellij_tab
+        command = run_command_in_zellij_tab(command=str(comman_path__), tab_name=args.zellij_tab, cwd=None)
     if args.watch: command = "watchexec --restart --exts py,sh,ps1 " + command
     if args.git_pull: command = f"\ngit -C {choice_file.parent} pull\n" + command
     if args.PathExport:
-        if platform.system() == "Linux": export_line = f"""export PYTHONPATH="{repo_root}""" + """:${PYTHONPATH}" """
+        if platform.system() in ["Linux", "Darwin"]: export_line = f"""export PYTHONPATH="{repo_root}""" + """:${PYTHONPATH}" """
         elif platform.system() == "Windows":
             # export_line = f"""set PYTHONPATH="{repo_root}""" + """:%PYTHONPATH%" """
             # powershell equivalent
@@ -326,9 +317,9 @@ zellij action close-pane; sleep 2
         command = export_line + "\n" + command
 
     program_path = os.environ.get("op_script", None)
-    program_path = P(program_path) if program_path is not None else PROGRAM_PATH
+    program_path = PathExtended(program_path) if program_path is not None else PROGRAM_PATH
     if args.loop:
-        if platform.system() == "Linux":
+        if platform.system() in ["Linux", "Darwin"]:
             command = command + "\nsleep 0.5"
         elif platform.system() == "Windows":
             # command = command + "timeout 0.5\n"

machineconfig/scripts/python/ftpx.py

@@ -7,9 +7,9 @@ Currently, the only way to work around this is to predifine the host in ~/.ssh/c
 
 import argparse
 from crocodile.meta import SSH
-from crocodile.core import Struct
-from crocodile.file_management import P
+from machineconfig.utils.path_reduced import P as PathExtended
 from machineconfig.scripts.python.helpers.helpers2 import ES
+from machineconfig.utils.utils2 import pprint
 
 
 def main():
@@ -43,12 +43,12 @@ def main():
 ┃    Cannot use expand symbol `{ES}` in both source and target
 ┃    This creates a cyclical inference dependency
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-            else: target = P(args.target).expanduser().absolute()
+            else: target = PathExtended(args.target).expanduser().absolute()
             source = target.collapseuser().as_posix()
         else:
             source = ":".join(args.source.split(":")[1:])
             if args.target == ES: target = None
-            else: target = P(args.target).expanduser().absolute().as_posix()
+            else: target = PathExtended(args.target).expanduser().absolute().as_posix()
 
     elif ":" in args.target and (args.target[1] != ":" if len(args.target) > 1 else True):  # avoid the case of "C:/":
         source_is_remote = False
@@ -66,7 +66,7 @@ def main():
         else:
             target = ":".join(args.target.split(":")[1:])
             if args.source == ES: source = None
-            else: source = P(args.source).expanduser().absolute()
+            else: source = PathExtended(args.source).expanduser().absolute()
 
     else:
         raise ValueError("""
@@ -76,7 +76,7 @@ def main():
 ┃    Format should be: machine:path
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
 
-    Struct({"source": str(source), "target": str(target), "machine": machine}).print(as_config=True, title="CLI Resolution")
+    pprint({"source": str(source), "target": str(target), "machine": machine}, "CLI Resolution")
 
     from paramiko.ssh_exception import AuthenticationException  # type: ignore
     try:
@@ -107,7 +107,7 @@ def main():
 │    Downloading from cloud to local...
 └────────────────────────────────────────────────────────────────""")
         ssh.run_locally(f"cloud_copy :^ {target}").print()
-        received_file = P(target)  # type: ignore
+        received_file = PathExtended(target)  # type: ignore
     else:
         if source_is_remote:
             assert source is not None, """
@@ -132,7 +132,7 @@ def main():
 └────────────────────────────────────────────────────────────────""")
             received_file = ssh.copy_from_here(source=source, target=target, z=args.zipFirst, r=args.recursive)
 
-    if source_is_remote and isinstance(received_file, P):
+    if source_is_remote and isinstance(received_file, PathExtended):
         print(f"""
 ┌────────────────────────────────────────────────────────────────
 │ 📁 File Received

machineconfig/scripts/python/get_zellij_cmd.py

@@ -1,7 +1,7 @@
-from crocodile.file_management import P
+from pathlib import Path
 
 
-def get_zellij_cmd(wd1: P, wd2: P) -> str:
+def get_zellij_cmd(wd1: Path, wd2: Path) -> str:
     _ = wd1, wd2
     lines = [""" zellij action new-tab --name gitdiff""",
              """zellij action new-pane --direction down --name local --cwd ./data """,
@@ -11,4 +11,4 @@ def get_zellij_cmd(wd1: P, wd2: P) -> str:
              """zellij action write-chars "cd '{wd2}' """,
              """git status" """
     ]
-    return "; ".join(lines)
+    return "; ".join(lines)

machineconfig/scripts/python/gh_models.py

@@ -1,11 +1,13 @@
 # as per https://github.com/marketplace/models/azure-openai/o1-preview
 from openai import OpenAI
-from crocodile.file_management import Read, P
+from machineconfig.utils.path_reduced import P as PathExtended
+from machineconfig.utils.utils2 import read_ini
 from rich import print as rprint
 from rich.panel import Panel
+from typing import Any
 
 
-gh_token = Read.ini(P.home().joinpath("dotfiles/creds/git/git_host_tokens.ini"))['thisismygitrepo']['newLongterm']
+gh_token = read_ini(PathExtended.home().joinpath("dotfiles/creds/git/git_host_tokens.ini"))['thisismygitrepo']['newLongterm']
 endpoint = "https://models.inference.ai.azure.com"
 model_name_preferences = ["o3-mini", "o1-preview", "o1-mini", "GPT-4o", "GPT-4-o-mini"]
 client__ = OpenAI(
@@ -14,7 +16,7 @@ client__ = OpenAI(
 )
 
 
-def get_response(client, model_name: str, messages: list[dict[str, str]]):
+def get_response(client: Any, model_name: str, messages: list[dict[str, str]]):
     print(f"""
 ┌────────────────────────────────────────────────────────────────
 │ 🤖 Querying Model: {model_name}
@@ -78,7 +80,7 @@ def interactive_chat():
                             title=f"🤖 AI ({model_name})",
                             border_style="blue"
                         ))
-                    except:
+                    except Exception:
                         # Fallback if rich formatting fails
                         print(f"""
 ┌────────────────────────────────────────────────────────────────

machineconfig/scripts/python/helpers/cloud_helpers.py

@@ -1,5 +1,5 @@
-from crocodile.core import Struct
-from crocodile.file_management import P, Read
+from pathlib import Path
+from machineconfig.utils.utils2 import pprint, read_json, read_ini
 from pydantic import ConfigDict
 from pydantic.dataclasses import dataclass
 from typing import Optional
@@ -46,18 +46,18 @@ class Args():
     config: Optional[str] = None
 
     @staticmethod
-    def from_config(config_path: P):
-        return Args(**Read.json(config_path))
+    def from_config(config_path: Path):
+        return Args(**read_json(config_path))
 
 
-def find_cloud_config(path: P):
+def find_cloud_config(path: Path):
     display_header(f"Searching for cloud configuration file @ {path}")
 
     for _i in range(len(path.parts)):
         if path.joinpath("cloud.json").exists():
             res = Args.from_config(path.joinpath("cloud.json"))
             display_success(f"Found cloud config at: {path.joinpath('cloud.json')}")
-            Struct(res.__dict__).print(as_config=True, title="Cloud Config")
+            pprint(res.__dict__, "Cloud Config")
             return res
         path = path.parent
 
@@ -65,10 +65,10 @@ def find_cloud_config(path: P):
     return None
 
 
-def absolute(path: str) -> P:
-    obj = P(path).expanduser()
+def absolute(path: str) -> Path:
+    obj = Path(path).expanduser()
     if not path.startswith(".") and  obj.exists(): return obj
-    try_absing =  P.cwd().joinpath(path)
+    try_absing =  Path.cwd().joinpath(path)
     if try_absing.exists(): return try_absing
     display_warning(f"Path {path} could not be resolved to absolute path.")
     display_warning("Trying to resolve symlinks (this may result in unintended paths).")
@@ -88,7 +88,7 @@ def get_secure_share_cloud_config(interactive: bool, cloud: Optional[str]) -> Ar
             console.print(f"☁️  Using cloud from environment: {cloud}")
         else:
             try:
-                default_cloud__ = Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
+                default_cloud__ = read_ini(DEFAULTS_PATH)['general']['rclone_config_name']
             except Exception:
                 default_cloud__ = 'No default cloud found.'
             if default_cloud__ == 'No default cloud found.' or interactive:
@@ -98,7 +98,7 @@ def get_secure_share_cloud_config(interactive: bool, cloud: Optional[str]) -> Ar
                 cloud = default_cloud__
                 console.print(f"☁️  Using default cloud: {cloud}")
 
-    default_password_path = P.home().joinpath("dotfiles/creds/passwords/quick_password")
+    default_password_path = Path.home().joinpath("dotfiles/creds/passwords/quick_password")
     if default_password_path.exists():
         pwd = default_password_path.read_text().strip()
         default_message = "defaults to quick_password"
@@ -112,7 +112,7 @@ def get_secure_share_cloud_config(interactive: bool, cloud: Optional[str]) -> Ar
                rel2home=True, root="myshare", os_specific=False,)
     
     display_success("Using SecureShare cloud config")
-    Struct(res.__dict__).print(as_config=True, title="SecureShare Config")
+    pprint(res.__dict__, "SecureShare Config")
     return res
 
 def display_header(title: str):

machineconfig/scripts/python/helpers/helpers2.py

@@ -1,7 +1,6 @@
-from crocodile.core import Struct
-from crocodile.file_management import Read
 from machineconfig.scripts.python.helpers.cloud_helpers import Args, ArgsDefaults, absolute, find_cloud_config, get_secure_share_cloud_config
 from machineconfig.utils.utils import DEFAULTS_PATH
+from machineconfig.utils.utils2 import read_ini, pprint
 from typing import Optional
 from rich.console import Console
 from rich.panel import Panel
@@ -54,7 +53,7 @@ def parse_cloud_source_target(args: Args, source: str, target: str) -> tuple[str
             maybe_config = tmp_maybe_config
 
         if maybe_config is None:
-            default_cloud: str=Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
+            default_cloud: str=read_ini(DEFAULTS_PATH)['general']['rclone_config_name']
             console.print(Panel(f"⚠️  No cloud config found. Using default cloud: {default_cloud}", width=150, border_style="yellow"))
             source = default_cloud + ":" + source[1:]
         else:
@@ -74,7 +73,7 @@ def parse_cloud_source_target(args: Args, source: str, target: str) -> tuple[str
             maybe_config = find_cloud_config(path)
 
         if maybe_config is None:
-            default_cloud = Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
+            default_cloud = read_ini(DEFAULTS_PATH)['general']['rclone_config_name']
             console.print(Panel(f"⚠️  No cloud config found. Using default cloud: {default_cloud}", width=150, border_style="yellow"))
             target = default_cloud + ":" + target[1:]
             print("target mutated to:", target, f"because of default cloud being {default_cloud}")
@@ -97,7 +96,8 @@ def parse_cloud_source_target(args: Args, source: str, target: str) -> tuple[str
         if len(source_parts) > 1 and source_parts[1] == ES:  # the source path is to be inferred from target.
             assert ES not in target, f"You can't use expand symbol `{ES}` in both source and target. Cyclical inference dependency arised."
             target_obj = absolute(target)
-            remote_path = target_obj.get_remote_path(os_specific=os_specific, root=root, rel2home=rel2home, strict=False)
+            from machineconfig.utils.path_reduced import P as PathExtended
+            remote_path = PathExtended(target_obj).get_remote_path(os_specific=os_specific, root=root, rel2home=rel2home, strict=False)
             source = f"{cloud}:{remote_path.as_posix()}"
         else:  # source path is mentioned, target? maybe.
             if target == ES:  # target path is to be inferred from source.
@@ -115,7 +115,8 @@ def parse_cloud_source_target(args: Args, source: str, target: str) -> tuple[str
         if len(target_parts) > 1 and target_parts[1] == ES:  # the target path is to be inferred from source.
             assert ES not in source, "You can't use $ in both source and target. Cyclical inference dependency arised."
             source_obj = absolute(source)
-            remote_path = source_obj.get_remote_path(os_specific=os_specific, root=root, rel2home=rel2home, strict=False)
+            from machineconfig.utils.path_reduced import P as PathExtended
+            remote_path = PathExtended(source_obj).get_remote_path(os_specific=os_specific, root=root, rel2home=rel2home, strict=False)
             target = f"{cloud}:{remote_path.as_posix()}"
         else:  # target path is mentioned, source? maybe.
             target = str(target)
@@ -130,6 +131,6 @@ def parse_cloud_source_target(args: Args, source: str, target: str) -> tuple[str
         raise ValueError(f"Either source or target must be a remote path (i.e. machine:path)\nGot: source: `{source}`, target: `{target}`")
 
     console.print(Panel("🔍 Path resolution complete", title="[bold blue]Resolution[/bold blue]", border_style="blue"))
-    Struct({"cloud": cloud, "source": str(source), "target": str(target)}).print(as_config=True, title="CLI Resolution")
+    pprint({"cloud": cloud, "source": str(source), "target": str(target)}, "CLI Resolution")
     _ = pwd, encrypt, zip_arg, share
-    return cloud, str(source), str(target)
+    return cloud, str(source), str(target)

machineconfig/scripts/python/helpers/helpers4.py

@@ -2,16 +2,16 @@
 from typing import Any, Callable, Optional
 import inspect
 import os
-import argparse
+# import argparse
 from crocodile.core import Display
-from crocodile.file_management import P
-from machineconfig.utils.utils import choose_ssh_host
+from machineconfig.utils.path_reduced import P as PathExtended
+# from machineconfig.utils.utils import choose_ssh_host
 
 
-def search_for_files_of_interest(path_obj: P):
+def search_for_files_of_interest(path_obj: PathExtended):
     if path_obj.joinpath(".venv").exists():
         path_objects = path_obj.search("*", not_in=[".venv"]).list
-        files: list[P] = []
+        files: list[PathExtended] = []
         for a_path_obj in path_objects:
             files += search_for_files_of_interest(path_obj=a_path_obj)
         return files
@@ -28,19 +28,11 @@ def convert_kwargs_to_fire_kwargs_str(kwargs: dict[str, Any]) -> str:
     if not kwargs:  # empty dict
         kwargs_str = ''
     else:
-        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__  + "}'"
+        # For fire module, all keyword arguments should be passed as --key value pairs
+        tmp_list: list[str] = []
+        for k, v in kwargs.items():
+            tmp_list.append(f"--{k} {v}")
+        kwargs_str = " " + " ".join(tmp_list) + " "
     return kwargs_str
 
 
@@ -51,7 +43,7 @@ def parse_pyfile(file_path: str):
     func_args: list[list[args_spec]] = [[]]  # this firt prepopulated dict is for the option 'RUN AS MAIN' which has no args
 
     import ast
-    parsed_ast = ast.parse(P(file_path).read_text(encoding='utf-8'))
+    parsed_ast = ast.parse(PathExtended(file_path).read_text(encoding='utf-8'))
     functions = [
         node
         for node in ast.walk(parsed_ast)
@@ -73,12 +65,8 @@ def parse_pyfile(file_path: str):
             if arg.annotation is not None:
                 try: type_ = arg.annotation.__dict__['id']
                 except KeyError as ke:
-                    # type_ = arg.annotation.__name__
-                    # print(f"Failed to get type for {arg.annotation}. {ke}")
-                    # Struct(get_attrs(arg.annotation)).print(as_yaml=True)
                     type_ = "Any"  # e.g. a callable object
                     _ = ke
-                    # raise ke
             else: type_ = "Any"
             default_tmp = function.args.defaults[idx] if idx < len(function.args.defaults) else None
             if default_tmp is None: default = None
@@ -123,18 +111,18 @@ def get_attrs_recursively(obj: Any):
     return obj
 
 
-def run_on_remote(func_file: str, args: argparse.Namespace):
-    host = choose_ssh_host(multi=False)
-    assert isinstance(host, str), f"host must be a string. Got {type(host)}"
-    from machineconfig.cluster.remote_machine import RemoteMachine, RemoteMachineConfig
-    config = RemoteMachineConfig(copy_repo=True, update_repo=False, update_essential_repos=True,
-                                 notify_upon_completion=True, ssh_params=dict(host=host),
-                                 # to_email=None, email_config_name='enaut',
-                                 data=[],
-                                 ipython=False, interactive=args.interactive, pdb=False, pudb=args.debug, wrap_in_try_except=False,
-                                 transfer_method="sftp")
-    m = RemoteMachine(func=func_file, func_kwargs=None, config=config)
-    m.run()
+# def run_on_remote(func_file: str, args: argparse.Namespace):
+#     host = choose_ssh_host(multi=False)
+#     assert isinstance(host, str), f"host must be a string. Got {type(host)}"
+#     from machineconfig.cluster.remote_machine import RemoteMachine, RemoteMachineConfig
+#     config = RemoteMachineConfig(copy_repo=True, update_repo=False, update_essential_repos=True,
+#                                  notify_upon_completion=True, ssh_params=dict(host=host),
+#                                  # to_email=None, email_config_name='enaut',
+#                                  data=[],
+#                                  ipython=False, interactive=args.interactive, pdb=False, pudb=args.debug, wrap_in_try_except=False,
+#                                  transfer_method="sftp")
+#     m = RemoteMachine(func=func_file, func_kwargs=None, config=config)
+#     m.run()
 
 
 def find_repo_root_path(start_path: str) -> Optional[str]: