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

machineconfig/scripts/python/devops_backup_retrieve.py

@@ -1,11 +1,10 @@
-
 """BR: Backup and Retrieve
 """
 
 # import subprocess
 from crocodile.file_management import Read, P
 from machineconfig.utils.utils import LIBRARY_ROOT, DEFAULTS_PATH, print_code, choose_cloud_interactively, choose_multiple_options
-from machineconfig.scripts.python.cloud_sync import ES
+from machineconfig.scripts.python.helpers.helpers2 import ES
 from platform import system
 from typing import Any, Literal, Optional
 
@@ -16,45 +15,164 @@ OPTIONS = Literal["BACKUP", "RETRIEVE"]
 def main_backup_retrieve(direction: OPTIONS, which: Optional[str] = None):
     try:
         cloud: str = Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
-        print(f"\n{'--' *  50}\n ⚠️ Using default cloud: `{cloud}` ⚠️\n{'--' *  50}\n")
-    except (FileNotFoundError, KeyError, IndexError): cloud = choose_cloud_interactively()
+        print(f"""
+╔{'═' * 70}╗
+║ ⚠️  DEFAULT CLOUD CONFIGURATION                                          ║
+╠{'═' * 70}╣
+║ 🌥️  Using default cloud: {cloud:<52} ║
+╚{'═' * 70}╝
+""")
+    except (FileNotFoundError, KeyError, IndexError):
+        print(f"""
+╔{'═' * 70}╗
+║ 🔍 DEFAULT CLOUD NOT FOUND                                              ║
+║ 🔄 Please select a cloud configuration from the options below            ║
+╚{'═' * 70}╝
+""")
+        cloud = choose_cloud_interactively()
 
     bu_file: dict[str, Any] = Read.toml(LIBRARY_ROOT.joinpath("profile/backup.toml"))
-    if system() == "Linux": bu_file = {key: val for key, val in bu_file.items() if "windows" not in key}
-    elif system() == "Windows": bu_file = {key: val for key, val in bu_file.items() if "linux" not in key}
+    
+    print(f"""
+╔{'═' * 70}╗
+║ 🧰 LOADING BACKUP CONFIGURATION                                         ║
+║ 📄 File: {LIBRARY_ROOT.joinpath("profile/backup.toml")}      ║
+╚{'═' * 70}╝
+""")
+    
+    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}╝
+""")
+    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}╝
+""")
 
     if which is None:
+        print(f"""
+╔{'═' * 70}╗
+║ 🔍 SELECT {direction} ITEMS                                             ║
+║ 📋 Choose which configuration entries to process                         ║
+╚{'═' * 70}╝
+""")
         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}╝
+""")
 
-    if "all" in choices: items = bu_file
+    if "all" in choices:
+        items = bu_file
+        print(f"""
+╔{'═' * 70}╗
+║ 📋 PROCESSING ALL ENTRIES                                               ║
+║ 🔢 Total entries to process: {len(bu_file):<39} ║
+╚{'═' * 70}╝
+""")
     else:
-        # items = {choices: bu_file[choices]}
         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}╝
+""")
 
     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}╝
+""")
+    
     for item_name, item in items.items():
-        # P.home().joinpath(".ipython").to_cloud(cloud="oduq1", zip=True, encrypt=True, rel2home=True, os_specific=False)
         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}╝
+""")
+        
         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"""
+        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}")
-        if item_name == "dotfiles" and system() == "Linux": program += """\nchmod 700 ~/.ssh/*\n"""
+            
+        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}╝
+""")
+            
     print_code(program, lexer="shell", desc=f"{direction} script")
+    
+    print(f"""
+╔{'═' * 70}╗
+║ ✅ {direction} SCRIPT GENERATION COMPLETE                               ║
+║ 🚀 Ready to execute the operations                                      ║
+╚{'═' * 70}╝
+""")
+    
     return program
 
 
 def main(direction: OPTIONS, which: Optional[str] = None):
+    print(f"""
+╔{'═' * 70}╗
+║ 🔄 {direction} OPERATION STARTED                                        ║
+║ ⏱️  {'-' * 58} ║
+╚{'═' * 70}╝
+""")
+    
     code = main_backup_retrieve(direction=direction, which=which)
-    from machineconfig.utils.utils import write_shell_script
-    write_shell_script(program=code, desc="backup_retrieve.sh")
+    from machineconfig.utils.utils import write_shell_script_to_default_program_path
+    
+    print(f"""
+╔{'═' * 70}╗
+║ 💾 GENERATING SHELL SCRIPT                                             ║
+║ 📄 Filename: backup_retrieve.sh                                         ║
+╚{'═' * 70}╝
+""")
+    
+    write_shell_script_to_default_program_path(program=code, desc="backup_retrieve.sh")
 
 
 if __name__ == "__main__":

machineconfig/scripts/python/devops_devapps_install.py

@@ -1,12 +1,12 @@
-
 """Devops Devapps Install
 """
 
 # import subprocess
+from machineconfig.utils.installer_utils.installer_class import Installer
 from tqdm import tqdm
 from crocodile.core import List as L
 from machineconfig.utils.utils import LIBRARY_ROOT, choose_multiple_options
-from machineconfig.utils.installer import get_installers, install_all, Installer, get_all_dicts
+from machineconfig.utils.installer import get_installers, install_all, get_all_dicts
 from platform import system
 from typing import Any, Optional, Literal, TypeAlias, get_args
 
@@ -27,7 +27,10 @@ def main(which: Optional[WHICH_CAT | str] = None):
                 kv.update(v)
             if a_which not in kv:
                 raise ValueError(f"{a_which=} not found in {kv.keys()}")
-            print(f"Installing {a_which}", kv[a_which])
+            print(f"""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ 🔧 Installing: {a_which}
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
             installer = Installer.from_dict(name=a_which, d=kv[a_which])
             print(installer)
             program = installer.install_robust(version=None)  # finish the task
@@ -37,12 +40,15 @@ def main(which: Optional[WHICH_CAT | str] = None):
 
     # interactive installation
     installers = [Installer.from_dict(d=vd, name=name) for __kat, vds in get_all_dicts(system=system()).items() for name, vd in vds.items()]
-    options = [x.get_description() for x in tqdm(installers, desc="Checking installed programs")] + list(get_args(WHICH_CAT))
-    program_names = choose_multiple_options(msg="", options=options, header="CHOOSE DEV APP", default="AllEssentials")
+    options = [x.get_description() for x in tqdm(installers, desc="✅ Checking installed programs")] + list(get_args(WHICH_CAT))
+    program_names = choose_multiple_options(msg="", options=options, header="🚀 CHOOSE DEV APP", default="AllEssentials")
 
     total_program = ""
     for _an_idx, a_program_name in enumerate(program_names):
-        print(a_program_name)
+        print(f"""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ 🔄 Processing: {a_program_name}
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
         if a_program_name in get_args(WHICH_CAT):
             total_program += "\n" + get_programs_by_category(program_name=a_program_name)  # type: ignore
         else:
@@ -52,6 +58,10 @@ def main(which: Optional[WHICH_CAT | str] = None):
 
 
 def get_programs_by_category(program_name: WHICH_CAT):
+    print(f"""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ 📦 Installing Category: {program_name}
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
     match program_name:
         case "AllEssentials" | "EssentialsAndOthers":
             installers_ = get_installers(dev=False, system=system())
@@ -66,10 +76,14 @@ def get_programs_by_category(program_name: WHICH_CAT):
                 options_system_1 = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps_dev.sh").read_text())
                 options_system_2 = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps.sh").read_text())
                 options_system = {**options_system_1, **options_system_2}
-            else: raise NotImplementedError(f"System {system()} not supported")
-            program_names = choose_multiple_options(msg="", options=sorted(list(options_system.keys())), header="CHOOSE DEV APP")
+            else: raise NotImplementedError(f"❌ System {system()} not supported")
+            program_names = choose_multiple_options(msg="", options=sorted(list(options_system.keys())), header="🚀 CHOOSE DEV APP")
             program = ""
             for name in program_names:
+                print(f"""
+┌────────────────────────────────────────────────────
+│ ⚙️  Installing: {name}
+└────────────────────────────────────────────────────""")
                 sub_program = options_system[name]
                 if sub_program.startswith("#winget"): sub_program = sub_program[1:]
                 program += "\n" + sub_program
@@ -109,7 +123,11 @@ def parse_apps_installer_linux(txt: str) -> dict[str, Any]:
             v = "\n".join(chunk.split("\n")[1:])
             res[k] = v
         except IndexError as e:
-            print(chunk)
+            print(f"""
+❌ Error parsing chunk:
+{'-' * 50}
+{chunk}
+{'-' * 50}""")
             raise e
     return res
 
@@ -126,12 +144,16 @@ def parse_apps_installer_windows(txt: str) -> dict[str, Any]:
         try:
             name = a_chunk.split('--name ')[1]
             if "--Id" not in name:
-                print(f"Warning: {name} does not have an Id, skipping")
+                print(f"⚠️  Warning: {name} does not have an Id, skipping")
                 continue
             name = name.split(' --Id ', maxsplit=1)[0].strip('"').strip('"')
             res[name] = a_chunk
         except IndexError as e:
-            print(a_chunk)
+            print(f"""
+❌ Error parsing chunk:
+{'-' * 50}
+{a_chunk}
+{'-' * 50}""")
             raise e
     # Struct(res).print(as_config=True)
     # L(chunks).print(sep="-----------------------------------------------------------------------\n\n")

machineconfig/scripts/python/devops_update_repos.py

@@ -1,5 +1,4 @@
-
-"""Update
+"""Update repositories with fancy output
 """
 
 from crocodile.file_management import P, Read
@@ -18,14 +17,21 @@ def main(verbose: bool=True) -> str:
         if tmp[-1] == "": tmp = tmp[:-1]
         repos += tmp
     except (FileNotFoundError, KeyError, IndexError):
-        print(f"Missing {DEFAULTS_PATH} or section [general] or key repos. Using default repos.")
-        print("""It should look like this:
-[general]
-repos = ~/code/repo1,~/code/repo2
-rclone_config_name = onedrivePersonal
-email_config_name = Yahoo3
-to_email = myemail@email.com
-""")
+        print(f"""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ 🚫 Configuration Error: Missing {DEFAULTS_PATH} or section [general] or key repos
+┃ ℹ️  Using default repositories instead
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
+        print("""
+┌────────────────────────────────────────────────────────────────
+│ ✨ Example Configuration:
+│ 
+│ [general]
+│ repos = ~/code/repo1,~/code/repo2
+│ rclone_config_name = onedrivePersonal
+│ email_config_name = Yahoo3
+│ to_email = myemail@email.com
+└────────────────────────────────────────────────────────────────""")
 
     repos_objs = []
     for a_package_path in repos:
@@ -34,49 +40,50 @@ to_email = myemail@email.com
             repo = git.Repo(str(P(a_package_path).expanduser()), search_parent_directories=True)
             repos_objs.append(repo)
         except Exception as ex:
-            print(ex)
+            print(f"""
+❌ Repository Error:
+   Path: {a_package_path}
+   Exception: {ex}
+{'-' * 50}""")
 
     if system() == "Linux":
         additions = []
         for a_repo in repos_objs:
-            if "machineconfig" in a_repo.working_dir:  # special treatment because of executables.
+            if "machineconfig" in str(a_repo.working_dir):  # special treatment because of executables.
                 an_addition = f"""
 echo ""
-echo "{("Pulling " + str(a_repo.working_dir)).center(80, "-")}"
+echo "🔄 {("Updating " + str(a_repo.working_dir)).center(80, "═")}"
+echo "🛠  Special handling for machineconfig repository..."
 cd "{a_repo.working_dir}"
 # git reset --hard
-git pull origin
+git pull origin &
 chmod +x ~/scripts -R
 chmod +x ~/code/machineconfig/src/machineconfig/jobs/linux -R
 chmod +x ~/code/machineconfig/src/machineconfig/settings/lf/linux/exe -R
 """
                 additions.append(an_addition)
             else:
-                # if a_repo.is_dirty() and input(f"Repository {a_repo} is not clean, hard-reset it? y/[n]"): a_repo.git.reset('--hard')
                 additions.append(f"""
-echo "{("Pulling " + str(a_repo.working_dir)).center(80, "-")}"
+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])}
+"""
+)
         program = "\n".join(additions)
 
     elif system() == "Windows":
         program = "\n".join([f"""
-echo "{("Pulling " + str(a_repo.working_dir)).center(80, "-")}"
+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"System {system()} not supported")
-    # write_shell_script(program, desc="Script to update repos")
-    # return ""
+    else: raise NotImplementedError(f"""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ ⚠️  Unsupported System: {system()}
+┃ ℹ️  This functionality is only available on Windows and Linux
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
     return program
 
 
-# def get_pulls(remote):
-#     if len(remote.branches) == 0: return ""
-#     elif len(remote.branches) == 1: return f'git pull {remote.name} {remote.branches[0].name}'
-#     else: return f'git pull {remote.name} {remote.active_branch.name}'
-
-
 if __name__ == '__main__':
     pass

machineconfig/scripts/python/dotfile.py

@@ -1,4 +1,3 @@
-
 """Like yadm and dotter.
 """
 
@@ -30,9 +29,15 @@ def main():
 
     symlink_func(this=orig_path, to_this=new_path, prioritize_to_this=args.overwrite)
 
-    print("Map completed. To enshrine this mapping, add the following line to the mapper.toml file:")
-    print(f"nano {LIBRARY_ROOT}/symlinks/mapper.toml")
+    print("""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ ✅ Symbolic Link Created Successfully
+┃ 
+┃ 🔄 To enshrine this mapping, add the following to mapper.toml:
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
     print(f"""
+📝 Edit configuration file: nano {LIBRARY_ROOT}/symlinks/mapper.toml
+
 [{new_path.parent.name}]
 {orig_path.trunk} = {{ this = '{orig_path.collapseuser().as_posix()}', to_this = '{new_path.collapseuser().as_posix()}' }}
 """)