machineconfig 1.5__py3-none-any.whl → 1.8__py3-none-any.whl

machineconfig/__init__.py

@@ -1,5 +1,8 @@
-
-__version__ = "1.5"
-release_notes = """
-added gpt script
-"""
+
+"""DS
+"""
+
+__version__ = "1.8"
+release_notes = """
+enhanced ve management
+"""

machineconfig/jobs/python/check_installations.py

@@ -1,163 +1,173 @@
-
-import crocodile.toolbox as tb
-import time
-import pandas as pd
-import platform
-from rich.console import Console
-# from rich.progress import track
-from machineconfig.utils.utils import LIBRARY_ROOT
-from machineconfig.jobs.python.python_linux_installers_all import get_installed_cli_apps
-from tqdm import tqdm
-
-
-safe_apps_records = LIBRARY_ROOT.joinpath(f"profile/records/{platform.system().lower()}/safe_cli_apps.json")
-safe_apps_url = LIBRARY_ROOT.joinpath(f"profile/records/{platform.system().lower()}/safe_cli_apps_url.txt")
-cloud = "gdpo"
-
-
-def scan(path, pct=0.0):
-    vt = tb.install_n_import(package="vt", name="vt-py")
-    client = vt.Client(tb.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():
-        print(f"Skipping {path} as it is a directory.")
-        return None
-    with open(str(path), "rb") as f:
-        analysis = client.scan_file(f)
-
-    repeat_counter = 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:
-                repeat_counter += 1
-                if repeat_counter > 2:
-                    raise ValueError(f"Error in scanning {path}")
-                print(f"Error in scanning, trying again.")
-            time.sleep(30)
-
-    df = pd.DataFrame(anal.results).T
-    malicious = []
-    for idx, row in df.iterrows():
-        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}")
-            malicious.append(row)
-
-    positive_pct = len(malicious) / len(df) * 100
-    print(f"positive_ratio = {positive_pct:.1f} %")
-    return positive_pct
-
-
-def main():
-    apps_paths_raw = get_installed_cli_apps()
-
-    app_versions = []
-    versions = tb.P.home().joinpath(f"tmp_results/cli_tools_installers/versions").search()
-    for an_app in apps_paths_raw:
-        if an_app.stem in versions.stem: app_versions.append(versions.filter(lambda x: x.stem == an_app.stem.replace(".exe", ""))[0].read_text())
-        else: app_versions.append(None)
-
-    positive_pct = []
-    # for app in track(apps, description="App apps scanning..."):
-    for idx, app in enumerate(apps_paths_raw):
-        try: res = scan(app, idx/len(apps_paths_raw)*100)
-        except ValueError as ve:
-            print(ve)
-            res = None
-        positive_pct.append(res)
-
-    res_df = pd.DataFrame({"app_name": apps_paths_raw.stem.list, "version": app_versions, "positive_pct": positive_pct,
-                           "app_path": apps_paths_raw.apply(lambda x: x.collapseuser(strict=False).as_posix()).list})
-
-    apps_safe_df = res_df.query("positive_pct < 5")
-
-    app_url = []
-    for idx, row in tqdm(apps_safe_df.iterrows(), total=apps_safe_df.shape[0]):
-        apps_safe_url = upload(tb.P(row["app_path"]).expanduser())
-        app_url.append(apps_safe_url.as_posix() if type(apps_safe_url) == tb.P else apps_safe_url)
-    res_df["app_url"] = app_url
-
-    res_df.to_json(safe_apps_records.create(parents_only=True), index=False, orient='split')
-    share_url = safe_apps_records.to_cloud(cloud, rel2home=True, share=True)
-    safe_apps_url.write_text(share_url.as_posix())
-    print(res_df)
-
-
-def upload(path):
-    set_time_out = tb.install_n_import("call_function_with_timeout").SetTimeout
-    def func():
-        return path.to_cloud(cloud, rel2home=True, share=True)
-    func_with_timeout = set_time_out(func, timeout=180)
-    is_done, is_timeout, erro_message, results = func_with_timeout()
-    if is_done: return results
-    else: return None
-
-
-class PrecompliedInstaller:
-    @staticmethod
-    def download_rclone_links(url, name=None):
-        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)
-
-    def __init__(self, from_cloud=True):
-        if from_cloud:  file = PrecompliedInstaller.download_rclone_links(safe_apps_url.read_text(), name=safe_apps_records.name)
-        else: file = safe_apps_records
-        tmp = file.readit()
-        self.df = pd.DataFrame(tmp['data'], columns=tmp['columns'])
-
-    def install(self, name):
-        res = self.df.query(f"app == '{name}'")
-        if len(res) == 0 or len(res) > 1:
-            print(f"Couldn't find unique result when searching safe_apps_records @ {self.safe_apps_records}")
-            return None
-        tb.P(res.app_url).download()
-
-    def download_safe_apps(self):
-        if platform.system().lower() == "windows":
-            from machineconfig.jobs.python.python_windows_installers_all import get_cli_py_installers
-            cli_installers = get_cli_py_installers()
-        elif platform.system().lower() == "linux":
-            from machineconfig.jobs.python.python_linux_installers_all import get_cli_py_installers
-            cli_installers = get_cli_py_installers()
-        else: raise NotImplementedError(f"Platform {platform.system().lower()} is not supported yet.")
-
-        def install_cli_apps(row):
-            if row["app_url"] is None:
-                print(f"{row['app_name']} url is not available, trying to download from its sources:")
-                version = row["version"]
-                if version is None:
-                    print(f"Version is not available, either, I can't trust the latest version. Skipping installation of this program.")
-                    return False
-                else:
-                    tmp = cli_installers.filter(lambda x: x.stem == row["app_name"].replace(".exe", ""))
-                    if len(tmp) == 0:
-                        print(f"Can't find the installer for {row['app_name']}, skipping installation of this program.")
-                        return False
-                    else: tb.Read.py(tmp[0])["main"](version=version)
-            else:
-                name = row["app_name"]
-                if platform.system().lower() == "windows" and not name.endswith(".exe"): name += ".exe"
-                exe = self.download_rclone_links(row["app_url"], name=name)
-                if platform.system().lower() == "linux":
-                    tb.Terminal().run(f"chmod +x {exe}")
-                    tb.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)
-            return True
-
-        res = tb.L(self.df.iterrows()).apply(lambda x: install_cli_apps(x[1]), jobs=20)
-
-        print("\n"*3)
-        for item_flag, item_name in zip(res, self.df["app_name"]):
-            if item_flag: print(f"✅ {item_name} is installed. 😁")
-            else: print(f"❌ {item_name} failed to install for reasons explained in the log above, try manually.")
-
-
-if __name__ == '__main__':
-    pass
+
+"""CI
+"""
+
+
+import time
+import pandas as pd
+import platform
+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"  # Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
+# my onedrive doesn't allow sharing.
+
+
+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():
+        print(f"Skipping {path} as it is a directory.")
+        return None
+    with open(str(path), "rb") as f:
+        analysis = client.scan_file(f)
+    repeat_counter = 0
+    while True:
+        with console.status(f"waiting for scan of {path} ... "):
+            try:
+                anal = client.get_object("/analyses/{}", analysis.id)
+                if anal.status == "completed": break
+            except Exception as ex:  # type: ignore
+                repeat_counter += 1
+                if repeat_counter > 2:
+                    raise ValueError(f"Error in scanning {path}") from ex
+                print(f"Error in scanning, trying again.")
+            time.sleep(30)
+    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:
+            Struct(row.to_dict()).print(as_config=True, title=f"Found Category {row.category}")
+            malicious.append(row)
+    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: L[P] = get_installed_cli_apps()
+    versions_files_paths: L[P] = INSTALL_VERSION_ROOT.search()
+    app_versions: list[Optional[str]] = []
+    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 = 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)
+    print(f"Checking tools collected from `{INSTALL_VERSION_ROOT}`:")
+    apps_paths_raw.print()
+    positive_pct: list[Optional[float]] = []
+    detailed_results: list[dict[str, Optional[pd.DataFrame]]] = []
+    for idx, app in enumerate(apps_paths_raw):
+        try: res = scan(path=app, pct=idx / len(apps_paths_raw) * 100)
+        except ValueError as ve:
+            print(ve)
+            res = None
+        if res is None:
+            positive_pct.append(None)
+            detailed_results.append({app.stem: None})
+        else:
+            ppct, df = res
+            positive_pct.append(ppct)
+            detailed_results.append({app.stem: df})
+
+    res_df = pd.DataFrame({"app_name": apps_paths_raw.apply(lambda x: x.stem).list, "version": app_versions, "positive_pct": positive_pct,
+                                "app_path": apps_paths_raw.apply(lambda x: x.collapseuser(strict=False).as_posix()).list})
+
+    app_url: list[Optional[str]] = []
+    for idx, row in tqdm(res_df.iterrows(), total=res_df.shape[0]):
+        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())
+    print(f"Safety Report:")
+    print(res_df)
+
+
+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
+    else: return None
+
+
+class PrecheckedCloudInstaller:
+    def __init__(self):
+        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 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
+    def install_cli_apps(app_url: str):
+        try:
+            exe = PrecheckedCloudInstaller.download_google_links(app_url)
+        except Exception as ex:  # type: ignore
+            print(f"Error in downloading {app_url} {ex}")
+            return None
+        if platform.system().lower() == "linux":
+            Terminal().run(f"chmod +x {exe}")
+            Terminal().run(f"mv {exe} /usr/local/bin/")
+        elif platform.system().lower() == "windows":
+            exe.move(folder=P.home().joinpath("AppData/Local/Microsoft/WindowsApps"), overwrite=True)
+        return True
+
+    def download_safe_apps(self, name: str = "AllEssentials"):
+        # if platform.system().lower() == "windows":
+        #     from machineconfig.jobs.python.python_windows_installers_all import get_cli_py_installers
+        #     cli_installers = get_cli_py_installers()
+        # elif platform.system().lower() == "linux":
+        #     from machineconfig.jobs.python.python_linux_installers_all import get_cli_py_installers
+        #     cli_installers = get_cli_py_installers()
+        # else: raise NotImplementedError(f"Platform {platform.system().lower()} is not supported yet.")
+
+        if name == "AllEssentials":
+            print(f"Downloading {self.df.shape[0]} apps ...")
+            print(self.df)
+            _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)
+
+        # print("\n" * 3)
+        # for item_flag, item_name in zip(res, self.df["app_name"]):
+        #     if item_flag: print(f"✅ {item_name} is installed. 😁")
+        #     else: print(f"❌ {item_name} failed to install for reasons explained in the log above, try manually.")
+
+
+if __name__ == '__main__':
+    pass

machineconfig/jobs/python/checkout_version.py

@@ -0,0 +1,117 @@
+
+"""checkout_version.py
+"""
+
+from crocodile.file_management import P, Save, randstr
+from crocodile.meta import Terminal
+from machineconfig.utils.ve import get_ve_profile, get_ve_specs, get_ve_install_script
+from machineconfig.scripts.python.repos import record_a_repo, install_repos
+import platform
+
+
+# TODO: add data requirements for added isolation of file system.
+
+
+def checkout_version(version: str, repo_root: P, exclude_editable: bool = False):
+    """Checkout a version of the repo and install its requirements."""
+    ve_name = get_ve_profile(init_path=repo_root)
+    ve_path = P.home().joinpath("venvs", ve_name)
+    ve_specs = get_ve_specs(ve_path)
+    py_version = ve_specs['version_major_minor']
+    sys = platform.system().lower()
+
+    target_dir = repo_root.expanduser().absolute().joinpath(f"versions/{version}").as_posix()
+    if exclude_editable:
+        editable_json = get_editable_packages(ve_name=ve_name)
+        specs_path = P(target_dir).expanduser().joinpath("editable_packages.json")
+        Save.json(obj=editable_json, path=specs_path, indent=4)
+        install_editable_packages = install_repos(specs_path=str(specs_path), editable_install=True)
+    else: install_editable_packages = ""
+
+    version_root = repo_root.collapseuser().joinpath(f"versions/{version}").as_posix()
+    version_root_obj = P(version_root).expanduser().create()
+    checkout_ve = f"{repo_root.name}-{version}-prod" if not exclude_editable else ve_name
+    checkout_ve = input(f"Name of the ve to create (default: {checkout_ve}): ") or checkout_ve
+
+    ve_template = get_ve_install_script(ve_name=checkout_ve, py_version=py_version, system="Windows", delete_if_exists=False, install_crocodile_and_machineconfig=False)
+    version_root_obj.joinpath("install_ve.ps1").write_text(ve_template)
+    ve_template = get_ve_install_script(ve_name=checkout_ve, py_version=py_version, system="Linux", delete_if_exists=False, install_crocodile_and_machineconfig=False)
+    version_root_obj.joinpath("install_ve.sh").write_text(ve_template)
+
+    install_requirements = f"""
+. $HOME/scripts/activate_ve {ve_name}
+cd {version_root}
+pip install -r requirements_{sys}.txt
+{install_editable_packages}
+"""
+    if sys == "windows":
+        version_root_obj.joinpath("install_requirements.ps1").write_text(install_requirements)
+        if not version_root_obj.joinpath("install_requirements.sh").exists(): version_root_obj.joinpath("install_requirements.sh").write_text(install_requirements)
+    elif sys == "linux":
+        version_root_obj.joinpath("install_requirements.sh").write_text(install_requirements)
+        if not version_root_obj.joinpath("install_requirements.ps1").exists(): version_root_obj.joinpath("install_requirements.ps1").write_text(install_requirements)
+    else: raise NotImplementedError(f"System {sys} not supported.")
+
+    pip_freeze_script = f"""
+cd '{target_dir}'
+. "$HOME/scripts/activate_ve" {ve_name}
+python -m pip freeze {'--exclude-editable' if exclude_editable else ''} > requirements_{sys}.txt
+"""
+    Terminal().run_script(pip_freeze_script, verbose=True, shell="default").print()
+
+    install_all_script = r"""
+#!/usr/bin/bash
+
+CUR_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+. $CUR_DIR/install_ve.sh
+. $CUR_DIR/install_requirements.sh
+"""
+    version_root_obj.joinpath("install.sh").write_text(install_all_script)
+    install_all_script = r"""
+
+$CUR_DIR = Split-Path $MyInvocation.MyCommand.Path -Parent
+. $CUR_DIR/install_ve.ps1
+. $CUR_DIR/install_requirements.ps1
+
+"""
+    version_root_obj.joinpath("install.ps1").write_text(install_all_script)
+    print(f"✅ Installed requirements for version {version}.")
+
+
+def main():
+    from git.repo import Repo
+    from git.exc import InvalidGitRepositoryError
+    try:
+        repo = Repo(P.cwd(), search_parent_directories=True)
+        print(f"✅ Found repo at {repo.working_dir}")
+    except InvalidGitRepositoryError as err:
+        print(f"❌ No repo found at {P.cwd()} or its parents.")
+        raise err
+    version = input("Enter version name: ")
+    from rich.prompt import Confirm
+    exclude_editable = Confirm.ask("Exclude editable packages?", default=False)
+
+    repo_root = P(repo.working_dir)
+    checkout_version(version, repo_root, exclude_editable=exclude_editable)
+
+
+def get_editable_packages(ve_name: str):
+    file = P.tmp().joinpath(f"tmp_files/editable_requirements_{randstr()}.txt")
+    editable_packages_script = f"""
+. $HOME/scripts/activate_ve {ve_name}
+pip list --editable > {file}
+"""
+    Terminal().run_script(editable_packages_script, verbose=True, shell="default").print()
+    try: tmp3 = file.read_text(encoding='utf-16').splitlines()[2:]
+    except UnicodeError: tmp3 = file.read_text().splitlines()[2:]
+
+    res = []
+    for a_pkg in tmp3:
+        tmp = P(a_pkg.split(" ")[-1].rstrip())
+        tmp1 = record_a_repo(tmp, search_parent_directories=True)  # pip list --editable returns path to package or repo in a way not yet understood.
+        res.append(tmp1)
+    return res
+
+
+if __name__ == "__main__":
+    pass

machineconfig/jobs/python/create_bootable_media.py

@@ -1,14 +1,14 @@
-
-
-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().find()()
-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())
-
-
-if __name__ == '__main__':
-    pass
+
+
+# 
+
+# # one can either install rufus: https://rufus.ie/en/
+# # however, to create bootable media with multiple OSs to choose from:
+
+# 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__':
+#     pass

machineconfig/jobs/python/create_zellij_template.py

@@ -1,56 +1,59 @@
-
-import crocodile.toolbox as tb
-import socket
-from machineconfig.utils.utils import choose_ssh_host, write_shell_script
-
-prefix = """
-
-layout {
-    default_tab_template {
-        pane size=1 borderless=true {
-            plugin location="zellij:compact-bar"
-        }
-        children
-
-}
-    
-"""
-
-suffix = """
- 
-    tab name="THISMACHINE" focus=true // the default_tab_template
-}
-"""
-
-tab = """
-
-    tab name="TABNAME" focus=false { // the default_tab_template with three vertical panes between the plugins
-        pane name="fpane" {
-        command "TABCOMMAND"
-        args "TABARGS"
-        }
-}
-
-"""
-
-
-def build_template(tabs: list):
-    res = prefix
-    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)
-    res = f"zellij --layout {file}"
-    return res
-
-
-def launch_from_ssh_config():
-    hosts = choose_ssh_host()
-    res = build_template(hosts)
-    write_shell_script(res, execute=False, desc="zellij launch script")
-    return None
-
-
-
-if __name__ == '__main__':
-    launch_from_ssh_config()
+
+"""ZT
+"""
+
+import socket
+from machineconfig.utils.utils import choose_ssh_host, write_shell_script
+from crocodile.file_management import P
+
+prefix = """
+
+layout {
+    default_tab_template {
+        pane size=1 borderless=true {
+            plugin location="zellij:compact-bar"
+        }
+        children
+
+}
+
+"""
+
+suffix = """
+
+    tab name="THISMACHINE" focus=true // the default_tab_template
+}
+"""
+
+tab = """
+
+    tab name="TABNAME" focus=false { // the default_tab_template with three vertical panes between the plugins
+        pane name="fpane" {
+        command "TABCOMMAND"
+        args "TABARGS"
+        }
+}
+
+"""
+
+
+def build_template(tabs: list[str]):
+    res = prefix
+    for t in tabs:
+        res += tab.replace("TABNAME", t).replace("TABCOMMAND", f"ssh").replace("TABARGS", t)
+    res += suffix.replace("THISMACHINE", socket.gethostname())
+    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
+
+
+def launch_from_ssh_config():
+    hosts = choose_ssh_host(multi=True)
+    assert isinstance(hosts, list)
+    res = build_template(hosts)
+    write_shell_script(res, execute=False, desc="zellij launch script")
+    return None
+
+
+if __name__ == '__main__':
+    launch_from_ssh_config()