machineconfig 1.97__py3-none-any.whl → 2.1__py3-none-any.whl

machineconfig/utils/ssh.py

@@ -0,0 +1,351 @@
+from typing import Optional, Any, Union, List
+import os
+from dataclasses import dataclass
+import rich.console
+from machineconfig.utils.terminal import Terminal, Response, MACHINE
+from machineconfig.utils.path_reduced import PathExtended, PLike, OPLike
+from machineconfig.utils.utils2 import pprint
+
+
+@dataclass
+class Scout:
+    source_full: PathExtended
+    source_rel2home: PathExtended
+    exists: bool
+    is_dir: bool
+    files: Optional[List[PathExtended]]
+
+
+def scout(source: PLike, z: bool = False, r: bool = False) -> Scout:
+    source_full = PathExtended(source).expanduser().absolute()
+    source_rel2home = source_full.collapseuser()
+    exists = source_full.exists()
+    is_dir = source_full.is_dir() if exists else False
+    if z and exists:
+        try:
+            source_full = source_full.zip()
+        except Exception as ex:
+            raise Exception(f"Could not zip {source_full} due to {ex}") from ex  # type: ignore # pylint: disable=W0719
+        source_rel2home = source_full.zip()
+    if r and exists and is_dir:
+        files = [item.collapseuser() for item in source_full.search(folders=False, r=True)]
+    else:
+        files = None
+    return Scout(source_full=source_full, source_rel2home=source_rel2home, exists=exists, is_dir=is_dir, files=files)
+
+
+class SSH:  # inferior alternative: https://github.com/fabric/fabric
+    def __init__(
+        self, host: Optional[str] = None, username: Optional[str] = None, hostname: Optional[str] = None, sshkey: Optional[str] = None, pwd: Optional[str] = None, port: int = 22, ve: Optional[str] = ".venv", compress: bool = False
+    ):  # https://stackoverflow.com/questions/51027192/execute-command-script-using-different-shell-in-ssh-paramiko
+        self.pwd = pwd
+        self.ve = ve
+        self.compress = compress  # Defaults: (1) use localhost if nothing provided.
+
+        self.host: Optional[str] = None
+        self.hostname: str
+        self.username: str
+        self.port: int = port
+        self.proxycommand: Optional[str] = None
+        import platform
+        import paramiko  # type: ignore
+        import getpass
+
+        if isinstance(host, str):
+            try:
+                import paramiko.config as pconfig
+
+                config = pconfig.SSHConfig.from_path(str(PathExtended.home().joinpath(".ssh/config")))
+                config_dict = config.lookup(host)
+                self.hostname = config_dict["hostname"]
+                self.username = config_dict["user"]
+                self.host = host
+                self.port = int(config_dict.get("port", port))
+                tmp = config_dict.get("identityfile", sshkey)
+                if isinstance(tmp, list):
+                    sshkey = tmp[0]
+                else:
+                    sshkey = tmp
+                self.proxycommand = config_dict.get("proxycommand", None)
+                if sshkey is not None:
+                    tmp = config.lookup("*").get("identityfile", sshkey)
+                    if isinstance(tmp, list):
+                        sshkey = tmp[0]
+                    else:
+                        sshkey = tmp
+            except (FileNotFoundError, KeyError):
+                assert "@" in host or ":" in host, f"Host must be in the form of `username@hostname:port` or `username@hostname` or `hostname:port`, but it is: {host}"
+                if "@" in host:
+                    self.username, self.hostname = host.split("@")
+                else:
+                    self.username = username or getpass.getuser()
+                    self.hostname = host
+                if ":" in self.hostname:
+                    self.hostname, port_ = self.hostname.split(":")
+                    self.port = int(port_)
+        elif username is not None and hostname is not None:
+            self.username, self.hostname = username, hostname
+            self.proxycommand = None
+        else:
+            print(f"Provided values: host={host}, username={username}, hostname={hostname}")
+            raise ValueError("Either host or username and hostname must be provided.")
+
+        self.sshkey = str(PathExtended(sshkey).expanduser().absolute()) if sshkey is not None else None  # no need to pass sshkey if it was configured properly already
+        self.ssh = paramiko.SSHClient()
+        self.ssh.load_system_host_keys()
+        self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+        pprint(dict(host=self.host, hostname=self.hostname, username=self.username, password="***", port=self.port, key_filename=self.sshkey, ve=self.ve), title="SSHing To")
+
+        sock = paramiko.ProxyCommand(self.proxycommand) if self.proxycommand is not None else None
+        try:
+            if pwd is None:
+                allow_agent = True
+                look_for_keys = True
+            else:
+                allow_agent = False
+                look_for_keys = False
+            self.ssh.connect(hostname=self.hostname, username=self.username, password=self.pwd, port=self.port, key_filename=self.sshkey, compress=self.compress, sock=sock, allow_agent=allow_agent, look_for_keys=look_for_keys)  # type: ignore
+        except Exception as _err:
+            rich.console.Console().print_exception()
+            self.pwd = getpass.getpass(f"Enter password for {self.username}@{self.hostname}: ")
+            self.ssh.connect(hostname=self.hostname, username=self.username, password=self.pwd, port=self.port, key_filename=self.sshkey, compress=self.compress, sock=sock, allow_agent=False, look_for_keys=False)  # type: ignore
+
+        try:
+            self.sftp: Optional[paramiko.SFTPClient] = self.ssh.open_sftp()
+        except Exception as err:
+            self.sftp = None
+            print(f"""⚠️  WARNING: Failed to open SFTP connection to {hostname}.
+   Error Details: {err}\nData transfer may be affected!""")
+
+        def view_bar(slf: Any, a: Any, b: Any):
+            slf.total = int(b)
+            slf.update(int(a - slf.n))  # update pbar with increment
+
+        from tqdm import tqdm
+
+        self.tqdm_wrap = type("TqdmWrap", (tqdm,), {"view_bar": view_bar})
+        self._local_distro: Optional[str] = None
+        self._remote_distro: Optional[str] = None
+        self._remote_machine: Optional[MACHINE] = None
+        self.terminal_responses: list[Response] = []
+        self.platform = platform
+        self.remote_env_cmd = rf"""~/code/machineconfig/{self.ve}/Scripts/Activate.ps1""" if self.get_remote_machine() == "Windows" else rf"""source ~/code/machineconfig/{self.ve}/bin/activate"""
+        self.local_env_cmd = rf"""~/code/machineconfig/{self.ve}/Scripts/Activate.ps1""" if self.platform.system() == "Windows" else rf"""source ~/code/machineconfig/{self.ve}/bin/activate"""  # works for both cmd and pwsh
+
+    def __getstate__(self):
+        return {attr: self.__getattribute__(attr) for attr in ["username", "hostname", "host", "port", "sshkey", "compress", "pwd", "ve"]}
+
+    def __setstate__(self, state: dict[str, Any]):
+        SSH(**state)
+
+    def get_remote_machine(self) -> MACHINE:
+        if self._remote_machine is None:
+            if self.run("$env:OS", verbose=False, desc="Testing Remote OS Type").op == "Windows_NT" or self.run("echo %OS%", verbose=False, desc="Testing Remote OS Type Again").op == "Windows_NT":
+                self._remote_machine = "Windows"
+            else:
+                self._remote_machine = "Linux"
+        return self._remote_machine  # echo %OS% TODO: uname on linux
+
+    def get_local_distro(self) -> str:
+        if self._local_distro is None:
+            command = """uv run --with distro python -c "import distro; print(distro.name(pretty=True))" """
+            import subprocess
+
+            res = subprocess.run(command, shell=True, capture_output=True, text=True).stdout.strip()
+            self._local_distro = res
+            return res
+        return self._local_distro
+
+    def get_remote_distro(self):
+        if self._remote_distro is None:
+            self._remote_distro = self.run_py("print(install_n_import('distro').name(pretty=True))", verbose=False).op_if_successfull_or_default() or ""
+            # q.run("""~/.local/bin/uv run --with distro python -c "import distro; print(distro.name(pretty=True))" """)
+        return self._remote_distro
+
+    def restart_computer(self):
+        self.run("Restart-Computer -Force" if self.get_remote_machine() == "Windows" else "sudo reboot")
+
+    def send_ssh_key(self):
+        self.copy_from_here("~/.ssh/id_rsa.pub")
+        assert self.get_remote_machine() == "Windows"
+        code_url = "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/refs/heads/main/src/machineconfig/setup_windows/openssh-server_add-sshkey.ps1"
+        code = PathExtended(code_url).download().read_text(encoding="utf-8")
+        self.run(code)
+
+    def copy_env_var(self, name: str):
+        assert self.get_remote_machine() == "Linux"
+        return self.run(f"{name} = {os.environ[name]}; export {name}")
+
+    def get_remote_repr(self, add_machine: bool = False) -> str:
+        return f"{self.username}@{self.hostname}:{self.port}" + (f" [{self.get_remote_machine()}][{self.get_remote_distro()}]" if add_machine else "")
+
+    def get_local_repr(self, add_machine: bool = False) -> str:
+        import getpass
+
+        return f"{getpass.getuser()}@{self.platform.node()}" + (f" [{self.platform.system()}][{self.get_local_distro()}]" if add_machine else "")
+
+    def __repr__(self):
+        return f"local {self.get_local_repr(add_machine=True)} >>> SSH TO >>> remote {self.get_remote_repr(add_machine=True)}"
+
+    def run_locally(self, command: str):
+        print(f"""💻 [LOCAL EXECUTION] Running command on node: {self.platform.node()} Command: {command}""")
+        res = Response(cmd=command)
+        res.output.returncode = os.system(command)
+        return res
+
+    def get_ssh_conn_str(self, cmd: str = ""):
+        return "ssh " + (f" -i {self.sshkey}" if self.sshkey else "") + self.get_remote_repr().replace(":", " -p ") + (f" -t {cmd} " if cmd != "" else " ")
+
+    # def open_console(self, cmd: str = '', new_window: bool = True, terminal: Optional[str] = None, shell: str = "pwsh"): Terminal().run_async(*(self.get_ssh_conn_str(cmd=cmd).split(" ")), new_window=new_window, terminal=terminal, shell=shell)
+    def run(self, cmd: str, verbose: bool = True, desc: str = "", strict_err: bool = False, strict_returncode: bool = False, env_prefix: bool = False) -> Response:  # most central method.
+        cmd = (self.remote_env_cmd + "; " + cmd) if env_prefix else cmd
+        raw = self.ssh.exec_command(cmd)
+        res = Response(stdin=raw[0], stdout=raw[1], stderr=raw[2], cmd=cmd, desc=desc)  # type: ignore
+        if not verbose:
+            res.capture().print_if_unsuccessful(desc=desc, strict_err=strict_err, strict_returncode=strict_returncode, assert_success=False)
+        else:
+            res.print()
+        self.terminal_responses.append(res)
+        return res
+
+    def run_py(self, cmd: str, desc: str = "", return_obj: bool = False, verbose: bool = True, strict_err: bool = False, strict_returncode: bool = False) -> Union[Any, Response]:
+        assert '"' not in cmd, 'Avoid using `"` in your command. I dont know how to handle this when passing is as command to python in pwsh command.'
+        if not return_obj:
+            return self.run(
+                cmd=f"""{self.remote_env_cmd}; python -c "{Terminal.get_header(wdir=None, toolbox=True)}{cmd}\n""" + '"', desc=desc or f"run_py on {self.get_remote_repr()}", verbose=verbose, strict_err=strict_err, strict_returncode=strict_returncode
+            )
+        assert "obj=" in cmd, "The command sent to run_py must have `obj=` statement if return_obj is set to True"
+        source_file = self.run_py(f"""{cmd}\npath = Save.pickle(obj=obj, path=P.tmpfile(suffix='.pkl'))\nprint(path)""", desc=desc, verbose=verbose, strict_err=True, strict_returncode=True).op.split("\n")[-1]
+        res = self.copy_to_here(source=source_file, target=PathExtended.tmpfile(suffix=".pkl"))
+        import pickle
+
+        res_bytes = res.read_bytes()
+        return pickle.loads(res_bytes)
+
+    def copy_from_here(self, source: PLike, target: OPLike = None, z: bool = False, r: bool = False, overwrite: bool = False, init: bool = True) -> Union[PathExtended, list[PathExtended]]:
+        if init:
+            print(f"{'⬆️' * 5} [SFTP UPLOAD] FROM `{source}` TO `{target}`")  # TODO: using return_obj do all tests required in one go.
+        source_obj = PathExtended(source).expanduser().absolute()
+        if not source_obj.exists():
+            raise RuntimeError(f"Meta.SSH Error: source `{source_obj}` does not exist!")
+        if target is None:
+            target = PathExtended(source_obj).expanduser().absolute().collapseuser(strict=True)
+            assert target.is_relative_to("~"), "If target is not specified, source must be relative to home."
+            if z:
+                target += ".zip"
+        if not z and source_obj.is_dir():
+            if r is False:
+                raise RuntimeError(f"Meta.SSH Error: source `{source_obj}` is a directory! either set `r=True` for recursive sending or raise `z=True` flag to zip it first.")
+            source_list: list[PathExtended] = source_obj.search("*", folders=False, files=True, r=True)
+            remote_root = (
+                self.run_py(
+                    f"path=P(r'{PathExtended(target).as_posix()}').expanduser()\n{'path.delete(sure=True)' if overwrite else ''}\nprint(path.create())", desc=f"Creating Target directory `{PathExtended(target).as_posix()}` @ {self.get_remote_repr()}", verbose=False
+                ).op
+                or ""
+            )
+            for idx, item in enumerate(source_list):
+                print(f"   {idx + 1:03d}. {item}")
+            for item in source_list:
+                a__target = PathExtended(remote_root).joinpath(item.relative_to(source_obj))
+                self.copy_from_here(source=item, target=a__target)
+            return list(source_list)
+        if z:
+            print("🗜️ ZIPPING ...")
+            source_obj = PathExtended(source_obj).expanduser().zip(content=True)  # .append(f"_{randstr()}", inplace=True)  # eventually, unzip will raise content flag, so this name doesn't matter.
+        remotepath = (
+            self.run_py(
+                f"path=P(r'{PathExtended(target).as_posix()}').expanduser()\n{'path.delete(sure=True)' if overwrite else ''}\nprint(path.parent.create())",
+                desc=f"Creating Target directory `{PathExtended(target).parent.as_posix()}` @ {self.get_remote_repr()}",
+                verbose=False,
+            ).op
+            or ""
+        )
+        remotepath = PathExtended(remotepath.split("\n")[-1]).joinpath(PathExtended(target).name)
+        print(f"""📤 [SFTP UPLOAD] Sending file: {repr(PathExtended(source_obj))}  ==>  Remote Path: {remotepath.as_posix()}""")
+        with self.tqdm_wrap(ascii=True, unit="b", unit_scale=True) as pbar:
+            self.sftp.put(localpath=PathExtended(source_obj).expanduser(), remotepath=remotepath.as_posix(), callback=pbar.view_bar)  # type: ignore # pylint: disable=E1129
+        if z:
+            _resp = self.run_py(f"""P(r'{remotepath.as_posix()}').expanduser().unzip(content=False, inplace=True, overwrite={overwrite})""", desc=f"UNZIPPING {remotepath.as_posix()}", verbose=False, strict_err=True, strict_returncode=True)
+            source_obj.delete(sure=True)
+            print("\n")
+        return source_obj
+
+    def copy_to_here(self, source: PLike, target: OPLike = None, z: bool = False, r: bool = False, init: bool = True) -> PathExtended:
+        if init:
+            print(f"{'⬇️' * 5} SFTP DOWNLOADING FROM `{source}` TO `{target}`")
+        if not z and self.run_py(f"print(P(r'{source}').expanduser().absolute().is_dir())", desc=f"Check if source `{source}` is a dir", verbose=False, strict_returncode=True, strict_err=True).op.split("\n")[-1] == "True":
+            if r is False:
+                raise RuntimeError(f"source `{source}` is a directory! either set r=True for recursive sending or raise zip_first flag.")
+            source_list = self.run_py(f"obj=P(r'{source}').search(folders=False, r=True).collapseuser(strict=False)", desc="Searching for files in source", return_obj=True, verbose=False)
+            assert isinstance(source_list, List), f"Could not resolve source path {source} due to error"
+            for file in source_list:
+                self.copy_to_here(source=file.as_posix(), target=PathExtended(target).joinpath(PathExtended(file).relative_to(source)) if target else None, r=False)
+        if z:
+            tmp: Response = self.run_py(f"print(P(r'{source}').expanduser().zip(inplace=False, verbose=False))", desc=f"Zipping source file {source}", verbose=False)
+            tmp2 = tmp.op2path(strict_returncode=True, strict_err=True)
+            if not isinstance(tmp2, PathExtended):
+                raise RuntimeError(f"Could not zip {source} due to {tmp.err}")
+            else:
+                source = tmp2
+        if target is None:
+            tmpx = self.run_py(f"print(P(r'{PathExtended(source).as_posix()}').collapseuser(strict=False).as_posix())", desc="Finding default target via relative source path", strict_returncode=True, strict_err=True, verbose=False).op2path()
+            if isinstance(tmpx, PathExtended):
+                target = tmpx
+            else:
+                raise RuntimeError(f"Could not resolve target path {target} due to error")
+            assert target.is_relative_to("~"), f"If target is not specified, source must be relative to home.\n{target=}"
+        target_obj = PathExtended(target).expanduser().absolute()
+        target_obj.parent.mkdir(parents=True, exist_ok=True)
+        if z and ".zip" not in target_obj.suffix:
+            target_obj += ".zip"
+        if "~" in str(source):
+            tmp3 = self.run_py(f"print(P(r'{source}').expanduser())", desc="# Resolving source path address by expanding user", strict_returncode=True, strict_err=True, verbose=False).op2path()
+            if isinstance(tmp3, PathExtended):
+                source = tmp3
+            else:
+                raise RuntimeError(f"Could not resolve source path {source} due to")
+        else:
+            source = PathExtended(source)
+        print(f"""📥 [DOWNLOAD] Receiving: {source}  ==>  Local Path: {target_obj}""")
+        with self.tqdm_wrap(ascii=True, unit="b", unit_scale=True) as pbar:  # type: ignore # pylint: disable=E1129
+            assert self.sftp is not None, f"Could not establish SFTP connection to {self.hostname}."
+            self.sftp.get(remotepath=source.as_posix(), localpath=str(target_obj), callback=pbar.view_bar)  # type: ignore
+        if z:
+            target_obj = target_obj.unzip(inplace=True, content=True)
+            self.run_py(f"P(r'{source.as_posix()}').delete(sure=True)", desc="Cleaning temp zip files @ remote.", strict_returncode=True, strict_err=True, verbose=False)
+        print("\n")
+        return target_obj
+
+    def receieve(self, source: PLike, target: OPLike = None, z: bool = False, r: bool = False) -> PathExtended:
+        scout = self.run_py(cmd=f"obj=scout(r'{source}', z={z}, r={r})", desc=f"Scouting source `{source}` path on remote", return_obj=True, verbose=False)
+        assert isinstance(scout, Scout)
+        if not z and scout.is_dir and scout.files is not None:
+            if r:
+                tmp: list[PathExtended] = [self.receieve(source=file.as_posix(), target=PathExtended(target).joinpath(PathExtended(file).relative_to(source)) if target else None, r=False) for file in scout.files]
+                return tmp[0]
+            else:
+                print("Source is a directory! either set `r=True` for recursive sending or raise `zip_first=True` flag.")
+        if target:
+            target = PathExtended(target).expanduser().absolute()
+        else:
+            target = scout.source_rel2home.expanduser().absolute()
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if z and ".zip" not in target.suffix:
+            target += ".zip"
+        source = scout.source_full
+        with self.tqdm_wrap(ascii=True, unit="b", unit_scale=True) as pbar:
+            self.sftp.get(remotepath=source.as_posix(), localpath=target.as_posix(), callback=pbar.view_bar)  # type: ignore # pylint: disable=E1129
+        if z:
+            target = target.unzip(inplace=True, content=True)
+            self.run_py(f"P(r'{source.as_posix()}').delete(sure=True)", desc="Cleaning temp zip files @ remote.", strict_returncode=True, strict_err=True)
+        print("\n")
+        return target
+
+    # def print_summary(self):
+    #     import polars as pl
+    #     df = pl.DataFrame(List(self.terminal_responses).apply(lambda rsp: dict(desc=rsp.desc, err=rsp.err, returncode=rsp.returncode)).list)
+    #     print("\nSummary of operations performed:")
+    #     print(df.to_pandas().to_markdown())
+    #     if ((df.select('returncode').to_series().to_list()[2:] == [None] * (len(df) - 2)) and (df.select('err').to_series().to_list()[2:] == [''] * (len(df) - 2))): print("\nAll operations completed successfully.\n")
+    #     else: print("\nSome operations failed. \n")
+    #     return df

machineconfig/utils/terminal.py

@@ -0,0 +1,225 @@
+from machineconfig.utils.path_reduced import PathExtended, OPLike
+import subprocess
+from typing import Any, BinaryIO, Optional, Union
+import platform
+import sys
+import os
+from typing import Literal, TypeAlias
+from dataclasses import dataclass
+
+SHELLS: TypeAlias = Literal["default", "cmd", "powershell", "pwsh", "bash"]  # pwsh.exe is PowerShell (community) and powershell.exe is Windows Powershell (msft)
+CONSOLE: TypeAlias = Literal["wt", "cmd"]
+MACHINE: TypeAlias = Literal["Windows", "Linux", "Darwin"]
+
+
+@dataclass
+class STD:
+    stdin: str
+    stdout: str
+    stderr: str
+    returncode: int
+
+
+class Response:
+    @staticmethod
+    def from_completed_process(cp: subprocess.CompletedProcess[str]):
+        resp = Response(cmd=cp.args)
+        resp.output.stdout = cp.stdout
+        resp.output.stderr = cp.stderr
+        resp.output.returncode = cp.returncode
+        return resp
+
+    def __init__(self, stdin: Optional[BinaryIO] = None, stdout: Optional[BinaryIO] = None, stderr: Optional[BinaryIO] = None, cmd: Optional[str] = None, desc: str = ""):
+        self.std = dict(stdin=stdin, stdout=stdout, stderr=stderr)
+        self.output = STD(stdin="", stdout="", stderr="", returncode=0)
+        self.input = cmd
+        self.desc = desc  # input command
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Optional[str]:
+        _ = args, kwargs
+        return self.op.rstrip() if type(self.op) is str else None
+
+    @property
+    def op(self) -> str:
+        return self.output.stdout
+
+    @property
+    def ip(self) -> str:
+        return self.output.stdin
+
+    @property
+    def err(self) -> str:
+        return self.output.stderr
+
+    @property
+    def returncode(self) -> int:
+        return self.output.returncode
+
+    def op2path(self, strict_returncode: bool = True, strict_err: bool = False) -> Union[PathExtended, None]:
+        if self.is_successful(strict_returcode=strict_returncode, strict_err=strict_err):
+            return PathExtended(self.op.rstrip())
+        return None
+
+    def op_if_successfull_or_default(self, strict_returcode: bool = True, strict_err: bool = False) -> Optional[str]:
+        return self.op if self.is_successful(strict_returcode=strict_returcode, strict_err=strict_err) else None
+
+    def is_successful(self, strict_returcode: bool = True, strict_err: bool = False) -> bool:
+        return ((self.returncode in {0, None}) if strict_returcode else True) and (self.err == "" if strict_err else True)
+
+    def capture(self):
+        for key in ["stdin", "stdout", "stderr"]:
+            val: Optional[BinaryIO] = self.std[key]
+            if val is not None and val.readable():
+                self.output.__dict__[key] = val.read().decode().rstrip()
+        return self
+
+    def print_if_unsuccessful(self, desc: str = "TERMINAL CMD", strict_err: bool = False, strict_returncode: bool = False, assert_success: bool = False):
+        success = self.is_successful(strict_err=strict_err, strict_returcode=strict_returncode)
+        if assert_success:
+            assert success, self.print(capture=False, desc=desc)
+        if success:
+            print(f"✅ {desc} completed successfully")
+        else:
+            self.print(capture=False, desc=desc)
+        return self
+
+    def print(self, desc: str = "TERMINAL CMD", capture: bool = True):
+        if capture:
+            self.capture()
+        from rich import console
+
+        con = console.Console()
+        from rich.panel import Panel
+        from rich.text import Text  # from rich.syntax import Syntax; syntax = Syntax(my_code, "python", theme="monokai", line_numbers=True)
+
+        tmp1 = Text("📥 Input Command:\n")
+        tmp1.stylize("u bold blue")
+        tmp2 = Text("\n📤 Terminal Response:\n")
+        tmp2.stylize("u bold blue")
+        list_str = [f"{f' {idx} - {key} '}".center(40, "═") + f"\n{val}" for idx, (key, val) in enumerate(self.output.__dict__.items())]
+        txt = tmp1 + Text(str(self.input), style="white") + tmp2 + Text("\n".join(list_str), style="white")
+        con.print(Panel(txt, title=f"🖥️  {self.desc}", subtitle=f"📋 {desc}", width=150, style="bold cyan on black"))
+        return self
+
+
+# DEPRECATED: Use subprocess.run directly instead of Terminal class.
+# The Terminal class has been replaced with inline subprocess calls to underlying primitives.
+# This file is kept for reference but should not be used.
+
+
+class Terminal:
+    def __init__(self, stdout: Optional[int] = subprocess.PIPE, stderr: Optional[int] = subprocess.PIPE, stdin: Optional[int] = subprocess.PIPE, elevated: bool = False):
+        self.machine: str = platform.system()
+        self.elevated: bool = elevated
+        self.stdout = stdout
+        self.stderr = stderr
+        self.stdin = stdin
+
+    # def set_std_system(self): self.stdout = sys.stdout; self.stderr = sys.stderr; self.stdin = sys.stdin
+    def set_std_pipe(self):
+        self.stdout = subprocess.PIPE
+        self.stderr = subprocess.PIPE
+        self.stdin = subprocess.PIPE
+
+    def set_std_null(self):
+        self.stdout, self.stderr, self.stdin = subprocess.DEVNULL, subprocess.DEVNULL, subprocess.DEVNULL  # Equivalent to `echo 'foo' &> /dev/null`
+
+    def run(self, *cmds: str, shell: Optional[SHELLS] = "default", check: bool = False, ip: Optional[str] = None) -> Response:  # Runs SYSTEM commands like subprocess.run
+        """Blocking operation. Thus, if you start a shell via this method, it will run in the main and won't stop until you exit manually IF stdin is set to sys.stdin, otherwise it will run and close quickly. Other combinations of stdin, stdout can lead to funny behaviour like no output but accept input or opposite.
+        * This method is short for: res = subprocess.run("powershell command", capture_output=True, shell=True, text=True) and unlike os.system(cmd), subprocess.run(cmd) gives much more control over the output and input.
+        * `shell=True` loads up the profile of the shell called so more specific commands can be run. Importantly, on Windows, the `start` command becomes availalbe and new windows can be launched.
+        * `capture_output` prevents the stdout to redirect to the stdout of the script automatically, instead it will be stored in the Response object returned. # `capture_output=True` same as `stdout=subprocess.PIPE, stderr=subprocess.PIPE`"""
+        my_list = list(
+            cmds
+        )  # `subprocess.Popen` (process open) is the most general command. Used here to create asynchronous job. `subprocess.run` is a thin wrapper around Popen that makes it wait until it finishes the task. `suprocess.call` is an archaic command for pre-Python-3.5.
+        if self.machine == "Windows" and shell in {"powershell", "pwsh"}:
+            my_list = [shell, "-Command"] + my_list  # alternatively, one can run "cmd"
+        if self.elevated is False or self.is_user_admin():
+            resp: subprocess.CompletedProcess[str] = subprocess.run(my_list, stderr=self.stderr, stdin=self.stdin, stdout=self.stdout, text=True, shell=True, check=check, input=ip)
+        else:
+            resp = __import__("ctypes").windll.shell32.ShellExecuteW(None, "runas", sys.executable, " ".join(sys.argv), None, 1)
+        return Response.from_completed_process(resp)
+
+    def run_script(self, script: str, shell: SHELLS = "default", verbose: bool = False):
+        if self.machine == "Linux":
+            script = "#!/bin/bash" + "\n" + script  # `source` is only available in bash.
+        script_file = PathExtended.tmpfile(name="tmp_shell_script", suffix=".ps1" if self.machine == "Windows" else ".sh", folder="tmp_scripts").write_text(script, newline={"Windows": None, "Linux": "\n"}[self.machine])
+        if shell == "default":
+            if self.machine == "Windows":
+                start_cmd = "powershell"  # default shell on Windows is cmd which is not very useful. (./source is not available)
+                full_command: Union[list[str], str] = [start_cmd, str(script_file)]  # shell=True will cause this to be a string anyway (with space separation)
+            else:
+                start_cmd = "bash"
+                full_command = f"{start_cmd} {script_file}"  # full_command = [start_cmd, str(script_file)]
+        else:
+            full_command = f"{shell} {script_file}"  # full_command = [shell, str(tmp_file)]
+        if verbose:
+            desc = "Script to be executed:"
+            if platform.system() == "Windows":
+                lexer = "powershell"
+            elif platform.system() == "Linux":
+                lexer = "sh"
+            elif platform.system() == "Darwin":
+                lexer = "sh"  # macOS uses similar shell to Linux
+            else:
+                raise NotImplementedError(f"Platform {platform.system()} not supported.")
+            from rich.console import Console
+            from rich.panel import Panel
+            from rich.syntax import Syntax
+            import rich.progress as pb
+
+            console = Console()
+            console.print(Panel(Syntax(code=script, lexer=lexer), title=f"📄 {desc}"), style="bold red")
+            with pb.Progress(transient=True) as progress:
+                _task = progress.add_task(f"Running Script @ {script_file}", total=None)
+                resp = subprocess.run(full_command, stderr=self.stderr, stdin=self.stdin, stdout=self.stdout, text=True, shell=True, check=False)
+        else:
+            resp = subprocess.run(full_command, stderr=self.stderr, stdin=self.stdin, stdout=self.stdout, text=True, shell=True, check=False)
+        return Response.from_completed_process(resp)
+
+    def run_py(self, script: str, wdir: OPLike = None, interactive: bool = True, ipython: bool = True, shell: Optional[str] = None, terminal: str = "", new_window: bool = True, header: bool = True):  # async run, since sync run is meaningless.
+        script = (Terminal.get_header(wdir=wdir, toolbox=True) if header else "") + script + ("\nDisplayData.set_pandas_auto_width()\n" if terminal in {"wt", "powershell", "pwsh"} else "")
+        py_script = PathExtended.tmpfile(name="tmp_python_script", suffix=".py", folder="tmp_scripts/terminal")
+        py_script.write_text(f"""print(r'''{script}''')""" + "\n" + script)
+        print(f"""🚀 [ASYNC PYTHON SCRIPT] Script URI:
+   {py_script.absolute().as_uri()}""")
+        print("Script to be executed asyncronously: ", py_script.absolute().as_uri())
+        shell_script = f"""
+{f"cd {wdir}" if wdir is not None else ""}
+{"ipython" if ipython else "python"} {"-i" if interactive else ""} {py_script}
+"""
+        shell_script = PathExtended.tmpfile(name="tmp_shell_script", suffix=".sh" if self.machine == "Linux" else ".ps1", folder="tmp_scripts/shell").write_text(shell_script)
+        if shell is None and self.machine == "Windows":
+            shell = "pwsh"
+        window = "start" if new_window and self.machine == "Windows" else ""
+        os.system(f"{window} {terminal} {shell} {shell_script}")
+
+    @staticmethod
+    def is_user_admin() -> bool:  # adopted from: https://stackoverflow.com/questions/19672352/how-to-run-script-with-elevated-privilege-on-windows"""
+        if os.name == "nt":
+            try:
+                return __import__("ctypes").windll.shell32.IsUserAnAdmin()
+            except Exception:
+                import traceback
+
+                traceback.print_exc()
+                print("Admin check failed, assuming not an admin.")
+                return False
+        else:
+            return os.getuid() == 0  # Check for root on Posix
+
+    #     @staticmethod
+    #     def run_as_admin(file: PLike, params: Any, wait: bool = False):
+    #         proce_info = install_n_import(library="win32com", package="pywin32", fromlist=["shell.shell.ShellExecuteEx"]).shell.shell.ShellExecuteEx(lpVerb='runas', lpFile=file, lpParameters=params)
+    #         # TODO update PATH for this to take effect immediately.
+    #         if wait: time.sleep(1)
+    #         return proce_info
+
+    @staticmethod
+    def get_header(wdir: OPLike, toolbox: bool):
+        return f"""
+# >> Code prepended
+{"from crocodile.toolbox import *" if toolbox else "# No toolbox import."}
+{'''sys.path.insert(0, r'{wdir}') ''' if wdir is not None else "# No path insertion."}
+# >> End of header, start of script passed
+"""

machineconfig/utils/utils.py

@@ -2,18 +2,17 @@
 Utils
 """
 
-from machineconfig.utils.path_reduced import P as PathExtended
-# import crocodile.environment as env
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
 import machineconfig
 from machineconfig.utils.options import check_tool_exists, choose_cloud_interactively, choose_multiple_options, choose_one_option, choose_ssh_host, display_options
 from rich.console import Console
 from rich.panel import Panel
 from machineconfig.utils.links import build_links, symlink_copy, symlink_func
-from machineconfig.utils.code import get_shell_script_executing_python_file, get_shell_file_executing_python_script, write_shell_script_to_default_program_path, print_code, PROGRAM_PATH
+from machineconfig.utils.code import write_shell_script_to_default_program_path, print_code, PROGRAM_PATH
 from machineconfig.utils.path import sanitize_path, match_file_name
 
 # Split into multiple assignments to fix incompatible tuple sizes
-_ = get_shell_script_executing_python_file, get_shell_file_executing_python_script, print_code, PROGRAM_PATH, display_options, write_shell_script_to_default_program_path
+_ = print_code, PROGRAM_PATH, display_options, write_shell_script_to_default_program_path
 _ = build_links
 _ = symlink_copy
 _ = symlink_func
@@ -48,31 +47,34 @@ DEFAULTS_PATH = PathExtended.home().joinpath("dotfiles/machineconfig/defaults.in
 #     else: print(f"\n❌ ERROR | API request failed: {response.status_code}\n")
 
 
-
-
-def check_dotfiles_version_is_beyond(commit_dtm: str, update: bool=False):
+def check_dotfiles_version_is_beyond(commit_dtm: str, update: bool) -> bool:
     dotfiles_path = str(PathExtended.home().joinpath("dotfiles"))
     from git import Repo
+
     repo = Repo(path=dotfiles_path)
     last_commit = repo.head.commit
     dtm = last_commit.committed_datetime
     from datetime import datetime  # make it tz unaware
+
     dtm = datetime(dtm.year, dtm.month, dtm.day, dtm.hour, dtm.minute, dtm.second)
-    res =  dtm > datetime.fromisoformat(commit_dtm)
+    res = dtm > datetime.fromisoformat(commit_dtm)
     if res is False and update is True:
         console = Console()
         console.print(Panel(f"🔄 UPDATE REQUIRED | Updating dotfiles because {dtm} < {datetime.fromisoformat(commit_dtm)}", border_style="bold blue", expand=False))
         from machineconfig.scripts.python.cloud_repo_sync import main
+
         main(cloud=None, path=dotfiles_path)
     return res
 
+
 def wait_for_jobs_to_finish(root: PathExtended, pattern: str, wait_for_n_jobs: int, max_wait_minutes: float) -> bool:
-    wait_finished: bool=False
+    wait_finished: bool = False
     import time
+
     t0 = time.time()
     while not wait_finished:
         parts = root.search(pattern, folders=False, r=False)
-        counter  =  len(parts)
+        counter = len(parts)
         if counter == wait_for_n_jobs:
             wait_finished = True
             console = Console()
@@ -89,8 +91,7 @@ def wait_for_jobs_to_finish(root: PathExtended, pattern: str, wait_for_n_jobs: i
     return False
 
 
-
-if __name__ == '__main__':
+if __name__ == "__main__":
     # import typer
     # typer.run(check_tool_exists)
     pass