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

machineconfig/scripts/python/fire_jobs.py

@@ -12,15 +12,15 @@ 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 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
-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
-
-from machineconfig.utils.ve_utils.ve1 import get_repo_root
+import os
 
 
 str2obj = {"True": True, "False": False, "None": None}
@@ -36,37 +36,44 @@ def main() -> None:
     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("--loop",            "-l", action="store_true", help="infinite recusion (runs again after completion/interruption)")
     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("--environment",     "-E", type=str, help="Choose ip, localhost, hostname or arbitrary url", default="")
     parser.add_argument("--holdDirectory",   "-D", action="store_true", help="hold current directory and avoid cd'ing to the script directory")
+    parser.add_argument("--PathExport",      "-P", action="store_true", help="augment the PYTHONPATH with repo root.")
     parser.add_argument("--git_pull",        "-g", action="store_true", help="Start by pulling the git repo")
-    parser.add_argument("--optimized", "-O", action="store_true", help="Run the optimized version of the function")
+    parser.add_argument("--optimized",       "-O", action="store_true", help="Run the optimized version of the function")
     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 ... (meaning k1=v1, k2=v2, etc)")
     parser.add_argument("--zellij_tab",      "-z", type=str, dest="zellij_tab", help="open in a new zellij tab")
-    args = parser.parse_args()
-
-    path_obj = sanitize_path(P(args.path))
+    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(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
-    print(f"💾 Selected file: {choice_file}")
+    repo_root = get_repo_root(str(choice_file))
+    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":
@@ -84,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
@@ -104,34 +112,60 @@ 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
+            if toml_path_maybe.exists():
+                toml_path = toml_path_maybe
             elif choice_file.parent.name == "pages":
                 toml_path_maybe = choice_file.parent.parent.joinpath(".streamlit/config.toml")
                 if toml_path_maybe.exists(): toml_path = toml_path_maybe
             if toml_path is not None:
-                config = Read.toml(toml_path)
+                print(f"📄 Reading config.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 = 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)
+                        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"
+                        else: host_url = f"http://{args.environment}:{port}/oauth2callback"
+                        try:
+                            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)                        
+                        except Exception as ex:
+                            print(ex)
+                            raise ex
             message = f"🚀 Streamlit app is running @:\n1- http://{local_ip_v4}:{port}\n2- http://{computer_name}:{port}\n3- http://localhost:{port}"
             from rich.panel import Panel
             from rich import print as rprint
             rprint(Panel(message))
-            exe = "streamlit run --server.address 0.0.0.0 --server.headless true"
+            exe = f"streamlit run --server.address 0.0.0.0 --server.headless true --server.port {port}"
             # exe = f"cd '{choice_file.parent}'; " + exe
         elif args.interactive is False: exe = "python"
         elif args.jupyter: exe = "jupyter-lab"
@@ -145,9 +179,8 @@ def main() -> None:
         raise NotImplementedError(f"File type {choice_file.suffix} not supported, in the sense that I don't know how to fire it.")
 
     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.
-        assert choice_file.suffix == ".py", f"File must be a python file to be imported as a module. Got {choice_file.suffix}"
+        assert choice_file.suffix == ".py", f"File must be a python file to be imported as a module. Got {choice_file}"
         import_line = get_import_module_code(str(choice_file))
-        repo_root = get_repo_root(str(choice_file))
         if repo_root is not None:
             repo_root_add = f"""sys.path.append(r'{repo_root}')"""
         else:
@@ -159,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:
@@ -179,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:
@@ -199,7 +234,7 @@ except ImportError as _ex:
         if args.holdDirectory:
             command = f"{exe} {choice_file}"
         else:
-            command = f"cd {choice_file.parent}\n\n{exe} {choice_file.name}\n\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} """
@@ -208,21 +243,18 @@ 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\n{exe} {choice_file.name}\n\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\n{command}"
-        if "pudb" in command: command = f"pip install pudb\n\n{command}"
-        command = f"{activate_ve_line}\n\n{command}"
+        if "ipdb" in command: command = f"pip install ipdb\n{command}"
+        if "pudb" in command: command = f"pip install pudb\n{command}"
+        command = f"{activate_ve_line}\n{command}"
     else:
         # CMD equivalent
         if "ipdb" in command: command = f"pip install ipdb & {command}"
         if "pudb" in command: command = f"pip install pudb & {command}"
-        command = fr"""start cmd -Argument "/k %USERPROFILE%\venvs\{args.ve}\Scripts\activate.bat & {command} " """  # this works from powershell
+        new_line = "\n"
+        command = fr"""start cmd -Argument "/k {activate_ve_line.replace(".ps1", ".bat").replace(". ", "")} & {command.replace(new_line, " & ")} " """  # this works from powershell
         # this works from cmd  # command = fr""" start cmd /k "%USERPROFILE%\venvs\{args.ve}\Scripts\activate.bat & {command} " """ # because start in cmd is different from start in powershell (in powershell it is short for Start-Process)
 
     if args.submit_to_cloud:
@@ -232,23 +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.loop:
-        command = command + "\n" + f". {PROGRAM_PATH}"
-
     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.
@@ -262,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()
@@ -270,27 +302,34 @@ 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
-"""
-    if args.git_pull:
-        command = f"\ngit -C {choice_file.parent} pull\n\n" + command
-    console.print(Panel(Syntax(command, lexer="shell"), title=f"🔥 fire command @ {PROGRAM_PATH}: "), style="bold red")
-    PROGRAM_PATH.write_text(command)
+        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() 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
+            export_line = f"""$env:PYTHONPATH="{repo_root}""" + """:$env:PYTHONPATH" """
+        else:
+            raise NotImplementedError(f"Platform {platform.system()} not supported.")
+        command = export_line + "\n" + command
+
+    program_path = os.environ.get("op_script", None)
+    program_path = PathExtended(program_path) if program_path is not None else PROGRAM_PATH
+    if args.loop:
+        if platform.system() in ["Linux", "Darwin"]:
+            command = command + "\nsleep 0.5"
+        elif platform.system() == "Windows":
+            # command = command + "timeout 0.5\n"
+            #pwsh equivalent
+            command ="$ErrorActionPreference = 'SilentlyContinue';\n" + command + "\nStart-Sleep -Seconds 0.5"
+        else:
+            raise NotImplementedError(f"Platform {platform.system()} not supported.")
+        command = command + f"\n. {program_path}"
+    console.print(Panel(Syntax(command, lexer="shell"), title=f"🔥 fire command @ {program_path}: "), style="bold red")
+    program_path.write_text(command)
 
 
 if __name__ == '__main__':

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,11 +1,16 @@
-
-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
 import os
 from machineconfig.utils.utils import DEFAULTS_PATH
+from rich.console import Console
+from rich.panel import Panel
+from rich import box # Import box
+
+
+console = Console()
 
 
 class ArgsDefaults:
@@ -41,68 +46,49 @@ class Args():
     config: Optional[str] = None
 
     @staticmethod
-    def from_config(config_path: P):
-        # from crocodile.core import install_n_import
-        # install_n_import("pydantic")
-        # from pydantic import BaseModel, ConfigDict
-        return Args(**Read.json(config_path))
+    def from_config(config_path: Path):
+        return Args(**read_json(config_path))
 
 
-def find_cloud_config(path: P):
-    print(f"""
-╭{'─' * 70}╮
-│ 🔍 Searching for cloud configuration file...                              │
-╰{'─' * 70}╯
-""")
+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"))
-            print(f"""
-╭{'─' * 70}╮
-│ ✅ Found cloud config at: {path.joinpath('cloud.json')}   │
-╰{'─' * 70}╯
-""")
-            Struct(res.__dict__).print(as_config=True, title="Cloud Config")
+            display_success(f"Found cloud config at: {path.joinpath('cloud.json')}")
+            pprint(res.__dict__, "Cloud Config")
             return res
         path = path.parent
 
-    print("❌ No cloud configuration file found")
+    display_error("No cloud configuration file found")
     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
-    print(f"""
-╭{'─' * 70}╮
-│ ⚠️  WARNING:                                                              │
-│ Path {path} could not be resolved to absolute path.         
-│ Trying to resolve symlinks (this may result in unintended paths).        │
-╰{'─' * 70}╯
-""")
+    display_warning(f"Path {path} could not be resolved to absolute path.")
+    display_warning("Trying to resolve symlinks (this may result in unintended paths).")
     return obj.absolute()
 
 
 
 def get_secure_share_cloud_config(interactive: bool, cloud: Optional[str]) -> Args:
-    print(f"""
-╔{'═' * 70}╗
-║ 🔐 Secure Share Cloud Configuration                                       ║
-╚{'═' * 70}╝
-""")
+    console = Console()
+    console.print(Panel("🔐 Secure Share Cloud Configuration", expand=False))
     
     if cloud is None:
         if os.environ.get("CLOUD_CONFIG_NAME") is not None:
             default_cloud = os.environ.get("CLOUD_CONFIG_NAME")
             assert default_cloud is not None
             cloud = default_cloud
-            print(f"☁️  Using cloud from environment: {cloud}")
+            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:
@@ -110,9 +96,9 @@ def get_secure_share_cloud_config(interactive: bool, cloud: Optional[str]) -> Ar
                 cloud = input(f"☁️  Enter cloud name (default {default_cloud__}): ") or default_cloud__
             else:
                 cloud = default_cloud__
-                print(f"☁️  Using default cloud: {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"
@@ -125,10 +111,27 @@ def get_secure_share_cloud_config(interactive: bool, cloud: Optional[str]) -> Ar
                zip=True, overwrite=True, share=True,
                rel2home=True, root="myshare", os_specific=False,)
     
-    print(f"""
-╭{'─' * 70}╮
-│ ⚙️  Using SecureShare cloud config                                        │
-╰{'─' * 70}╯
-""")
-    Struct(res.__dict__).print(as_config=True, title="SecureShare Config")
+    display_success("Using SecureShare cloud config")
+    pprint(res.__dict__, "SecureShare Config")
     return res
+
+def display_header(title: str):
+    console.print(Panel(title, box=box.DOUBLE_EDGE, title_align="left")) # Replace print with Panel
+
+def display_subheader(title: str):
+    console.print(Panel(title, box=box.ROUNDED, title_align="left")) # Replace print with Panel
+
+def display_content(content: str):
+    console.print(Panel(content, box=box.ROUNDED, title_align="left")) # Replace print with Panel
+
+def display_status(status: str):
+    console.print(Panel(status, box=box.ROUNDED, title_align="left")) # Replace print with Panel
+
+def display_success(message: str):
+    console.print(Panel(message, box=box.ROUNDED, border_style="green", title_align="left")) # Replace print with Panel
+
+def display_warning(message: str):
+    console.print(Panel(message, box=box.ROUNDED, border_style="yellow", title_align="left")) # Replace print with Panel
+
+def display_error(message: str):
+    console.print(Panel(message, box=box.ROUNDED, border_style="red", title_align="left")) # Replace print with Panel