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

machineconfig/scripts/python/devops_backup_retrieve.py

@@ -2,177 +2,89 @@
 """
 
 # import subprocess
-from crocodile.file_management import Read, P
+from machineconfig.utils.path_reduced import P as PathExtended
+from machineconfig.utils.utils2 import read_ini, read_toml
 from machineconfig.utils.utils import LIBRARY_ROOT, DEFAULTS_PATH, print_code, choose_cloud_interactively, choose_multiple_options
 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}╝
-""")
+        cloud: str = read_ini(DEFAULTS_PATH)['general']['rclone_config_name']
+        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"))
+    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}╝
-""")
+        choices = which.split(",") if which else []
+        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: {PathExtended(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"""
+            program += f"""\ncloud_copy "{PathExtended(item['path']).as_posix()}" $cloud {flags}\n"""
         elif direction == "RETRIEVE": 
-            program += f"""\ncloud_copy $cloud "{P(item['path']).as_posix()}" {flags}\n"""
+            program += f"""\ncloud_copy $cloud "{PathExtended(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")
+    write_shell_script_to_default_program_path(program=code, desc="backup_retrieve.sh", preserve_cwd=True, display=True, execute=False)
 
 
 if __name__ == "__main__":

machineconfig/scripts/python/devops_devapps_install.py

@@ -4,7 +4,6 @@
 # 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, get_all_dicts
 from platform import system
@@ -67,7 +66,7 @@ def get_programs_by_category(program_name: WHICH_CAT):
             installers_ = get_installers(dev=False, system=system())
             if program_name == "EssentialsAndOthers":
                 installers_ += get_installers(dev=True, system=system())
-            install_all(installers=L(installers_))
+            install_all(installers=installers_)
             program = ""
 
         case "SystemInstallers":
@@ -107,10 +106,11 @@ def get_programs_by_category(program_name: WHICH_CAT):
         #         sub_program = installers[idx].install_robust(version=None)  # finish the task
 
         case  "PrecheckedCloudInstaller":
-            from machineconfig.jobs.python.check_installations import PrecheckedCloudInstaller
-            ci = PrecheckedCloudInstaller()
-            ci.download_safe_apps(name="AllEssentials")
-            program = ""
+            # from machineconfig.jobs.python.check_installations import PrecheckedCloudInstaller
+            # ci = PrecheckedCloudInstaller()
+            # ci.download_safe_apps(name="AllEssentials")
+            # program = ""
+            raise NotImplementedError("PrecheckedCloudInstaller is not implemented yet.")
     return program
 
 
@@ -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

@@ -1,8 +1,9 @@
 """Update repositories with fancy output
 """
 
-from crocodile.file_management import P, Read
+from machineconfig.utils.path_reduced import P as PathExtended
 from machineconfig.utils.utils import DEFAULTS_PATH
+from machineconfig.utils.utils2 import read_ini
 from platform import system
 
 
@@ -13,7 +14,7 @@ def main(verbose: bool=True) -> str:
     _ = verbose
     repos: list[str] = ["~/code/crocodile", "~/code/machineconfig", ]
     try:
-        tmp = Read.ini(DEFAULTS_PATH)['general']['repos'].split(",")
+        tmp = read_ini(DEFAULTS_PATH)['general']['repos'].split(",")
         if tmp[-1] == "": tmp = tmp[:-1]
         repos += tmp
     except (FileNotFoundError, KeyError, IndexError):
@@ -37,7 +38,7 @@ def main(verbose: bool=True) -> str:
     for a_package_path in repos:
         try:
             import git
-            repo = git.Repo(str(P(a_package_path).expanduser()), search_parent_directories=True)
+            repo = git.Repo(str(PathExtended(a_package_path).expanduser()), search_parent_directories=True)
             repos_objs.append(repo)
         except Exception as ex:
             print(f"""
@@ -75,7 +76,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/dotfile.py

@@ -2,7 +2,7 @@
 """
 
 
-from crocodile.file_management import P
+from machineconfig.utils.path_reduced import P as PathExtended
 from machineconfig.profile.create import symlink_func
 from machineconfig.utils.utils import LIBRARY_ROOT, REPO_ROOT
 import argparse
@@ -18,14 +18,17 @@ def main():
     parser.add_argument("-d", "--dest", help="destination folder", default="")
 
     args = parser.parse_args()
-    orig_path = P(args.file).expanduser().absolute()
+    orig_path = PathExtended(args.file).expanduser().absolute()
     if args.dest == "":
-        if "Local" in orig_path: junction = orig_path.split(at="Local", sep=-1)[1]
-        elif "Roaming" in orig_path: junction = orig_path.split(at="Roaming", sep=-1)[1]
-        elif ".config" in orig_path: junction = orig_path.split(at=".config", sep=-1)[1]
+        if "Local" in str(orig_path): junction = orig_path.split(at="Local", sep=-1)[1]
+        elif "Roaming" in str(orig_path): junction = orig_path.split(at="Roaming", sep=-1)[1]
+        elif ".config" in str(orig_path): junction = orig_path.split(at=".config", sep=-1)[1]
         else: junction = orig_path.rel2home()
         new_path = REPO_ROOT.joinpath(junction)
-    else: new_path = P(args.dest).expanduser().absolute().create().joinpath(orig_path.name)
+    else: 
+        dest_path = PathExtended(args.dest).expanduser().absolute()
+        dest_path.mkdir(parents=True, exist_ok=True)
+        new_path = dest_path.joinpath(orig_path.name)
 
     symlink_func(this=orig_path, to_this=new_path, prioritize_to_this=args.overwrite)
 
@@ -39,7 +42,7 @@ def main():
 📝 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()}' }}
+{orig_path.name.split('.')[0]} = {{ this = '{orig_path.collapseuser().as_posix()}', to_this = '{new_path.collapseuser().as_posix()}' }}
 """)
 
 

machineconfig/scripts/python/fire_agents.py

@@ -0,0 +1,69 @@
+
+
+from pathlib import Path
+# from machineconfig.cluster.sessions_managers.zellij_local import run_zellij_layout
+from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
+
+
+def launch_agents(repo_root: Path, prompts: list[str]):
+    tab_config: dict[str, tuple[str, str]] = {}
+    for idx, a_prompt in enumerate(prompts):
+        tmp_file_path = repo_root.joinpath(f".ai/tmp_prompts/agent{idx}.txt")
+        tmp_file_path.parent.mkdir(parents=True, exist_ok=True)
+        Path(tmp_file_path).write_text(a_prompt)
+        tab_config[f"Agent{idx}"] = (str(repo_root), f"cursor-agent --print --output-format text < .ai/tmp_prompts/agent{idx}.txt")
+    if len(tab_config) > 15:
+        raise RuntimeError(f"Too many agents (#{len(tab_config)}), please cut them down to 15 or less")
+    print(f"Launching a template with #{len(tab_config)} agents")
+    return tab_config
+
+
+def main():
+    repo_root = Path.cwd()
+    print(f"Operating @ {repo_root}")
+    file_path = input("Enter path to target file [press Enter to generate it from searching]: ")
+    if file_path == "":
+        keyword = input("Enter keyword to search recursively for all .py files containing it. ")
+        py_files = list(repo_root.rglob("*.py"))
+        matching_files = [
+            f for f in py_files
+            if keyword in f.read_text(encoding='utf-8', errors='ignore')
+        ]
+        if not matching_files:
+            print(f"💥 No .py files found containing keyword: {keyword}")
+            return
+        print(f"Found {len(matching_files)} .py files containing keyword: {keyword}")
+        file_path = repo_root.joinpath(".ai", "target_file.txt")
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        file_path.write_text("\n".join(str(f) for f in matching_files), encoding='utf-8')
+        separator = "\n"
+    else:
+        separator = input("Enter separator [\\n]: ") or "\n"
+
+    err_file = Path(file_path).expanduser().absolute().read_text(encoding='utf-8', errors='ignore')
+    prefix = input("Enter prefix prompt: ")
+    prompts = [item for item in err_file.split(separator)]
+    # Dynamically choose chunk size so we end up with <= 15 combined prompts.
+    # If we already have 15 or fewer, keep them as-is.
+    if len(prompts) <= 15:
+        combined_prompts = prompts
+    else:
+        # Compute minimal chunk size so that number_of_chunks <= 15.
+        # number_of_chunks = ceil(len(prompts)/chunk_size) <= 15
+        # => chunk_size >= len(prompts)/15 -> choose ceil(len/15)
+        from math import ceil
+        chunk_size = ceil(len(prompts) / 15)
+        combined_prompts: list[str] = []
+        for i in range(0, len(prompts), chunk_size):
+            combined_prompts.append("\nTargeted Locations:\n".join(prompts[i:i+chunk_size]))
+    combined_prompts = [prefix + "\n" + item for item in combined_prompts]
+    tab_config = launch_agents(repo_root=repo_root, prompts=combined_prompts)
+    from machineconfig.utils.utils2 import randstr
+    random_name = randstr(length=3)
+    manager = ZellijLocalManager(session2zellij_tabs={"Agents": tab_config}, session_name_prefix=random_name)
+    manager.start_all_sessions()
+    manager.run_monitoring_routine()
+
+
+if __name__ == "__main__":
+    main()