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

machineconfig/scripts/python/devops_backup_retrieve.py

@@ -7,170 +7,81 @@ from machineconfig.utils.utils import LIBRARY_ROOT, DEFAULTS_PATH, print_code, c
 from machineconfig.scripts.python.helpers.helpers2 import ES
 from platform import system
 from typing import Any, Literal, Optional
+from rich.console import Console
+from rich.panel import Panel
 
 
 OPTIONS = Literal["BACKUP", "RETRIEVE"]
 
 
 def main_backup_retrieve(direction: OPTIONS, which: Optional[str] = None):
+    console = Console()
+    
     try:
         cloud: str = Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
-        print(f"""
-╔{'═' * 70}╗
-║ ⚠️  DEFAULT CLOUD CONFIGURATION                                          ║
-╠{'═' * 70}╣
-║ 🌥️  Using default cloud: {cloud:<52} ║
-╚{'═' * 70}╝
-""")
+        console.print(Panel(f"⚠️  DEFAULT CLOUD CONFIGURATION\n🌥️  Using default cloud: {cloud}", title="[bold blue]Cloud Configuration[/bold blue]", border_style="blue"))
     except (FileNotFoundError, KeyError, IndexError):
-        print(f"""
-╔{'═' * 70}╗
-║ 🔍 DEFAULT CLOUD NOT FOUND                                              ║
-║ 🔄 Please select a cloud configuration from the options below            ║
-╚{'═' * 70}╝
-""")
+        console.print(Panel("🔍 DEFAULT CLOUD NOT FOUND\n🔄 Please select a cloud configuration from the options below", title="[bold red]Error: Cloud Not Found[/bold red]", border_style="red"))
         cloud = choose_cloud_interactively()
 
     bu_file: dict[str, Any] = Read.toml(LIBRARY_ROOT.joinpath("profile/backup.toml"))
     
-    print(f"""
-╔{'═' * 70}╗
-║ 🧰 LOADING BACKUP CONFIGURATION                                         ║
-║ 📄 File: {LIBRARY_ROOT.joinpath("profile/backup.toml")}      ║
-╚{'═' * 70}╝
-""")
+    console.print(Panel(f"🧰 LOADING BACKUP CONFIGURATION\n📄 File: {LIBRARY_ROOT.joinpath('profile/backup.toml')}", title="[bold blue]Backup Configuration[/bold blue]", border_style="blue"))
     
     if system() == "Linux": 
         bu_file = {key: val for key, val in bu_file.items() if "windows" not in key}
-        print(f"""
-╔{'═' * 70}╗
-║ 🐧 LINUX ENVIRONMENT DETECTED                                           ║
-║ 🔍 Filtering out Windows-specific entries                               ║
-║ ✅ Found {len(bu_file)} applicable backup configuration entries               ╚{'═' * 70}╝
-""")
+        console.print(Panel(f"🐧 LINUX ENVIRONMENT DETECTED\n🔍 Filtering out Windows-specific entries\n✅ Found {len(bu_file)} applicable backup configuration entries", title="[bold blue]Linux Environment[/bold blue]", border_style="blue"))
     elif system() == "Windows": 
         bu_file = {key: val for key, val in bu_file.items() if "linux" not in key}
-        print(f"""
-╔{'═' * 70}╗
-║ 🪟 WINDOWS ENVIRONMENT DETECTED                                         ║
-║ 🔍 Filtering out Linux-specific entries                                 ║
-║ ✅ Found {len(bu_file)} applicable backup configuration entries               ╚{'═' * 70}╝
-""")
+        console.print(Panel(f"🪟 WINDOWS ENVIRONMENT DETECTED\n🔍 Filtering out Linux-specific entries\n✅ Found {len(bu_file)} applicable backup configuration entries", title="[bold blue]Windows Environment[/bold blue]", border_style="blue"))
 
     if which is None:
-        print(f"""
-╔{'═' * 70}╗
-║ 🔍 SELECT {direction} ITEMS                                             ║
-║ 📋 Choose which configuration entries to process                         ║
-╚{'═' * 70}╝
-""")
+        console.print(Panel(f"🔍 SELECT {direction} ITEMS\n📋 Choose which configuration entries to process", title="[bold blue]Select Items[/bold blue]", border_style="blue"))
         choices = choose_multiple_options(msg=f"WHICH FILE of the following do you want to {direction}?", options=['all'] + list(bu_file.keys()))
     else:
         choices = which.split(",") if isinstance(which, str) else which
-        print(f"""
-╔{'═' * 70}╗
-║ 🔖 PRE-SELECTED ITEMS                                                   ║
-║ 📝 Using: {', '.join(choices):<54} ║
-╚{'═' * 70}╝
-""")
+        console.print(Panel(f"🔖 PRE-SELECTED ITEMS\n📝 Using: {', '.join(choices)}", title="[bold blue]Pre-selected Items[/bold blue]", border_style="blue"))
 
     if "all" in choices:
         items = bu_file
-        print(f"""
-╔{'═' * 70}╗
-║ 📋 PROCESSING ALL ENTRIES                                               ║
-║ 🔢 Total entries to process: {len(bu_file):<39} ║
-╚{'═' * 70}╝
-""")
+        console.print(Panel(f"📋 PROCESSING ALL ENTRIES\n🔢 Total entries to process: {len(bu_file)}", title="[bold blue]Process All Entries[/bold blue]", border_style="blue"))
     else:
         items = {key: val for key, val in bu_file.items() if key in choices}
-        print(f"""
-╔{'═' * 70}╗
-║ 📋 PROCESSING SELECTED ENTRIES                                          ║
-║ 🔢 Total entries to process: {len(items):<39} ║
-╚{'═' * 70}╝
-""")
-
+        console.print(Panel(f"📋 PROCESSING SELECTED ENTRIES\n🔢 Total entries to process: {len(items)}", title="[bold blue]Process Selected Entries[/bold blue]", border_style="blue"))
     program = f"""$cloud = "{cloud}:{ES}" \n """ if system() == "Windows" else f"""cloud="{cloud}:{ES}" \n """
-    
-    print(f"""
-╔{'═' * 70}╗
-║ 🚀 GENERATING {direction} SCRIPT                                        ║
-╠{'═' * 70}╣
-║ 🌥️  Cloud: {cloud:<58} ║
-║ 🗂️  Items: {len(items):<58} ║
-╚{'═' * 70}╝
-""")
-    
+    console.print(Panel(f"🚀 GENERATING {direction} SCRIPT\n🌥️  Cloud: {cloud}\n🗂️  Items: {len(items)}", title="[bold blue]Script Generation[/bold blue]", border_style="blue"))
     for item_name, item in items.items():
         flags = ''
         flags += 'z' if item['zip'] == 'True' else ''
         flags += 'e' if item['encrypt'] == 'True' else ''
         flags += 'r' if item['rel2home'] == 'True' else ''
         flags += 'o' if system().lower() in item_name else ''
-        
-        print(f"""
-╔{'─' * 70}╗
-║ 📦 PROCESSING: {item_name:<53} ║
-╠{'─' * 70}╣
-║ 📂 Path: {P(item['path']).as_posix():<55} ║
-║ 🏳️  Flags: {flags or 'None':<56} ║
-╚{'─' * 70}╝
-""")
-        
+        console.print(Panel(f"📦 PROCESSING: {item_name}\n📂 Path: {P(item['path']).as_posix()}\n🏳️  Flags: {flags or 'None'}", title=f"[bold blue]Processing Item: {item_name}[/bold blue]", border_style="blue"))
         if flags: flags = "-" + flags
         if direction == "BACKUP": 
             program += f"""\ncloud_copy "{P(item['path']).as_posix()}" $cloud {flags}\n"""
         elif direction == "RETRIEVE": 
             program += f"""\ncloud_copy $cloud "{P(item['path']).as_posix()}" {flags}\n"""
         else:
-            print(f"""
-╔{'═' * 70}╗
-║ ❌ ERROR: INVALID DIRECTION                                            ║
-║ ⚠️  Direction must be either "BACKUP" or "RETRIEVE"                     ║
-╚{'═' * 70}╝
-""")
-            raise RuntimeError(f"Unknown direction: {direction}")
-            
+            console.print(Panel("❌ ERROR: INVALID DIRECTION\n⚠️  Direction must be either \"BACKUP\" or \"RETRIEVE\"", title="[bold red]Error: Invalid Direction[/bold red]", border_style="red"))
+            raise RuntimeError(f"Unknown direction: {direction}")            
         if item_name == "dotfiles" and system() == "Linux": 
             program += """\nchmod 700 ~/.ssh/*\n"""
-            print(f"""
-╔{'─' * 70}╗
-║ 🔒 SPECIAL HANDLING: SSH PERMISSIONS                                    ║
-║ 🛠️  Setting secure permissions for SSH files                            ║
-║ 📝 Command: chmod 700 ~/.ssh/*                                          ║
-╚{'─' * 70}╝
-""")
-            
+            console.print(Panel("🔒 SPECIAL HANDLING: SSH PERMISSIONS\n🛠️  Setting secure permissions for SSH files\n📝 Command: chmod 700 ~/.ssh/*", title="[bold blue]Special Handling: SSH Permissions[/bold blue]", border_style="blue"))
     print_code(program, lexer="shell", desc=f"{direction} script")
-    
-    print(f"""
-╔{'═' * 70}╗
-║ ✅ {direction} SCRIPT GENERATION COMPLETE                               ║
-║ 🚀 Ready to execute the operations                                      ║
-╚{'═' * 70}╝
-""")
-    
+    console.print(Panel(f"✅ {direction} SCRIPT GENERATION COMPLETE\n🚀 Ready to execute the operations", title="[bold green]Script Generation Complete[/bold green]", border_style="green"))
     return program
 
 
 def main(direction: OPTIONS, which: Optional[str] = None):
-    print(f"""
-╔{'═' * 70}╗
-║ 🔄 {direction} OPERATION STARTED                                        ║
-║ ⏱️  {'-' * 58} ║
-╚{'═' * 70}╝
-""")
+    console = Console()
+    
+    console.print(Panel(f"🔄 {direction} OPERATION STARTED\n⏱️  {'-' * 58}", title="[bold blue]Operation Initiated[/bold blue]", border_style="blue"))
     
     code = main_backup_retrieve(direction=direction, which=which)
     from machineconfig.utils.utils import write_shell_script_to_default_program_path
     
-    print(f"""
-╔{'═' * 70}╗
-║ 💾 GENERATING SHELL SCRIPT                                             ║
-║ 📄 Filename: backup_retrieve.sh                                         ║
-╚{'═' * 70}╝
-""")
+    console.print(Panel("💾 GENERATING SHELL SCRIPT\n📄 Filename: backup_retrieve.sh", title="[bold blue]Shell Script Generation[/bold blue]", border_style="blue"))
     
     write_shell_script_to_default_program_path(program=code, desc="backup_retrieve.sh")
 

machineconfig/scripts/python/devops_devapps_install.py

@@ -155,10 +155,6 @@ def parse_apps_installer_windows(txt: str) -> dict[str, Any]:
 {a_chunk}
 {'-' * 50}""")
             raise e
-    # Struct(res).print(as_config=True)
-    # L(chunks).print(sep="-----------------------------------------------------------------------\n\n")
-    # import time
-    # time.sleep(10)
     return res
 
 

machineconfig/scripts/python/devops_update_repos.py

@@ -75,7 +75,7 @@ cd "{a_repo.working_dir}"
         program = "\n".join([f"""
 echo "🔄 {("Updating " + str(a_repo.working_dir)).center(80, "═")}"
 cd "{a_repo.working_dir}"
-{sep.join([f'git pull {remote.name} {a_repo.active_branch.name} &' for remote in a_repo.remotes])}
+{sep.join([f'git pull {remote.name} {a_repo.active_branch.name}' for remote in a_repo.remotes])}
 """ for a_repo in repos_objs])
     else: raise NotImplementedError(f"""
 ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

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_utils.ve1 import get_repo_root
 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.file_management import P, Read, Save
 from crocodile.core import randstr
 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,19 +36,28 @@ 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()
+    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))
     if not path_obj.exists():
@@ -62,7 +71,8 @@ def main() -> None:
         choice_file = P(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}. Repo root: {repo_root}")
 
     ve_name_suggested, ipy_profile = get_ve_name_and_ipython_profile(choice_file)
     if ipy_profile is None: ipy_profile = "default"
@@ -118,20 +128,39 @@ def main() -> None:
             port = 8501
             toml_path: Optional[P] = 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:
+                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 = P.home().joinpath(f"dotfiles/creds/streamlit/{P(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 +174,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:
@@ -199,7 +227,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 {P.cwd()}"
 
     elif args.cmd:
         command = rf""" cd /d {choice_file.parent} & {exe} {choice_file.name} """
@@ -208,21 +236,22 @@ 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 {P.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:
@@ -235,9 +264,6 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
     # 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")
@@ -287,10 +313,32 @@ 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)
+    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}" """
+        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 = P(program_path) if program_path is not None else PROGRAM_PATH
+    if args.loop:
+        if platform.system() == "Linux":
+            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/helpers/cloud_helpers.py

@@ -1,4 +1,3 @@
-
 from crocodile.core import Struct
 from crocodile.file_management import P, Read
 from pydantic import ConfigDict
@@ -6,6 +5,12 @@ 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:
@@ -42,32 +47,21 @@ class Args():
 
     @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 find_cloud_config(path: P):
-    print(f"""
-╭{'─' * 70}╮
-│ 🔍 Searching for cloud configuration file...                              │
-╰{'─' * 70}╯
-""")
+    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}╯
-""")
+            display_success(f"Found cloud config at: {path.joinpath('cloud.json')}")
             Struct(res.__dict__).print(as_config=True, title="Cloud Config")
             return res
         path = path.parent
 
-    print("❌ No cloud configuration file found")
+    display_error("No cloud configuration file found")
     return None
 
 
@@ -76,30 +70,22 @@ def absolute(path: str) -> P:
     if not path.startswith(".") and  obj.exists(): return obj
     try_absing =  P.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']
@@ -110,7 +96,7 @@ 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")
     if default_password_path.exists():
@@ -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}╯
-""")
+    display_success("Using SecureShare cloud config")
     Struct(res.__dict__).print(as_config=True, title="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