machineconfig 1.9__py3-none-any.whl → 1.91__py3-none-any.whl

machineconfig/scripts/python/devops_devapps_install.py

@@ -6,79 +6,97 @@
 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, Installer, install_all
+from machineconfig.utils.installer import get_installers, install_all, Installer, get_all_dicts
 from platform import system
-from typing import Any, Optional, Literal, TypeAlias
+from typing import Any, Optional, Literal, TypeAlias, get_args
 
 
-WHICH: TypeAlias = Literal["AllEssentials", "EssentialsAndOthers", "SystemInstallers", "OtherDevApps", "PrecheckedCloudInstaller"]
+WHICH_CAT: TypeAlias = Literal["AllEssentials", "EssentialsAndOthers", "SystemInstallers", "PrecheckedCloudInstaller"]
 
 
-def main(which: Optional[str] = None):
-    sys = system()
-    installers = get_installers(dev=False, system=sys)  # + get_installers(dev=True, system=sys)
-    default = "AllEssentials"
-    options = ["SystemInstallers", "OtherDevApps", "EssentialsAndOthers", "PrecheckedCloudInstaller", default]
-    options = [x.get_description() for x in tqdm(installers, desc="Checking installed programs")] + options
+def main(which: Optional[WHICH_CAT | str] = None):
 
-    if which is not None:
-        return get_program(program_name=which, options=options, installers=list(installers))
+    if which is not None and which in get_args(WHICH_CAT):  # install by category
+        return get_programs_by_category(program_name=which)  # type: ignore
+
+    if which is not None:  # install by name
+        program_total = ""
+        for a_which in (which.split(",") if type(which) == str else which):
+            kv = {}
+            for _category, v in get_all_dicts(system=system()).items():
+                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])
+            installer = Installer.from_dict(name=a_which, d=kv[a_which])
+            print(installer)
+            program = installer.install_robust(version=None)  # finish the task
+            program = "echo 'Finished Installation'"  # write an empty program
+            program_total += "\n" + program
+        return program_total
+
+    # 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")
 
-    program_names = choose_multiple_options(msg="", options=options, header="CHOOSE DEV APP", default=str(default))
     total_program = ""
-    for which in program_names:
-        assert isinstance(which, str), f"program_name is not a string: {which}"
-        total_program += "\n" + get_program(program_name=which, options=options, installers=list(installers))
+    for _an_idx, a_program_name in enumerate(program_names):
+        print(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:
+            an_installer = installers[options.index(a_program_name)]
+            total_program += "\n" + an_installer.install_robust(version=None)  # finish the task
     return total_program
 
 
-def get_program(program_name: str, options: list[str], installers: list[Installer]):
-    if program_name == "AllEssentials" or program_name == "EssentialsAndOthers":
-        installers_ = get_installers(dev=False, system=system())
-        if program_name == "EssentialsAndOthers":
-            installers_ += get_installers(dev=True, system=system())
-        install_all(installers=L(installers))
-        program = ""
-    elif program_name == "SystemInstallers":
-        if system() == "Windows": options_system = parse_apps_installer_windows(LIBRARY_ROOT.joinpath("setup_windows/apps.ps1").read_text())
-        elif system() == "Linux":
-            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")
-        program = ""
-        for name in program_names:
-            sub_program = options_system[name]
-            if sub_program.startswith("#winget"): sub_program = sub_program[1:]
-            program += "\n" + sub_program
-    elif program_name == "OtherDevApps":
-        installers = get_installers(dev=True, system=system())
-        options__: list[str] = [x.get_description() for x in tqdm(installers, desc="Checking installed programs")]
-        program_names = choose_multiple_options(msg="", options=sorted(options__) + ["all"], header="CHOOSE DEV APP")
-        if "all" in program_names: program_names = options__
-        program = ""
-        print(f"Installing:")
-        L(program_names).print()
-        for name in program_names:
-            try:
-                idx = options__.index(name)
-            except ValueError as ve:
-                print(f"{name=}")
-                print(f"{options__=}")
-                raise ve
-            print(f"Installing {name}")
-            sub_program = installers[idx].install_robust(version=None)  # finish the task
-    elif program_name == "PrecheckedCloudInstaller":
-        from machineconfig.jobs.python.check_installations import PrecheckedCloudInstaller
-        ci = PrecheckedCloudInstaller()
-        ci.download_safe_apps(name="AllEssentials")
-        program = ""
-    else:
-        idx = options.index(program_name)
-        print(installers[idx])
-        program = installers[idx].install_robust(version=None)  # finish the task
-        program = "echo 'Finished Installation'"  # write an empty program
+def get_programs_by_category(program_name: WHICH_CAT):
+    match program_name:
+        case "AllEssentials" | "EssentialsAndOthers":
+            installers_ = get_installers(dev=False, system=system())
+            if program_name == "EssentialsAndOthers":
+                installers_ += get_installers(dev=True, system=system())
+            install_all(installers=L(installers_))
+            program = ""
+
+        case "SystemInstallers":
+            if system() == "Windows": options_system = parse_apps_installer_windows(LIBRARY_ROOT.joinpath("setup_windows/apps.ps1").read_text())
+            elif system() == "Linux":
+                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")
+            program = ""
+            for name in program_names:
+                sub_program = options_system[name]
+                if sub_program.startswith("#winget"): sub_program = sub_program[1:]
+                program += "\n" + sub_program
+
+        # case "OtherDevApps":
+        #     installers = get_installers(dev=True, system=system())
+        #     options__: list[str] = [x.get_description() for x in tqdm(installers, desc="Checking installed programs")]
+        #     program_names = choose_multiple_options(msg="", options=sorted(options__) + ["all"], header="CHOOSE DEV APP")
+        #     if "all" in program_names: program_names = options__
+        #     program = ""
+        #     print("Installing:")
+        #     L(program_names).print()
+        #     for name in program_names:
+        #         try:
+        #             idx = options__.index(name)
+        #         except ValueError as ve:
+        #             print(f"{name=}")
+        #             print(f"{options__=}")
+        #             raise ve
+        #         print(f"Installing {name}")
+        #         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 = ""
     return program
 
 

machineconfig/scripts/python/devops_update_repos.py

@@ -3,7 +3,6 @@
 """
 
 from crocodile.file_management import P, Read
-from crocodile.core import install_n_import
 from machineconfig.utils.utils import DEFAULTS_PATH
 from platform import system
 
@@ -11,7 +10,7 @@ from platform import system
 sep = "\n"
 
 
-def main(verbose: bool = True) -> str:
+def main(verbose: bool=True) -> str:
     _ = verbose
     repos: list[str] = ["~/code/crocodile", "~/code/machineconfig", ]
     try:
@@ -20,10 +19,10 @@ def main(verbose: bool = True) -> str:
         repos += tmp
     except (FileNotFoundError, KeyError, IndexError):
         print(f"Missing {DEFAULTS_PATH} or section [general] or key repos. Using default repos.")
-        print(f"""It should look like this:
+        print("""It should look like this:
 [general]
 repos = ~/code/repo1,~/code/repo2
-rclone_config_name = onedriveWork
+rclone_config_name = onedrivePersonal
 email_config_name = Yahoo3
 to_email = myemail@email.com
 """)
@@ -31,7 +30,8 @@ to_email = myemail@email.com
     repos_objs = []
     for a_package_path in repos:
         try:
-            repo = install_n_import("git", "gitpython").Repo(str(P(a_package_path).expanduser()), search_parent_directories=True)
+            import git
+            repo = git.Repo(str(P(a_package_path).expanduser()), search_parent_directories=True)
             repos_objs.append(repo)
         except Exception as ex:
             print(ex)

machineconfig/scripts/python/dotfile.py

@@ -4,7 +4,7 @@
 
 
 from crocodile.file_management import P
-from machineconfig.profile.create import symlink
+from machineconfig.profile.create import symlink_func
 from machineconfig.utils.utils import LIBRARY_ROOT, REPO_ROOT
 import argparse
 
@@ -16,7 +16,7 @@ def main():
     # FLAGS
     parser.add_argument("--overwrite", "-o", help="Overwrite.", action="store_true")  # default is False
     # optional
-    parser.add_argument("-d", "--dest", help=f"destination folder", default="")
+    parser.add_argument("-d", "--dest", help="destination folder", default="")
 
     args = parser.parse_args()
     orig_path = P(args.file).expanduser().absolute()
@@ -28,9 +28,9 @@ def main():
         new_path = REPO_ROOT.joinpath(junction)
     else: new_path = P(args.dest).expanduser().absolute().create().joinpath(orig_path.name)
 
-    symlink(this=orig_path, to_this=new_path, prioritize_to_this=args.overwrite)
+    symlink_func(this=orig_path, to_this=new_path, prioritize_to_this=args.overwrite)
 
-    print(f"Map completed. To enshrine this mapping, add the following line to the mapper.toml file:")
+    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(f"""
 [{new_path.parent.name}]

machineconfig/scripts/python/fire_jobs.py

@@ -10,7 +10,7 @@ fire
 
 
 from machineconfig.utils.utils import display_options, choose_one_option, PROGRAM_PATH, choose_ssh_host, match_file_name, sanitize_path
-from crocodile.file_management import P, install_n_import
+from crocodile.file_management import P, install_n_import, Read
 from crocodile.core import Display, randstr
 import inspect
 import platform
@@ -19,6 +19,23 @@ from typing import Callable, Any, Optional
 import argparse
 
 
+def search_for_files_of_interest(path_obj: P):
+    if path_obj.joinpath(".venv").exists():
+        path_objects = path_obj.search("*", not_in=[".venv"]).list
+        files: list[P] = []
+        for a_path_obj in path_objects:
+            files += search_for_files_of_interest(path_obj=a_path_obj)
+        return files
+    py_files = path_obj.search(pattern="*.py", not_in=["__init__.py"], r=True).list
+    ps_files = path_obj.search(pattern="*.ps1", r=True).list
+    sh_files = path_obj.search(pattern="*.sh", r=True).list
+    files = py_files + ps_files + sh_files
+    return files
+
+
+str2obj = {"True": True, "False": False, "None": None}
+
+
 def main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument("path",     nargs='?', type=str, help="The directory containing the jobs", default=".")
@@ -37,6 +54,7 @@ def main() -> None:
     parser.add_argument("--streamlit",       "-S", action="store_true", help="run as streamlit app")
     parser.add_argument("--history",         "-H", action="store_true", help="choose from history")
     # 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("--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 ...")
 
@@ -44,23 +62,21 @@ def main() -> None:
     if args.kw is not None:
         assert len(args.kw) % 2 == 0, f"args.kw must be a list of even length. Got {len(args.kw)}"
         kwargs = dict(zip(args.kw[::2], args.kw[1::2]))
+        for key, value in kwargs.items():
+            if value in str2obj:
+                kwargs[key] = str2obj[value]
         # print(f"kwargs = {kwargs}")
     else:
         kwargs = {}
 
     path_obj = sanitize_path(P(args.path))
     if not path_obj.exists():
-        path_obj = match_file_name(args.path)
-        print(path_obj)
+        path_obj = match_file_name(sub_string=args.path)
     else: pass
 
     if path_obj.is_dir():
         print(f"Seaching recursively for all python file in directory `{path_obj}`")
-        py_files = path_obj.search(pattern="*.py", not_in=["__init__.py"], r=True).list
-        ps_files = path_obj.search(pattern="*.ps1", r=True).list
-        sh_files = path_obj.search(pattern="*.sh", r=True).list
-        files = py_files + ps_files + sh_files
-
+        files = search_for_files_of_interest(path_obj)
         choice_file = choose_one_option(options=files, fzf=True)
         choice_file = P(choice_file)
     else:
@@ -90,12 +106,19 @@ def main() -> None:
         args.ve = get_ve_profile(choice_file)
 
     if args.streamlit:
-        import socket
-        try: local_ip_v4 = socket.gethostbyname(socket.gethostname() + ".local")  # without .local, in linux machines, '/etc/hosts' file content, you have an IP address mapping with '127.0.1.1' to your hostname
-        except Exception:
-            print(f"Warning: Could not get local_ip_v4. This is probably because you are running a WSL instance")  # TODO find a way to get the local_ip_v4 in WSL
-            local_ip_v4 = socket.gethostbyname(socket.gethostname())
-        print(f"🚀 Streamlit app is running at: http://{local_ip_v4}:8501")
+        from crocodile.environment import get_network_addresses
+        local_ip_v4 = get_network_addresses()["local_ip_v4"]
+        computer_name = platform.node()
+        port = 8501
+        if choice_file.parent.joinpath(".streamlit/config.toml").exists():
+            config = Read.toml(choice_file.parent.joinpath(".streamlit/config.toml"))
+            if "server" in config:
+                if "port" in config["server"]:
+                    port = config["server"]["port"]
+        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"
     elif args.interactive is False: exe = "python"
     elif args.jupyter: exe = "jupyter-lab"
@@ -105,7 +128,7 @@ def main() -> None:
 
     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.
         import_line = get_import_module_code(str(choice_file))
-        txt: str = f"""
+        txt: str=f"""
 try:
     {import_line}
 except (ImportError, ModuleNotFoundError) as ex:
@@ -183,9 +206,9 @@ except ImportError as _ex:
         if "ipdb" in command: command = f"pip install ipdb\n\n{command}"
         if "pudb" in command: command = f"pip install pudb\n\n{command}"
         if platform.system() == "Windows":
-            command = f". activate_ve {args.ve}\n\n{command}"
+            command = f". $HOME/scripts/activate_ve {args.ve}\n\n{command}"
         else:
-            command = f". ~/scripts/activate_ve {args.ve}\n\n{command}"
+            command = f". $HOME/scripts/activate_ve {args.ve}\n\n{command}"
     else:
         # CMD equivalent
         if "ipdb" in command: command = f"pip install ipdb & {command}"
@@ -195,20 +218,22 @@ except ImportError as _ex:
 
     if args.submit_to_cloud:
         command = f"""
-. activate_ve {args.ve}
+. $HOME/scripts/activate_ve {args.ve}
 python -m crocodile.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 + f"\n" + f". {PROGRAM_PATH}"
+        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", ". ~/scripts/activate_ve")
+        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 = P.tmpfile(suffix=".sh").write_text(sub_command)
             lines.append(f"""zellij action new-pane -- bash {sub_command_path}  """)
             lines.append("sleep 1")  # python tends to freeze if you launch instances within 1 microsecond of each other
@@ -216,9 +241,17 @@ python -m crocodile.cluster.templates.cli_click --file {choice_file} """
 
     # TODO: send this command to terminal history. In powershell & bash there is no way to do it with a command other than goiing to history file. In Mcfly there is a way but its linux only tool. # if platform.system() == "Windows": command = f" ({command}) | Add-History  -PassThru "
     # mcfly add --exit 0 command
-    print(f"🔥 command:\n{command}\n\n")
+    if args.optimized:
+        # note that in ipython, optimization is meaningless.
+        command = command.replace("python ", "python -OO ")
     # if platform.system() == "Linux":
     #     command = "timeout 1s aafire -driver slang\nclear\n" + command
+
+    from rich.panel import Panel
+    from rich.console import Console
+    from rich.syntax import Syntax
+    console = Console()
+    console.print(Panel(Syntax(command, lexer="shell"), title=f"🔥 fire command @ {PROGRAM_PATH}: "), style="bold red")
     PROGRAM_PATH.write_text(command)
 
 
@@ -290,7 +323,8 @@ def interactively_run_function(func: Callable[[Any], Any]):
             if value == "": value = default
         else: value = input(f"Please enter a value for argument `{param.name}` (type = {hint}) : ")
         try:
-            if param.annotation is not inspect.Parameter.empty: value = param.annotation(value)
+            if param.annotation is not inspect.Parameter.empty:
+                value = param.annotation
         except (TypeError, ValueError) as err:
             raise ValueError(f"Invalid input: {value} is not of type {param.annotation}") from err
         if param.kind == inspect.Parameter.KEYWORD_ONLY: kwargs[param.name] = value
@@ -315,7 +349,7 @@ def run_on_remote(func_file: str, args: argparse.Namespace):
 
 def find_repo_root_path(start_path: str) -> Optional[str]:
     root_files = ['setup.py', 'pyproject.toml', '.git']
-    path: str = start_path
+    path: str=start_path
     trials = 0
     root_path = os.path.abspath(os.sep)
     while path != root_path and trials < 20:

machineconfig/scripts/python/gh_models.py

@@ -0,0 +1,53 @@
+
+# as per https://github.com/marketplace/models/azure-openai/o1-preview
+from openai import OpenAI
+from crocodile.file_management import Read, P
+
+
+gh_token = Read.ini(P.home().joinpath("dotfiles/creds/git/git_host_tokens.ini"))['thisismygitrepo']['newLongterm']
+endpoint = "https://models.inference.ai.azure.com"
+model_name_preferences = ["o1-preview", "o1-mini", "GPT-4o", "GPT-4-o-mini"]
+client__ = OpenAI(
+    base_url=endpoint,
+    api_key=gh_token,
+)
+
+def get_response(client, model_name, messages):
+    try:
+        response = client.chat.completions.create(
+            messages=messages,
+            model=model_name
+        )
+        return response.choices
+    except Exception as e:
+        print(f"Error with model {model_name}: {e}")
+        return None
+
+
+def interactive_chat():
+    conversation_history = []
+    model_index = 0
+    model_name = model_name_preferences[model_index]
+    while True:
+        print(f"Using model {model_name}".center(80, "="))
+        while True:
+            user_input = input("You: ")
+            conversation_history.append({"role": "user", "content": user_input})
+
+            while True:
+                choices = get_response(client__, model_name, conversation_history)
+                if choices is None:
+                    model_index += 1
+                    model_name = model_name_preferences[model_index % len(model_name_preferences)]
+                    print(f"Switching to model {model_name}".center(80, "="))
+                    continue
+                else:
+                    break
+
+            for a_choice in choices:
+                response_content = a_choice.message.content
+                print("\n" * 5)
+                print(f"AI: {response_content}")
+                conversation_history.append({"role": "assistant", "content": response_content})
+
+interactive_chat()

machineconfig/scripts/python/mount_nfs.py

@@ -11,7 +11,7 @@ import platform
 
 
 def main():
-    print(f"Mounting NFS Share ... ")
+    print("Mounting NFS Share ... ")
     share_info = input("share path? (e.g. machine:~/data/share_nfs) [press enter for interactive choice] = ")
     if share_info == "":
         tmp = choose_ssh_host(multi=False)

machineconfig/scripts/python/mount_nw_drive.py

@@ -6,15 +6,15 @@ import platform
 
 
 def main():
-    print(f"Welcome to the WindowsNetworkDrive Mounting Wizard")
+    print("Welcome to the WindowsNetworkDrive Mounting Wizard")
     drive_location = input("Enter the network drive location (ex: //192.168.1.100/Share): ")
     machine_name = drive_location.split("//")[1].split("/")[0]
     mount_point = input(f"Enter the mount point directory (ex: /mnt/network) [default: ~/data/mount_nw/{machine_name}]: ")
     if mount_point == "": mount_point = P.home().joinpath(fr"data/mount_nw/{machine_name}")
     else: mount_point = P(mount_point).expanduser()
 
-    username = input(f"Enter the username: ")
-    password = input(f"Enter the password: ")
+    username = input("Enter the username: ")
+    password = input("Enter the password: ")
     if platform.system() == "Linux":
         PROGRAM_PATH.write_text(f"""
 drive_location='{drive_location}'

machineconfig/scripts/python/mount_ssh.py

@@ -11,8 +11,7 @@ from machineconfig.utils.utils import PROGRAM_PATH, choose_ssh_host
 
 
 def main():
-
-    print(f"Mounting SSHFS ... ")
+    print("Mounting SSHFS ... ")
     share_info = input("share path? (e.g. user@host:/path) [press enter for interactive choice] = ")
     if share_info == "":
         tmp = choose_ssh_host(multi=False)
@@ -28,7 +27,7 @@ def main():
     if mount_point == "": mount_point = P.home().joinpath(fr"data/mount_ssh/{ssh.hostname}")
 
     if system() == "Linux":
-        txt = fr"""
+        txt = """
 sshfs alex@:/media/dbhdd /media/dbhdd\
 """
     elif system() == "Windows":

machineconfig/scripts/python/pomodoro.py

@@ -16,7 +16,7 @@ def pomodoro(work: int = 25, rest: int = 5, repeats: int = 4):
         while (diff := rest - ((datetime.now() - start).seconds / 60)) > 0: logger.critical(f"Keep Resting. Time Left: {round(diff)} minutes"); time.sleep(60 * 1)
     def speak(txt: str):
         install_n_import("gtts").gTTS(txt, lang='en', tld='com.au').save(tmp := P.tmpfile(suffix=".mp3")); time.sleep(0.5)
-        pyglet = install_n_import("pyglet"); pyglet.resource.path = [tmp.parent.str]; pyglet.resource.reindex(); pyglet.resource.media(tmp.name).play()
+        pyglet = install_n_import("pyglet"); pyglet.resource.path = [tmp.parent.to_str()]; pyglet.resource.reindex(); pyglet.resource.media(tmp.name).play()
     def beep(duration: int = 1, frequency: int = 3000):
         try: import winsound
         except ImportError: __import__("os").system(f'beep -f {frequency} -l {1000 * duration}')

machineconfig/scripts/python/repos.py

@@ -8,7 +8,7 @@ in the event that username@github.com is not mentioned in the remote url.
 
 from rich import print as pprint
 from machineconfig.utils.utils import write_shell_script, CONFIG_PATH, DEFAULTS_PATH
-from crocodile.file_management import P, install_n_import, Read, Save
+from crocodile.file_management import P, Read, Save
 from crocodile.core import randstr
 import argparse
 from dataclasses import dataclass
@@ -31,7 +31,7 @@ class RepoRecord:
     version: dict[str, str]
 
 
-def git_action(path: P, action: GitAction, mess: Optional[str] = None, r: bool = False) -> str:
+def git_action(path: P, action: GitAction, mess: Optional[str] = None, r: bool=False) -> str:
     from git.exc import InvalidGitRepositoryError
     from git.repo import Repo
     try:
@@ -57,7 +57,7 @@ git add .; git commit -am "{mess}"
         action_name = "pull" if action == GitAction.pull else "push"
         cmds = [f'echo "pulling from {remote.url}" ; git {action_name} {remote.name} {repo.active_branch.name}' for remote in repo.remotes]
         program += '\n' + '\n'.join(cmds) + '\n'
-    program = program + f'''
+    program = program + '''
 echo ""; echo ""
 '''
     return program
@@ -68,41 +68,40 @@ def main():
     # POSITIONAL
     parser.add_argument("directory", help="folder containing repos to record a json out of OR a specs json file to follow.", default="")
     # FLAGS
-    parser.add_argument("--push", help=f"push", action="store_true")
-    parser.add_argument("--pull", help=f"pull", action="store_true")
-    parser.add_argument("--commit", help=f"commit", action="store_true")
-    parser.add_argument("--all", help=f"pull, commit and push", action="store_true")
-    parser.add_argument("--record", help=f"record respos", action="store_true")
-    parser.add_argument("--clone", help=f"clone repos from record", action="store_true")
-    parser.add_argument("--checkout", help=f"Check out to versions prvided in this json file", action="store_true")
+    parser.add_argument("--push", help="push", action="store_true")
+    parser.add_argument("--pull", help="pull", action="store_true")
+    parser.add_argument("--commit", help="commit", action="store_true")
+    parser.add_argument("--all", help="pull, commit and push", action="store_true")
+    parser.add_argument("--record", help="record respos", action="store_true")
+    parser.add_argument("--clone", help="clone repos from record", action="store_true")
+    parser.add_argument("--checkout", help="Check out to versions prvided in this json file", action="store_true")
     parser.add_argument("--checkout_to_branch", help="Checkout to the main branch", action="store_true")
-    parser.add_argument("--recursive", "-r", help=f"recursive flag", action="store_true")
+    parser.add_argument("--recursive", "-r", help="recursive flag", action="store_true")
     # OPTIONAL
-    parser.add_argument("--cloud", "-c", help=f"cloud", default=None)
+    parser.add_argument("--cloud", "-c", help="cloud", default=None)
     args = parser.parse_args()
 
     if args.directory == "": repos_root = P.home().joinpath("code")  # it is a positional argument, can never be empty.
     else: repos_root = P(args.directory).expanduser().absolute()
-    _ = install_n_import("git", "gitpython")
 
     program = ""
     if args.record:
         res = record_repos(repos_root=str(repos_root))
-        pprint(f"Recorded repositories:\n", res)
+        pprint("Recorded repositories:\n", res)
         save_path = CONFIG_PATH.joinpath("repos").joinpath(repos_root.rel2home()).joinpath("repos.json")
         # Save.pickle(obj=res, path=save_path)
-        Save.json(obj=res, path=save_path)
+        Save.json(obj=res, path=save_path, indent=4)
         pprint(f"Result pickled at {P(save_path)}")
         if args.cloud is not None: P(save_path).to_cloud(rel2home=True, cloud=args.cloud)
-        program += f"""\necho '>>>>>>>>> Finished Recording'\n"""
+        program += """\necho '>>>>>>>>> Finished Recording'\n"""
     elif args.clone or args.checkout or args.checkout_to_branch:
         # preferred_remote = input("Enter preferred remote to use (default: None): ") or ""
-        program += f"""\necho '>>>>>>>>> Cloning Repos'\n"""
+        program += """\necho '>>>>>>>>> Cloning Repos'\n"""
         if not repos_root.exists() or repos_root.stem != 'repos.json':  # user didn't pass absolute path to pickle file, but rather expected it to be in the default save location
             repos_root = CONFIG_PATH.joinpath("repos").joinpath(repos_root.rel2home()).joinpath("repos.json")
             if not repos_root.exists():
                 if args.cloud is None:
-                    cloud: str = Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
+                    cloud: str=Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
                     print(f"⚠️ Using default cloud: {cloud}")
                 else:
                     cloud = args.cloud
@@ -122,7 +121,7 @@ def main():
     write_shell_script(program, "Script to update repos")
 
 
-def record_repos(repos_root: str, r: bool = True) -> list[dict[str, Any]]:
+def record_repos(repos_root: str, r: bool=True) -> list[dict[str, Any]]:
     path_obj = P(repos_root).expanduser().absolute()
     if path_obj.is_file(): return []
     search_res = path_obj.search("*", files=False)
@@ -135,7 +134,7 @@ def record_repos(repos_root: str, r: bool = True) -> list[dict[str, Any]]:
     return res
 
 
-def record_a_repo(path: P, search_parent_directories: bool = False, preferred_remote: Optional[str] = None):
+def record_a_repo(path: P, search_parent_directories: bool=False, preferred_remote: Optional[str] = None):
     from git.repo import Repo
     repo = Repo(path, search_parent_directories=search_parent_directories)  # get list of remotes using git python
     repo_root = P(repo.working_dir).absolute()
@@ -160,7 +159,7 @@ def record_a_repo(path: P, search_parent_directories: bool = False, preferred_re
     return res
 
 
-def install_repos(specs_path: str, clone: bool = True, checkout_to_recorded_commit: bool = False, checkout_to_branch: bool = False, editable_install: bool = False, preferred_remote: Optional[str] = None):
+def install_repos(specs_path: str, clone: bool=True, checkout_to_recorded_commit: bool=False, checkout_to_branch: bool=False, editable_install: bool=False, preferred_remote: Optional[str] = None):
     program = ""
     path_obj = P(specs_path).expanduser().absolute()
     repos: list[dict[str, Any]] = Read.json(path_obj)
@@ -189,7 +188,7 @@ def install_repos(specs_path: str, clone: bool = True, checkout_to_recorded_comm
                 program += f"\ncd {parent_dir.collapseuser().as_posix()}/{repo['name']}; git checkout {repo['current_branch']}"
                 break
             if editable_install and idx == 0:
-                program += f"\ncd {parent_dir.collapseuser().as_posix()}/{repo['name']}; pip install -e ."
+                program += f"\ncd {parent_dir.collapseuser().as_posix()}/{repo['name']}; uv pip install -e ."
         program += "\n"
     pprint(program)
     return program