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

machineconfig/__init__.py

@@ -2,7 +2,9 @@
 """DS
 """
 
-__version__ = "1.7"
+__version__ = "1.9"
 release_notes = """
-enhanced cli
+
+imporoved installer
+
 """

machineconfig/jobs/python/check_installations.py

@@ -2,7 +2,7 @@
 """CI
 """
 
-import crocodile.toolbox as tb
+
 import time
 import pandas as pd
 import platform
@@ -10,18 +10,21 @@ from rich.console import Console
 # from rich.progress import track
 from machineconfig.utils.utils import LIBRARY_ROOT, INSTALL_VERSION_ROOT
 from machineconfig.utils.installer import get_installed_cli_apps
+from crocodile.core import List as L, install_n_import, Struct
+from crocodile.file_management import P
+from crocodile.meta import Terminal
 from tqdm import tqdm
 from typing import Optional
 
 
 APP_SUMMARY_PATH = LIBRARY_ROOT.joinpath(f"profile/records/{platform.system().lower()}/apps_summary_report.csv")
-CLOUD: str = "gdw"  # tb.Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
+CLOUD: str = "gdw"  # Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
 # my onedrive doesn't allow sharing.
 
 
-def scan(path: tb.P, pct: float = 0.0):
-    vt = tb.install_n_import(library="vt", package="vt-py")
-    client = vt.Client(tb.P.home().joinpath("dotfiles/creds/tokens/virustotal").read_text().split("\n")[0])
+def scan(path: P, pct: float = 0.0):
+    vt = install_n_import(library="vt", package="vt-py")
+    client = vt.Client(P.home().joinpath("dotfiles/creds/tokens/virustotal").read_text().split("\n")[0])
     console = Console()
     console.rule(f"Scanning {path}. {pct:.2f}% done")
     if path.is_dir():
@@ -29,12 +32,11 @@ def scan(path: tb.P, pct: float = 0.0):
         return None
     with open(str(path), "rb") as f:
         analysis = client.scan_file(f)
-    repeat_counter = 0
+    repeat_counter: int = 0
     while True:
         with console.status(f"waiting for scan of {path} ... "):
             try:
                 anal = client.get_object("/analyses/{}", analysis.id)
-                # print(anal.status)
                 if anal.status == "completed": break
             except Exception as ex:  # type: ignore
                 repeat_counter += 1
@@ -42,33 +44,37 @@ def scan(path: tb.P, pct: float = 0.0):
                     raise ValueError(f"Error in scanning {path}") from ex
                 print(f"Error in scanning, trying again.")
             time.sleep(30)
-    df = pd.DataFrame(anal.results).T
+    df = pd.DataFrame(anal.results.values())
     malicious = []
     for _idx, row in df.iterrows():
+        # try:
+        #     print(row.result)
+        # except Exception as ex:  # type: ignore
+        #     print(row)
         if row.result is None and row.category in ["undetected", "type-unsupported", "failure", "timeout", "confirmed-timeout"]: continue
         else:
-            tb.Struct(row.to_dict()).print(as_config=True, title=f"Found Category {row.category}")
+            Struct(row.to_dict()).print(as_config=True, title=f"Found Category {row.category}")
             malicious.append(row)
-    positive_pct = round(len(malicious) / len(df) * 100, 1)
+    positive_pct: float = round(number=len(malicious) / len(df) * 100, ndigits=1)
     print(f"positive_ratio = {positive_pct:.1f} %")
     return positive_pct, df
 
 
 def main() -> None:
-    apps_paths_tmp: tb.List[tb.P] = get_installed_cli_apps()
-    versions_files_paths: tb.L[tb.P] = INSTALL_VERSION_ROOT.search()
+    apps_paths_tmp: L[P] = get_installed_cli_apps()
+    versions_files_paths: L[P] = INSTALL_VERSION_ROOT.search()
     app_versions: list[Optional[str]] = []
-    apps_paths_raw: tb.L[tb.P] = tb.L([])
-    for an_app in versions_files_paths:
-        exe_path = apps_paths_tmp.filter(lambda x: x.stem == an_app.stem)
-        if len(exe_path) == 1:
-            app_versions.append(an_app.read_text())
-            apps_paths_raw.append(exe_path.list[0])
+    apps_paths_raw: L[P] = L([])
+    for an_app in apps_paths_tmp:
+        version_path = versions_files_paths.filter(lambda x: x.stem == an_app.stem)
+        if len(version_path) == 1:
+            app_versions.append(version_path.list[0].read_text())
+            apps_paths_raw.append(an_app)
         # if an_app.stem in versions_files_paths.stem:
         #     app_versions.append(versions_files_paths.filter(lambda x: x.stem == an_app.stem.replace(".exe", "")).list[0].read_text())
         # else:
         #     print(f"🤔 Cloud not find a documented version for installation of {an_app.stem}, trying to get it from the app itself.")
-        #     tmp = tb.Terminal().run(f"{an_app.stem} --version", shell="powershell").capture().op_if_successfull_or_default(strict_err=False, strict_returcode=False)
+        #     tmp = Terminal().run(f"{an_app.stem} --version", shell="powershell").capture().op_if_successfull_or_default(strict_err=False, strict_returcode=False)
         #     if tmp is not None: tmp = tmp.split("\n")[0]
         #     print(f"➡️ Found version `{tmp}` for {an_app.stem}.")
         #     app_versions.append(None)
@@ -94,8 +100,8 @@ def main() -> None:
 
     app_url: list[Optional[str]] = []
     for idx, row in tqdm(res_df.iterrows(), total=res_df.shape[0]):
-        apps_safe_url = upload(tb.P(str(row["app_path"])).expanduser())
-        app_url.append(apps_safe_url.as_posix() if type(apps_safe_url) is tb.P else apps_safe_url)
+        apps_safe_url = upload(P(str(row["app_path"])).expanduser())
+        app_url.append(apps_safe_url.as_posix() if type(apps_safe_url) is P else apps_safe_url)
     res_df["app_url"] = app_url
     res_df.to_csv(APP_SUMMARY_PATH.with_suffix(".csv").create(parents_only=True), index=False)
     APP_SUMMARY_PATH.with_suffix(".md").write_text(res_df.to_markdown())
@@ -103,8 +109,8 @@ def main() -> None:
     print(res_df)
 
 
-def upload(path: tb.P):
-    set_time_out = tb.install_n_import("call_function_with_timeout").SetTimeout
+def upload(path: P):
+    set_time_out = install_n_import("call_function_with_timeout").SetTimeout
     func_with_timeout = set_time_out(lambda: path.to_cloud(CLOUD, rel2home=True, share=True, os_specific=True), timeout=180)
     is_done, _is_timeout, _erro_message, results = func_with_timeout()
     if is_done: return results
@@ -113,17 +119,17 @@ def upload(path: tb.P):
 
 class PrecheckedCloudInstaller:
     def __init__(self):
-        tb.install_n_import("gdown")
+        install_n_import("gdown")
         self.df = pd.read_csv(APP_SUMMARY_PATH)
 
     @staticmethod
     def download_google_links(url: str):
         # if "drive.google.com" in str(url): url = str(url).replace("open?", "uc?")
         # else: raise NotImplementedError("Only google drive is supported for now.")
-        # return tb.P(url).download(name=name)
-        gdrive_id = tb.P(url).parts[-1].split("id=")[1]
-        gdown = tb.install_n_import("gdown")
-        result = tb.P(gdown.download(id=gdrive_id)).absolute()
+        # return P(url).download(name=name)
+        gdrive_id = P(url).parts[-1].split("id=")[1]
+        gdown = install_n_import("gdown")
+        result = P(gdown.download(id=gdrive_id)).absolute()
         return result
 
     @staticmethod
@@ -134,10 +140,10 @@ class PrecheckedCloudInstaller:
             print(f"Error in downloading {app_url} {ex}")
             return None
         if platform.system().lower() == "linux":
-            tb.Terminal().run(f"chmod +x {exe}")
-            tb.Terminal().run(f"mv {exe} /usr/local/bin/")
+            Terminal().run(f"chmod +x {exe}")
+            Terminal().run(f"mv {exe} /usr/local/bin/")
         elif platform.system().lower() == "windows":
-            exe.move(folder=tb.P.home().joinpath("AppData/Local/Microsoft/WindowsApps"), overwrite=True)
+            exe.move(folder=P.home().joinpath("AppData/Local/Microsoft/WindowsApps"), overwrite=True)
         return True
 
     def download_safe_apps(self, name: str = "AllEssentials"):
@@ -152,7 +158,7 @@ class PrecheckedCloudInstaller:
         if name == "AllEssentials":
             print(f"Downloading {self.df.shape[0]} apps ...")
             print(self.df)
-            _res = tb.L(self.df.app_url).apply(PrecheckedCloudInstaller.install_cli_apps, jobs=20)
+            _res = L(self.df.app_url).apply(PrecheckedCloudInstaller.install_cli_apps, jobs=20)
         else:
             app_url = self.df[self.df.app_name == name].iloc[0].app_url
             _res = PrecheckedCloudInstaller.install_cli_apps(app_url=app_url)

machineconfig/jobs/python/create_bootable_media.py

@@ -1,13 +1,13 @@
 
 
-# import crocodile.toolbox as tb
+# 
 
 # # one can either install rufus: https://rufus.ie/en/
 # # however, to create bootable media with multiple OSs to choose from:
 
-# tb.P(r'https://github.com/ventoy/Ventoy/archive/refs/tags/v1.0.78.zip').download().unzip().search[0]()
-# tb.P(r'https://mirrors.layeronline.com/linuxmint/stable/21/linuxmint-21-cinnamon-64bit.iso').download(folder=tb.P.home().joinpath("Downloads/os").create())
-# tb.P(r'https://download.manjaro.org/kde/21.3.7/manjaro-kde-21.3.7-minimal-220816-linux515.iso').download(folder=tb.P.home().joinpath("Downloads/os").create())
+# P(r'https://github.com/ventoy/Ventoy/archive/refs/tags/v1.0.78.zip').download().unzip().search[0]()
+# P(r'https://mirrors.layeronline.com/linuxmint/stable/21/linuxmint-21-cinnamon-64bit.iso').download(folder=P.home().joinpath("Downloads/os").create())
+# P(r'https://download.manjaro.org/kde/21.3.7/manjaro-kde-21.3.7-minimal-220816-linux515.iso').download(folder=P.home().joinpath("Downloads/os").create())
 
 
 # if __name__ == '__main__':

machineconfig/jobs/python/create_zellij_template.py

@@ -1,9 +1,10 @@
 
 """ZT
 """
-import crocodile.toolbox as tb
+
 import socket
 from machineconfig.utils.utils import choose_ssh_host, write_shell_script
+from crocodile.file_management import P
 
 prefix = """
 
@@ -41,7 +42,7 @@ def build_template(tabs: list[str]):
     for t in tabs:
         res += tab.replace("TABNAME", t).replace("TABCOMMAND", f"ssh").replace("TABARGS", t)
     res += suffix.replace("THISMACHINE", socket.gethostname())
-    file = tb.P.tmp().joinpath(f"tmp_files/templates/zellij_template.kdl").create(parents_only=True).write_text(res)
+    file = P.tmp().joinpath(f"tmp_files/templates/zellij_template.kdl").create(parents_only=True).write_text(res)
     res = f"zellij --layout {file}"
     return res
 

machineconfig/jobs/python/python_cargo_build_share.py

@@ -1,5 +1,10 @@
 
-import crocodile.toolbox as tb
+"""
+cargo install
+"""
+
+from crocodile.meta import Terminal
+from crocodile.file_management import P
 import platform
 
 
@@ -18,22 +23,22 @@ cargo install --path .
 """
     print(f"Executing {script}")
     if platform.system() == "Windows":
-        tb.Terminal(stdout=None).run(f". {tb.P.tmpfile(suffix='.ps1').write_text(script)}", shell="pwsh").print()
+        Terminal(stdout=None).run(f". {P.tmpfile(suffix='.ps1').write_text(script)}", shell="pwsh").print()
     else:
-        tb.Terminal(stdout=None).run(script, shell="pwsh")
+        Terminal(stdout=None).run(script, shell="pwsh")
 
-    exe = tb.P.home().joinpath(f".cargo/bin/{tool_name}" + (".exe" if platform.system() == "Windows" else ""))
+    exe = P.home().joinpath(f".cargo/bin/{tool_name}" + (".exe" if platform.system() == "Windows" else ""))
 
     try:
-        tb.P.home().joinpath(tool_name).delete(sure=True)
+        P.home().joinpath(tool_name).delete(sure=True)
     except PermissionError:
-        print(f"PermissionError, couldn't delete: {tb.P.home().joinpath(tool_name)}")
+        print(f"PermissionError, couldn't delete: {P.home().joinpath(tool_name)}")
 
     if platform.system() == "Windows":
-        exe = exe.move(folder=tb.P.get_env().WindowsApps)
+        exe = exe.move(folder=P.get_env().WindowsApps)
     elif platform.system() == "Linux":
-        tb.Terminal().run(f"sudo mv {exe} /usr/local/bin")
-        exe = tb.P(r"/usr/local/bin").joinpath(exe.name)
+        Terminal().run(f"sudo mv {exe} /usr/local/bin")
+        exe = P(r"/usr/local/bin").joinpath(exe.name)
     else:
         raise NotImplementedError(f"Platform {platform.system()} not supported.")
     share_link = exe.to_cloud("gdpo", share=True)

machineconfig/jobs/python/python_ve_symlink.py

@@ -2,16 +2,16 @@
 """Symlinks
 """
 
-import crocodile.toolbox as tb
+from crocodile.file_management import P
 # from machineconfig.utils.utils import display_options
 
 
 def main():
-    target = tb.P(input("Symlink to which target? ")).expanduser().absolute()
-    source = input(f"symlink from which source ? [default to: CWD/{target.name}] ") or tb.P.cwd().joinpath(target.name)
-    if isinstance(source, str): source = tb.P(source).expanduser().absolute()
-    # ve_path = display_options(msg="symlin link? ", options=tb.P.home().joinpath("ve").starget.symlink_toimport crocodile.toolbox as tb; tb.P(r'$pwd').joinpath('venv').symlink_to(r'$to'); tb.P('.gitignore').modify_text('venv', 'venv', replace_line=True)"(target.symlink_to(
-    # tb.P('.gitignore').modify_text('venv', 'venv', replace_line=True)"
+    target = P(input("Symlink to which target? ")).expanduser().absolute()
+    source = input(f"symlink from which source ? [default to: CWD/{target.name}] ") or P.cwd().joinpath(target.name)
+    if isinstance(source, str): source = P(source).expanduser().absolute()
+    # ve_path = display_options(msg="symlin link? ", options=P.home().joinpath("ve").starget.symlink_to; P(r'$pwd').joinpath('venv').symlink_to(r'$to'); P('.gitignore').modify_text('venv', 'venv', replace_line=True)"(target.symlink_to(
+    # P('.gitignore').modify_text('venv', 'venv', replace_line=True)"
     source.symlink_to(target, overwrite=True)
     return "echo '😁 Finished creating symlink.'"
 

machineconfig/jobs/python_custom_installers/azuredatastudio.py

@@ -0,0 +1,36 @@
+
+"""
+custom installer for azuredatastudio
+"""
+
+from typing import Optional
+import platform
+
+config_dict = {
+        "repo_url": "CUSTOM",
+        "doc": "Azure Data Studio is a data management tool that enables working with SQL Server, Azure SQL DB and SQL DW from Windows, macOS and Linux.",
+        "filename_template_windows_amd_64": "AzureDataStudio-{}.exe",
+        "filename_template_linux_amd_64": "azuredatastudio-{}.deb",
+        "strip_v": True,
+        "exe_name": "azuredatastudio"
+    }
+
+
+def main(version: Optional[str] = None):
+    _ = version
+    if platform.system() == "Linux": return f"""
+
+cd ~/Downloads
+curl https://azuredatastudio-update.azurewebsites.net/latest/linux-x64/stable -o ./azuredatastudio-linux-x64.tar.gz
+tar -xvf ./azuredatastudio-linux-x64.tar.gz
+echo 'export PATH="$PATH:~/azuredatastudio-linux-x64"' >> ~/.bashrc
+source ~/.bashrc
+
+"""
+    elif platform.system() == "Windows": return "winget install -e --id Microsoft.AzureDataStudio"
+    else:
+        raise NotImplementedError(f"Your platform {platform.system()} is not supported!")
+
+
+if __name__ == '__main__':
+    pass

machineconfig/jobs/python_custom_installers/bypass_paywall.py

@@ -0,0 +1,30 @@
+
+# import numpy as np
+# import matplotlib.pyplot as plt
+
+# from platform import system
+from typing import Optional
+from crocodile.file_management import P
+
+
+config_dict = {
+        "repo_url": "CUSTOM",
+        "doc": """Plugin for chrome to bypass paywalls""",
+        "filename_template_windows_amd_64": "VSCodeSetup-{}.exe",
+        "filename_template_linux_amd_64": "code_{}.deb",
+        "strip_v": True,
+        "exe_name": "code"
+    }
+
+
+def main(version: Optional[str] = None):
+    _ = version
+    # see remove paywalls and enhance YT experience by Chris Titus
+    folder = r"C:\\"
+    P("https://github.com/iamadamdev/bypass-paywalls-chrome/archive/master.zip").download().unzip(folder=folder, content=True)
+    P(folder).joinpath("bypass-paywalls-chrome-master")
+    return ""
+
+
+if __name__ == '__main__':
+    pass

machineconfig/jobs/{python_linux_installers/dev → python_custom_installers}/docker_desktop.py

@@ -1,6 +1,8 @@
 
+"""
+Installer
+"""
 # from machineconfig.utils.installer import get_latest_release
-# import crocodile.toolbox as tb
 # from crocodile.meta import Terminal
 from typing import Optional
 
@@ -11,10 +13,19 @@ from typing import Optional
 
 # url = r"https://github.com/koute/bytehound"
 # fname = r"bytehound-x86_64-unknown-linux-gnu.tgz"
-__doc__ = """Docker Desltop for Ubuntu as per https://docs.docker.com/desktop/install/ubuntu/"""
 
 
-def main(version: Optional[str] = None):
+config_dict = {
+    "repo_url": "CUSTOM",
+    "doc": """Docker Desltop for Ubuntu as per https://docs.docker.com/desktop/install/ubuntu/""",
+    "filename_template_windows_amd_64": "gh_{}_windows_amd64.zip",
+    "filename_template_linux_amd_64": "gh_{}_linux_amd64.tar.gz",
+    "strip_v": True,
+    "exe_name": "gh"
+}
+
+
+def main(version: Optional[str]):
     _ = version
     code = """
 # Add Docker's official GPG key:
@@ -38,4 +49,4 @@ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin
 
 
 if __name__ == '__main__':
-    main()
+    pass

machineconfig/jobs/python_custom_installers/gh.py

@@ -0,0 +1,53 @@
+
+"""gh-cli installer
+"""
+
+import platform
+from typing import Optional
+from machineconfig.utils.installer import Installer
+from crocodile.meta import Terminal
+
+r"""
+https://github.com/cli/cli
+
+# as per https://docs.github.com/en/copilot/github-copilot-in-the-cli/using-github-copilot-in-the-cli
+# gh auth login
+# gh extension install github/gh-copilot
+
+# & 'C:\Program Files\GitHub CLI\gh.exe' extension install github/gh-copilot
+# & 'C:\Program Files\GitHub CLI\gh.exe' extension install auth login
+
+"""
+
+config_dict = {
+    "repo_url": "https://github.com/cli/cli",
+    "doc": "GitHub CLI",
+    "filename_template_windows_amd_64": "gh_{}_windows_amd64.zip",
+    "filename_template_linux_amd_64": "gh_{}_linux_amd64.tar.gz",
+    "strip_v": True,
+    "exe_name": "gh"
+}
+
+
+def main(version: Optional[str]):
+    _ = version
+    inst = Installer.from_dict(d=config_dict, name="gh")
+    inst.install(version=version)
+    if platform.system() == "Windows":
+        program = "gh extension install github/gh-copilot"
+    elif platform.system() == "Linux":
+        program = """
+gh extension install github/gh-copilot
+"""
+    else:
+        raise NotImplementedError("unsupported platform")
+
+    program += """
+gh auth login --with-token $HOME/dotfiles/creds/git/gh_token.txt
+"""
+    Terminal().run(program, shell="default").print(desc="installing gh-copilot extension", capture=True)
+    return program
+
+
+if __name__ == "__main__":
+    pass

machineconfig/jobs/python_custom_installers/goes.py

@@ -0,0 +1,35 @@
+
+"""
+natural language to API
+https://github.com/ShishirPatil/gorilla
+"""
+
+from machineconfig.utils.ve import get_ve_install_script
+# import subprocess
+
+config_dict = {
+        "repo_url": "CUSTOM",
+        "doc": "natural language to API",
+        "filename_template_windows_amd_64": "ngrok-stable-windows-amd64.zip",
+        "filename_template_linux_amd_64": "ngrok-stable-linux-amd64.zip",
+        "strip_v": False,
+        "exe_name": "ngrok"
+    }
+
+ve_name = "goex"
+
+
+def main():
+    install_script = get_ve_install_script(ve_name=ve_name, py_version="3.11", install_crocodile_and_machineconfig=False,
+                                        delete_if_exists=True, system=None)
+
+
+    install_script += f"""
+
+    . activate_ve {ve_name}
+    cd ~/code/foreign
+    git clone https://github.com/ShishirPatil/gorilla --depth 1
+    cd gorilla/goex
+    pip install -e .
+
+    """

machineconfig/jobs/python_custom_installers/helix.py

@@ -0,0 +1,43 @@
+
+"""
+Installers do not add runtime files to the machine, hence this script.
+"""
+
+# from pathlib import Path
+from machineconfig.utils.installer import Installer, LINUX_INSTALL_PATH, WINDOWS_INSTALL_PATH
+from typing import Optional
+import platform
+
+
+config_dict = {
+        "repo_url": "https://github.com/helix-editor/helix",
+        "doc": "Helix is a post-modern modal text editor.",
+        "filename_template_windows_amd_64": "helix-{}-x86_64-windows.zip",
+        "filename_template_linux_amd_64": "helix-{}-x86_64-linux.tar.xz",
+        "strip_v": False,
+        "exe_name": "hx"
+    }
+
+
+def main(version: Optional[str]):
+    inst = Installer.from_dict(d=config_dict, name="hx")
+    downloaded, _version_to_be_installed = inst.download(version=version)
+    hx_file_search = downloaded.search("hx", folders=False, files=True, r=True)
+    assert len(hx_file_search) == 1
+    hx_file = hx_file_search.list[0]
+    contrib = hx_file.parent / "contrib"
+    runtime = contrib.parent / "runtime"
+    assert runtime.exists()
+    assert contrib.exists()
+    if platform.system() == "Linux":
+        hx_file.move(folder=LINUX_INSTALL_PATH)
+        contrib.move(folder="~/.config/helix")
+        runtime.move(folder="~/.config/helix")
+    elif platform.system() == "Windows":
+        hx_file.move(folder=WINDOWS_INSTALL_PATH)
+        contrib.move(folder="~/.config/helix")
+        runtime.move(folder="~/.config/helix")
+
+
+if __name__ == "__main__":
+    main(version=None)

machineconfig/jobs/python_custom_installers/lvim.py

@@ -0,0 +1,48 @@
+
+"""lvim
+"""
+
+from crocodile.meta import Terminal
+import subprocess
+import platform
+from typing import Optional
+
+
+_ = Terminal, subprocess
+# as per https://www.lunarvim.org/docs/installation
+
+
+config_dict = {
+        "repo_url": "CUSTOM",
+        "doc": "Terminal text editor based on neovim.",
+        "filename_template_windows_amd_64": "",
+        "filename_template_linux_amd_64": "",
+        "strip_v": False,
+        "exe_name": "lvim"
+    }
+
+
+def main(version: Optional[str]):
+    _ = version
+    if platform.system() == "Windows":
+        program = """
+
+pwsh -c "`$LV_BRANCH='release-1.4/neovim-0.9'; iwr https://raw.githubusercontent.com/LunarVim/LunarVim/release-1.4/neovim-0.9/utils/installer/install.ps1 -UseBasicParsing | iex"
+
+"""
+    elif platform.system() == "Linux":
+        program = """
+
+LV_BRANCH='release-1.4/neovim-0.9' bash <(curl -s https://raw.githubusercontent.com/LunarVim/LunarVim/release-1.4/neovim-0.9/utils/installer/install.sh)
+
+"""
+    else:
+        raise NotImplementedError("unsupported platform")
+    # _res = Terminal(stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE).run_script(script=program, shell="default").print(desc="Running custom installer", capture=True)
+    # run script here as it requires user input
+    _ = program
+    return ""
+
+
+if __name__ == "__main__":
+    pass

machineconfig/jobs/python_custom_installers/ngrok.py

@@ -0,0 +1,39 @@
+
+"""ngrok
+"""
+
+import platform
+from typing import Optional
+
+
+config_dict = {
+        "repo_url": "CUSTOM",
+        "doc": "ngrok secure introspectable tunnels to localhost",
+        "filename_template_windows_amd_64": "ngrok-stable-windows-amd64.zip",
+        "filename_template_linux_amd_64": "ngrok-stable-linux-amd64.zip",
+        "strip_v": False,
+        "exe_name": "ngrok"
+    }
+
+
+def main(version: Optional[str]):
+    _ = version
+    if platform.system() == "Windows":
+        program = "winget install ngrok.ngrok --source winget"
+    elif platform.system() == "Linux":
+        # as per https://ngrok.com/docs/getting-started/?os=linux
+        program = """
+
+curl -s https://ngrok-agent.s3.amazonaws.com/ngrok.asc | \
+sudo tee /etc/apt/trusted.gpg.d/ngrok.asc >/dev/null && \
+echo "deb https://ngrok-agent.s3.amazonaws.com buster main" | \
+sudo tee /etc/apt/sources.list.d/ngrok.list && \
+sudo apt update && sudo apt install ngrok
+"""
+    else:
+        raise NotImplementedError("unsupported platform")
+    return program
+
+
+if __name__ == "__main__":
+    pass

machineconfig/jobs/python_custom_installers/nvim.py

@@ -0,0 +1,48 @@
+
+
+
+"""nvim
+"""
+
+
+import platform
+from typing import Optional
+
+
+config_dict = {
+        "repo_url": "CUSTOM",
+        "doc": "Neovim",
+        "filename_template_windows_amd_64": "nvim-win64.zip",
+        "filename_template_linux_amd_64": "nvim-linux64.tar.gz",
+        "strip_v": False,
+        "exe_name": "nvim"
+}
+
+
+def main(version: Optional[str]):
+    _ = version
+    if platform.system() == "Windows":
+        program = """
+winget install --no-upgrade --name "Neovim" --Id Neovim.Neovim --source winget --accept-package-agreements --accept-source-agreements
+"""
+    elif platform.system() == "Linux":
+        program = """
+# mkdir $HOME/tmp_install -p || true
+# mkdir $HOME/.local/share -p || true
+# cd $HOME/tmp_install || true
+# wget https://github.com/neovim/neovim/releases/download/stable/nvim-linux64.tar.gz || true
+# tar -xvf nvim-linux64.tar.gz  -C $HOME/.local/share/ || true
+# sudo cp ~/.local/share/nvim-linux64/bin/nvim /usr/local/bin/nvim || true
+brew install neovim
+# nix-env -iA nixpkgs.neovim
+"""
+        _ = program
+        program = ""
+    else:
+        raise NotImplementedError("unsupported platform")
+    return program
+
+
+if __name__ == "__main__":
+    print("Executed!")
+    pass