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

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
@@ -119,10 +118,10 @@ def main():
             if args.commit or args.all: program += git_action(a_path, action=GitAction.commit, r=args.recursive)
             if args.push or args.all: program += git_action(a_path, action=GitAction.push, r=args.recursive)
     else: program = "echo 'no action specified, try to pass --push, --pull, --commit or --all'"
-    write_shell_script(program, "Script to update repos")
+    write_shell_script(program=program, desc="Script to update repos", preserve_cwd=True)
 
 
-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

machineconfig/scripts/python/scheduler.py

@@ -45,7 +45,7 @@ def main_parse():
         print(f"✅ Task {task_name} created in {task_root}. Head there and edit the config.ini file & task.py file.")
         return None
 
-    main(root=root.str, ignore_conditions=args.ignore_conditions)
+    main(root=root.to_str(), ignore_conditions=args.ignore_conditions)
 
 
 if __name__ == "__main__":

machineconfig/scripts/python/start_slidev.py

@@ -16,7 +16,7 @@ PORT_DEFAULT = 3030
 SLIDEV_REPO = CONFIG_PATH.joinpath(".cache/slidev")
 if not SLIDEV_REPO.joinpath("components").exists():
     # assert slidev is installed first
-    Terminal(stderr=subprocess.PIPE, stdin=subprocess.PIPE, stdout=subprocess.PIPE).run(f"cd {SLIDEV_REPO.parent};npm init slidev")
+    Terminal(stderr=subprocess.PIPE, stdin=subprocess.PIPE, stdout=subprocess.PIPE).run(f"cd {SLIDEV_REPO.parent};npm init slidev@latest")
 
 
 def jupyter_to_markdown(file: P):
@@ -55,10 +55,11 @@ def main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument("-d", "--directory", default=None, help="Directory of the report")
     parser.add_argument("-j", "--jupyter-file", default=None, help="Jupyter notebook file to convert to slides. If not provided, slides.md is used.")
-    parser.add_argument("--port", default=PORT_DEFAULT, help=f"Port to serve the report, default to {PORT_DEFAULT}")
+    # parser.add_argument("--port", default=PORT_DEFAULT, help=f"Port to serve the report, default to {PORT_DEFAULT}")
     args = parser.parse_args()
 
-    port = args.port
+    # port = args.port
+    port = PORT_DEFAULT
 
     if args.jupyter_file is not None:
         report_dir = jupyter_to_markdown(P(args.jupyter_file))
@@ -89,15 +90,20 @@ def main() -> None:
     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
+        print("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"Presentation is served at http://{platform.node()}:{port}")
     print(f"Presentation is served at http://localhost:{port}")
     print(f"Presentation is served at http://{local_ip_v4}:{port}")
-    program: str = f"cd {SLIDEV_REPO}; slidev --port {port} --remote 0.0.0.0; cd {P.cwd()}"
+    # This version requires a globally installed cli of slidev, which is not recommended.
+    # program: str=f"cd {SLIDEV_REPO}; slidev --port {port} --remote 0.0.0.0; cd {P.cwd()}"
+
+    # The recommended approach is do `npm init slidev@latest` in the directory where you want to create the presentation
+    # Then you can do the following:
+    program = "npm run dev slides.md -- --remote"
     PROGRAM_PATH.write_text(program)
-    print_code(program, lexer="bash")
+    print_code(code=program, lexer="bash", desc="Run the following command to start the presentation")
 
 
 if __name__ == '__main__':

machineconfig/scripts/python/start_terminals.py

@@ -2,7 +2,7 @@
 """Script to start terminals on windows and wsl
 """
 
-from machineconfig.utils.utils import PROGRAM_PATH, display_options, install_n_import, get_ssh_hosts, platform
+from machineconfig.utils.utils import PROGRAM_PATH, display_options, get_ssh_hosts, platform
 from itertools import cycle
 from typing import Literal
 
@@ -22,14 +22,14 @@ THIS_MACHINE_HOSTNAME = platform.node()
 THIS_MACHINE_HOSTNAME_WSL = f"{THIS_MACHINE_HOSTNAME}wsl"
 
 
-def main_windows_and_wsl(window: int, hosts: list[str], orientation: ORIENTATION_TYPE = "vertical", mprocs: bool = False):
+def main_windows_and_wsl(window: int, hosts: list[str], orientation: ORIENTATION_TYPE = "vertical", mprocs: bool=False):
     orientation_oposite = "horizontal" if orientation == "vertical" else "vertical"
     orientation_swap                = "up" if orientation         == "horizontal" else "left"
     orientation_opposite_move_focus = "up" if orientation_oposite == "horizontal" else "left"
     orientation_opposite_move_focus_other = "down" if orientation_oposite == "horizontal" else "right"
     sleep = 3
     sep = f"\nsleep {sleep}; wt --window {window}"  # or '`;'
-    ssh_cmd = f"-t 'mprocs'" if mprocs else ''  # 'wsl_ssh_windows_port_forwarding.ps1'
+    ssh_cmd = "-t 'mprocs'" if mprocs else ''  # 'wsl_ssh_windows_port_forwarding.ps1'
     split_per_machine = 1 / len(hosts)
     size = 0.3
     known_hosts = get_ssh_hosts()
@@ -89,7 +89,8 @@ def main():
         cmd = main_windows_and_wsl(window=args.window, hosts=hosts, orientation="vertical" if args.vertical else "horizontal")
 
     print(cmd)
-    install_n_import("clipboard").copy(cmd)
+    # import clipboard
+    # install_n_import("clipboard").copy(cmd)
     PROGRAM_PATH.write_text(cmd)
 
 

machineconfig/scripts/python/wifi_conn.py

@@ -1,50 +1,44 @@
-
 """Wifi connect
+
+sudo apt-get install network-manager
+
 """
 
 import argparse
 import configparser
 from pathlib import Path
-# import random
-# import string
 import os
-
+import platform
+import subprocess
 
 def create_new_connection(name: str, ssid: str, password: str):
-    config = """<?xml version=\"1.0\"?>
-<WLANProfile xmlns="http://www.microsoft.com/networking/WLAN/profile/v1">
-    <name>""" + name + """</name>
-    <SSIDConfig>
-        <SSID>
-            <name>""" + ssid + """</name>
-        </SSID>
-    </SSIDConfig>
-    <connectionType>ESS</connectionType>
-    <connectionMode>auto</connectionMode>
-    <MSM>
-        <security>
-            <authEncryption>
-                <authentication>WPA2PSK</authentication>
-                <encryption>AES</encryption>
-                <useOneX>false</useOneX>
-            </authEncryption>
-            <sharedKey>
-                <keyType>passPhrase</keyType>
-                <protected>false</protected>
-                <keyMaterial>""" + password + """</keyMaterial>
-            </sharedKey>
-        </security>
-    </MSM>
-</WLANProfile>"""
-    command = "netsh wlan add profile filename=\"" + name + ".xml\"" + " interface=Wi-Fi"
-    with open(name + ".xml", mode='w', encoding="utf-8") as file: file.write(config)
-    os.system(command)
-
+    if platform.system() == "Windows":
+        config = """<?xml version=\"1.0\"?>
+        // ...existing XML config...
+        """
+        command = "netsh wlan add profile filename=\"" + name + ".xml\"" + " interface=Wi-Fi"
+        with open(name + ".xml", mode='w', encoding="utf-8") as file:
+            file.write(config)
+        os.system(command)
+    elif platform.system() == "Linux":
+        # Use nmcli to add/update connection
+        command = f"nmcli connection add type wifi con-name '{name}' ssid '{ssid}' wifi-sec.key-mgmt wpa-psk wifi-sec.psk '{password}'"
+        subprocess.run(command, shell=True, check=True)
 
 def connect(name: str, ssid: str):
-    command = "netsh wlan connect name=\"" + name + "\" ssid=\"" + ssid + "\" interface=Wi-Fi"
-    os.system(command)
-def display_available_networks(): os.system("netsh wlan show networks interface=Wi-Fi")  #
+    if platform.system() == "Windows":
+        command = "netsh wlan connect name=\"" + name + "\" ssid=\"" + ssid + "\" interface=Wi-Fi"
+        os.system(command)
+    elif platform.system() == "Linux":
+        command = f"nmcli connection up '{name}'"
+        subprocess.run(command, shell=True, check=True)
+
+
+def display_available_networks():
+    if platform.system() == "Windows":
+        os.system("netsh wlan show networks interface=Wi-Fi")
+    elif platform.system() == "Linux":
+        subprocess.run("nmcli device wifi list", shell=True, check=True)
 
 
 def main():
@@ -52,20 +46,18 @@ def main():
     creds.read(Path.home().joinpath('dotfiles/machineconfig/setup/wifi.ini'))
 
     parser = argparse.ArgumentParser(description='Wifi Connector')
-    parser.add_argument('-n', "--ssid", help=f"SSID of Wifi", default='MyPhoneHotSpot')
+    parser.add_argument('-n', "--ssid", help="SSID of Wifi", default='MyPhoneHotSpot')
 
     args = parser.parse_args()
     ssid = creds[args.ssid]['SSID']
-    # pwd = creds[args.ssid]['pwd']
+    password = creds[args.ssid]['pwd']  # You'll need the password for Linux connections
 
-    # displayAvailableNetworks()
-    # createNewConnection(name, name, password)
+    # Create and connect to the network
+    create_new_connection(ssid, ssid, password)
     connect(ssid, ssid)
 
 
 def get_current_wifi_name() -> str:
-    import subprocess
-    import platform
     if platform.system() == "Windows":
         try:
             cmd_output = subprocess.check_output(["netsh", "wlan", "show", "interface"], shell=True).decode("utf-8")

machineconfig/scripts/python/wsl_windows_transfer.py

@@ -28,7 +28,7 @@ Otherwise, a flag must be raised to indicate the direction.""")
     path = P(args.path).expanduser().absolute()
 
     if args.same_file_system:
-        print(f"💥 Using a not recommended transfer method! Copying same files across different file systems.")
+        print("💥 Using a not recommended transfer method! Copying same files across different file systems.")
         if system == "Windows":  # move files over to WSL
             path.copy(folder=WSL_FROM_WIN.joinpath(UserName).joinpath(path.rel2home().parent), overwrite=True)  # the following works for files and folders alike.
         else:  # move files from WSL to win

machineconfig/setup_windows/wt_and_pwsh/set_pwsh_theme.py

@@ -32,7 +32,7 @@ def install_nerd_fonts():
     folder.search("*readme*").apply(lambda p: p.delete(sure=True))
     folder.search("*LICENSE*").apply(lambda p: p.delete(sure=True))
     file = P.tmpfile(suffix=".ps1").write_text(LIBRARY_ROOT.joinpath("setup_windows/wt_and_pwsh/install_fonts.ps1").read_text().replace(r".\fonts-to-be-installed", str(folder)))
-    subprocess.run(rf"powershell.exe -executionpolicy Bypass -nologo -noninteractive -File {file.str}", check=True)
+    subprocess.run(rf"powershell.exe -executionpolicy Bypass -nologo -noninteractive -File {file.to_str()}", check=True)
     folder.delete(sure=True)
 
 

machineconfig/setup_windows/wt_and_pwsh/set_wt_settings.py

@@ -52,7 +52,7 @@ class TerminalSettings(object):
 
     # 1- Customizing Powershell========================================================
     # as opposed to Windows Powershell
-    def customize_powershell(self, nerd_font: bool = True):
+    def customize_powershell(self, nerd_font: bool=True):
         pwsh: dict[str, Any] = dict(name="PowerShell",
                                     commandline="pwsh",
                                     hidden=False,
@@ -65,7 +65,8 @@ class TerminalSettings(object):
             if item["name"] == "PowerShell":
                 self.profs.list[idx].update(pwsh)
                 break
-        else: print(f"Couldn't customize powershell because profile not found, try to install it first.")
+        else:
+            print("Couldn't customize powershell because profile not found, try to install it first.")
 
     def make_powershell_default_profile(self):
         for profile in self.profs:

machineconfig/utils/installer.py

@@ -3,22 +3,25 @@
 """
 from rich.console import Console
 
-from crocodile.file_management import P, List as L, Read, Struct
+from crocodile.file_management import P, List as L, Read
+from crocodile.core import Struct
 from crocodile.meta import Terminal
 from machineconfig.utils.utils import INSTALL_VERSION_ROOT, INSTALL_TMP_DIR, LIBRARY_ROOT, check_tool_exists
 
 # from dataclasses import dataclass
-from typing import Optional, Any
+from typing import Optional, Any, TypeAlias, Literal
 import platform
 # import os
 
 
-LINUX_INSTALL_PATH = '/usr/local/bin'
-WINDOWS_INSTALL_PATH = '~/AppData/Local/Microsoft/WindowsApps'
+# LINUX_INSTALL_PATH = '/usr/local/bin'
+LINUX_INSTALL_PATH = '~/.local/bin'
 
+WINDOWS_INSTALL_PATH = P.home().joinpath("AppData/Local/Microsoft/WindowsApps").__str__()
+CATEGORY: TypeAlias = Literal["OS_SPECIFIC", "OS_GENERIC", "CUSTOM", "OS_SPECIFIC_DEV", "OS_GENERIC_DEV", "CUSTOM_DEV"]
 
-def find_move_delete_windows(downloaded_file_path: P, exe_name: Optional[str] = None, delete: bool = True, rename_to: Optional[str] = None):
-    """Moves executable to {WINDOWS_INSTALL_PATH}"""
+
+def find_move_delete_windows(downloaded_file_path: P, exe_name: Optional[str] = None, delete: bool=True, rename_to: Optional[str] = None):
     if exe_name is not None and ".exe" in exe_name: exe_name = exe_name.replace(".exe", "")
     if downloaded_file_path.is_file():
         exe = downloaded_file_path
@@ -59,26 +62,30 @@ def find_move_delete_linux(downloaded: P, tool_name: str, delete: Optional[bool]
     print(f"MOVING file `{repr(exe)}` to '{LINUX_INSTALL_PATH}'")
     exe.chmod(0o777)
     # exe.move(folder=LINUX_INSTALL_PATH, overwrite=False)
-    Terminal().run(f"sudo mv {exe} {LINUX_INSTALL_PATH}/").print_if_unsuccessful(desc=f"MOVING executable `{exe}` to {LINUX_INSTALL_PATH}", strict_err=True, strict_returncode=True)
+    if "/usr" in LINUX_INSTALL_PATH:
+        Terminal().run(f"sudo mv {exe} {LINUX_INSTALL_PATH}/").print_if_unsuccessful(desc=f"MOVING executable `{exe}` to {LINUX_INSTALL_PATH}", strict_err=True, strict_returncode=True)
+    else:
+        exe.move(folder=LINUX_INSTALL_PATH, overwrite=True)
     if delete: downloaded.delete(sure=True)
     exe_new_location = P(LINUX_INSTALL_PATH).joinpath(exe.name)
     return exe_new_location
 
 
 class Installer:
-    def __init__(self, repo_url: str, name: str, doc: str, filename_template_windows_amd_64: str, filename_template_linux_amd_64: str, strip_v: bool, exe_name: str):
-        self.repo_url = repo_url
-        self.name = name
-        self.doc = doc
-        self.filename_template_windows_amd_64 = filename_template_windows_amd_64
-        self.filename_template_linux_amd_64 = filename_template_linux_amd_64
-        self.strip_v = strip_v
-        self.exe_name = exe_name
+    def __init__(self, repo_url: str, name: str, doc: str, filename_template_windows_amd_64: str, filename_template_linux_amd_64: str,
+                 strip_v: bool, exe_name: str):
+        self.repo_url: str=repo_url
+        self.name: str=name
+        self.doc: str=doc
+        self.filename_template_windows_amd_64: str=filename_template_windows_amd_64
+        self.filename_template_linux_amd_64: str=filename_template_linux_amd_64
+        self.strip_v: bool=strip_v
+        self.exe_name: str=exe_name
     def __repr__(self) -> str: return f"Installer of {self.repo_url}"
     def get_description(self):
         # old_version_cli = Terminal().run(f"{self.exe_name} --version").op.replace("\n", "")
         # old_version_cli = os.system(f"{self.exe_name} --version").replace("\n", "")
-        old_version_cli = check_tool_exists(tool_name=self.exe_name)
+        old_version_cli: bool=check_tool_exists(tool_name=self.exe_name)
         old_version_cli_str = "✅" if old_version_cli else "❌"
         # name_version = f"{self.exe_name} {old_version_cli_str}"
         return f"{self.exe_name:<12} {old_version_cli_str} {self.doc}"
@@ -102,34 +109,41 @@ class Installer:
 
     def install_robust(self, version: Optional[str]):
         try:
+
             old_version_cli = Terminal().run(f"{self.exe_name} --version").op.replace("\n", "")
             self.install(version=version)
             new_version_cli = Terminal().run(f"{self.exe_name} --version").op.replace("\n", "")
-            if old_version_cli == new_version_cli: return f"📦️ 😑 {self.exe_name}, same version: {old_version_cli}"
-            else: return f"📦️ 🤩 {self.exe_name} updated from {old_version_cli} === to ===> {new_version_cli}"
+
+            if old_version_cli == new_version_cli: return f"""echo "📦️ 😑 {self.exe_name}, same version: {old_version_cli}" """
+            else: return f"""echo "📦️ 🤩 {self.exe_name} updated from {old_version_cli} ➡️ TO ➡️  {new_version_cli}" """
+
         except Exception as ex:
             print(ex)
-            return f"📦️ Failed at {self.exe_name} with {ex}"
+            return f"""echo "📦️ Failed at `{self.name}` with {ex}" """
 
     def install(self, version: Optional[str]):
         if self.repo_url == "CUSTOM":
+
             import machineconfig.jobs.python_custom_installers as python_custom_installers
             installer_path = P(python_custom_installers.__file__).parent.joinpath(self.exe_name + ".py")
+            if not installer_path.exists():
+                installer_path = P(python_custom_installers.__file__).parent.joinpath("dev", self.exe_name + ".py")
+
             import runpy
-            program = runpy.run_path(str(installer_path), run_name=None)['main'](version=version)
-            Terminal().run_script(script=program, shell="default").print(desc="Running custom installer", capture=True)
+            print(f"Executing func `main` from `{installer_path}`to get the program to run")
+            program: str = runpy.run_path(str(installer_path), run_name=None)['main'](version=version)
+            # print(program)
+            Terminal(stdin=None, stdout=None, stderr=None).run_script(script=program, shell="default").print(desc="Running custom installer", capture=True)
             # import subprocess
             # subprocess.run(program, shell=True, check=True)
             version_to_be_installed = str(version)
-        elif "npm " in self.repo_url:
-            Terminal().run(self.repo_url, shell="default").print_if_unsuccessful(desc="npm install", strict_err=True, strict_returncode=True)
-            version_to_be_installed = "npmLatest"
-        elif "pip " in self.repo_url:
-            Terminal().run(self.repo_url, shell="default").print_if_unsuccessful(desc="pip install", strict_err=True, strict_returncode=True)
-            version_to_be_installed = "pipLatest"
+        elif "npm " in self.repo_url or "pip " in self.repo_url or "winget " in self.repo_url:
+            desc = self.repo_url.split(" ", maxsplit=1)[0] + "installation"
+            version_to_be_installed = self.repo_url.split(" ", maxsplit=1)[0] + "Latest"
+            Terminal().run(self.repo_url, shell="default").print_if_unsuccessful(desc=desc, strict_err=True, strict_returncode=True)
         else:
             downloaded, version_to_be_installed = self.download(version=version)
-            if downloaded.str.endswith(".deb"):
+            if downloaded.to_str().endswith(".deb"):
                 assert platform.system() == "Linux"
                 Terminal().run(f"sudo apt install -y {downloaded}").print_if_unsuccessful(desc="Installing .deb", strict_err=True, strict_returncode=True)
                 downloaded.delete(sure=True)
@@ -161,16 +175,17 @@ class Installer:
             else: raise NotImplementedError(f"📦️ System {platform.system()} not implemented")
             version_to_be_installed = "predefined_url"
         else:
-            release_url, version_to_be_installed = self.get_github_release(repo_url=self.repo_url, version=version)
+            release_url, version_to_be_installed = Installer.get_github_release(repo_url=self.repo_url, version=version)
             print(f"📦️ Version to be installed: {version_to_be_installed}")
             print(f"📦️ Release URL: {release_url}")
             version_to_be_installed_stripped = version_to_be_installed.replace("v", "") if self.strip_v else version_to_be_installed
+            version_to_be_installed_stripped = version_to_be_installed_stripped.replace("ipinfo-", "")
             if platform.system() == "Windows":
                 file_name = self.filename_template_windows_amd_64.format(version_to_be_installed_stripped)
             elif platform.system() == "Linux":
                 file_name = self.filename_template_linux_amd_64.format(version_to_be_installed_stripped)
             else: raise NotImplementedError(f"📦️ System {platform.system()} not implemented")
-            print(f"📦️ File name", file_name)
+            print("📦️ File name", file_name)
             download_link = release_url.joinpath(file_name)
         print(f"📦️ Downloading {self.name}: ", download_link.as_url_str())
         downloaded = download_link.download(folder=INSTALL_TMP_DIR).decompress()
@@ -262,36 +277,66 @@ def get_installed_cli_apps():
 
 
 def get_installers(system: str, dev: bool) -> list[Installer]:
+    res_all = get_all_dicts(system=system)
+    if not dev:
+        del res_all["CUSTOM_DEV"]
+        del res_all["OS_SPECIFIC_DEV"]
+        del res_all["OS_GENERIC_DEV"]
+    res_final = {}
+    for _k, v in res_all.items():
+        res_final.update(v)
+    return [Installer.from_dict(d=vd, name=k) for k, vd in res_final.items()]
+
+
+def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
     if system == "Windows": import machineconfig.jobs.python_windows_installers as os_specific_installer
     else: import machineconfig.jobs.python_linux_installers as os_specific_installer
+
     import machineconfig.jobs.python_generic_installers as generic_installer
     path_os_specific = P(os_specific_installer.__file__).parent
     path_os_generic = P(generic_installer.__file__).parent
+
+    path_os_specific_dev = path_os_specific.joinpath("dev")
+    path_os_generic_dev = path_os_generic.joinpath("dev")
+
+    res_final: dict[CATEGORY, dict[str, dict[str, Any]]] = {}
+    res_final["OS_SPECIFIC"] = Read.json(path=path_os_specific.joinpath("config.json"))
+    res_final["OS_GENERIC"] = Read.json(path=path_os_generic.joinpath("config.json"))
+    res_final["OS_SPECIFIC_DEV"] = Read.json(path=path_os_specific_dev.joinpath("config.json"))
+    res_final["OS_GENERIC_DEV"] = Read.json(path=path_os_generic_dev.joinpath("config.json"))
+
     path_custom_installer = path_os_generic.with_name("python_custom_installers")
-    if dev:
-        path_os_specific = path_os_specific.joinpath("dev")
-        path_os_generic = path_os_generic.joinpath("dev")
-    res1: dict[str, Any] = Read.json(path=path_os_specific.joinpath("config.json"))
-    res2: dict[str, Any] = Read.json(path=path_os_generic.joinpath("config.json"))
-    res2.update(res1)
+    path_custom_installer_dev = path_custom_installer.joinpath("dev")
+
     import runpy
-    for item in path_custom_installer.search("*.py", r=False):
+    res_custom: dict[str, dict[str, Any]] = {}
+    for item in path_custom_installer.search("*.py", r=False, not_in=["__init__"]):
+        try:
+            config_dict = runpy.run_path(str(item), run_name=None)['config_dict']
+            res_custom[item.stem] = config_dict
+        except Exception as ex:
+            print(f"Failed to load {item}: {ex}")
+
+    res_custom_dev: dict[str, dict[str, Any]] = {}
+    for item in path_custom_installer_dev.search("*.py", r=False, not_in=["__init__"]):
         try:
             config_dict = runpy.run_path(str(item), run_name=None)['config_dict']
-            res2[item.stem] = config_dict
+            res_custom_dev[item.stem] = config_dict
         except Exception as ex:
             print(f"Failed to load {item}: {ex}")
 
-    return [Installer.from_dict(d=vd, name=k) for k, vd in res2.items()]
+    res_final["CUSTOM"] = res_custom
+    res_final["CUSTOM_DEV"] = res_custom_dev
+    return res_final
 
 
-def install_all(installers: L[Installer], safe: bool = False, jobs: int = 10, fresh: bool = False):
+def install_all(installers: L[Installer], safe: bool=False, jobs: int = 10, fresh: bool=False):
     if fresh: INSTALL_VERSION_ROOT.delete(sure=True)
     if safe:
         from machineconfig.jobs.python.check_installations import APP_SUMMARY_PATH
         apps_dir = APP_SUMMARY_PATH.readit()
         if platform.system().lower() == "windows":
-            apps_dir.search("*").apply(lambda app: app.move(folder=P.get_env().WindowsApps))
+            apps_dir.search("*").apply(lambda app: app.move(folder=P.get_env().WindowsPaths().WindowsApps))
         elif platform.system().lower() == "linux":
             Terminal().run(f"sudo mv {apps_dir.as_posix()}/* {LINUX_INSTALL_PATH}/").print_if_unsuccessful(desc=f"MOVING executable to {LINUX_INSTALL_PATH}", strict_err=True, strict_returncode=True)
         else: raise NotImplementedError(f"I don't know this system {platform.system()}")

machineconfig/utils/procs.py

@@ -60,7 +60,7 @@ class ProcessManager:
             self.kill(pids=sub_df.pid.to_list())
             return
         kill_by_index = input("🔫 Kill by index? 1 4 ... /[n] ")
-        if kill_by_index != "":
+        if kill_by_index != "" and kill_by_index != "n":
             indices = [int(val) for val in kill_by_index.split(" ")]
             sub_sub_df = sub_df.iloc[indices]
             for idx2, row in sub_sub_df.iterrows():
@@ -93,7 +93,7 @@ class ProcessManager:
                 print(f'💀 Killed process with pid {pid} and name {proc.name()}.  It lived {get_age(proc.create_time())}. RIP 🪦💐')
             except psutil.NoSuchProcess: print(f'No process with pid {pid} found')
         for command in commands:
-            rows = self.df[self.df['command'].str.contains(command)]
+            rows = self.df[self.df['command'].to_str().contains(command)]
             if len(rows) > 0:
                 for _idx, a_row in rows.iterrows():
                     psutil.Process(a_row.pid).kill()