machineconfig 1.95__py3-none-any.whl → 1.96__py3-none-any.whl

machineconfig/cluster/self_ssh.py

@@ -1,59 +1,57 @@
 
-"""SelfSSh
-"""
+# """SelfSSh
+# """
 
 
-from crocodile.file_management import PLike
-from crocodile.meta import MACHINE, Terminal
-from typing import Optional, Any
-import getpass
-import platform
-import subprocess
+# from typing import Optional, Any
+# import getpass
+# import platform
+# import subprocess
 
 
-class SelfSSH:
-    """Instead of SSH'ing to the same machine, one can use this interface.
-    """
-    def __init__(self):
-        self.hostname = "localhost"
-        self._remote_machine: Optional[MACHINE] = None
-        self.remote_env_cmd = ". activate_ve"
-        self.sftp: Any
-    def __getstate__(self) -> object: return {}
-    def __setstate__(self, state: dict[str, Any]) -> None:
-        """This behaviour makes SelfSSH dynamic, even if it was pickled from windows machine, when unpickled on Linux, it will behave as a Linux machine instance."""
-        _ = state
-        new_instance = SelfSSH()
-        self.__dict__.update(new_instance.__dict__)
-        return None
-    def run(self, cmd: str, desc: str = "", verbose: bool = False):
-        _ = desc, verbose
-        return Terminal().run(cmd, shell="powershell")
-    def run_py(self, cmd: str, verbose: bool = False, desc: str = ''):
-        _ = verbose, cmd, desc
-        exec(cmd)  # type: ignore # pylint: disable=exec-used
-        return None
-    def get_ssh_conn_str(self): return "ssh localhost"
-    def get_remote_machine(self) -> MACHINE:
-        if self._remote_machine is None:
-            self._remote_machine = "Windows" if (self.run("$env:OS").op.rstrip("\n") == "Windows_NT" or self.run("echo %OS%").op == "Windows_NT") else "Linux"
-        return self._remote_machine
-    def get_remote_repr(self, add_machine: bool = False):
-        _ = add_machine
-        host = f"{getpass.getuser()}@{platform.node()}"
-        return f"SelfSSH({host}) REMOTE"
-    def get_local_repr(self, add_machine: bool = False): return self.get_remote_repr(add_machine=add_machine).replace("REMOTE", "LOCAL")
-    def open_console(self, cmd: str = '', new_window: bool = True, terminal: Optional[str] = None, shell: str = "pwsh"):
-        _ = cmd, shell, new_window, terminal
-        # return Terminal().run_async("", new_window=True, shell=shell)
-        # Terminal().run_async(*(self.get_ssh_conn_str(cmd=cmd).split(" ")), new_window=new_window, terminal=terminal, shell=shell)
-        if platform.system() == "Windows":
-            subprocess.Popen(["wt", "--profile", "pwsh"], stdin=subprocess.PIPE, shell=True)
-        elif platform.system() == "Linux":
-            subprocess.Popen(["zellij --session haha"], shell=True, stdin=None, stdout=None, stderr=None)
-    def copy_to_here(self, source: PLike = '', target: Optional[str] = '', z: bool = True, r: bool = True, desc: str = '', overwrite: bool = False):
-        _ = source, target, z, r, desc, overwrite
-        return None
-    def copy_from_here(self, source: PLike = '', target: Optional[str] = '', z: bool = True, r: bool = True, desc: str = '', overwrite: bool = False):
-        _ = source, target, z, r, desc, overwrite
-        return None
+# class SelfSSH:
+#     """Instead of SSH'ing to the same machine, one can use this interface.
+#     """
+#     def __init__(self):
+#         self.hostname = "localhost"
+#         self._remote_machine: Optional[MACHINE] = None
+#         self.remote_env_cmd = ". activate_ve"
+#         self.sftp: Any
+#     def __getstate__(self) -> object: return {}
+#     def __setstate__(self, state: dict[str, Any]) -> None:
+#         """This behaviour makes SelfSSH dynamic, even if it was pickled from windows machine, when unpickled on Linux, it will behave as a Linux machine instance."""
+#         _ = state
+#         new_instance = SelfSSH()
+#         self.__dict__.update(new_instance.__dict__)
+#         return None
+#     def run(self, cmd: str, desc: str = "", verbose: bool = False):
+#         _ = desc, verbose
+#         return Terminal().run(cmd, shell="powershell")
+#     def run_py(self, cmd: str, verbose: bool = False, desc: str = ''):
+#         _ = verbose, cmd, desc
+#         exec(cmd)  # type: ignore # pylint: disable=exec-used
+#         return None
+#     def get_ssh_conn_str(self): return "ssh localhost"
+#     def get_remote_machine(self) -> MACHINE:
+#         if self._remote_machine is None:
+#             self._remote_machine = "Windows" if (self.run("$env:OS").op.rstrip("\n") == "Windows_NT" or self.run("echo %OS%").op == "Windows_NT") else "Linux"
+#         return self._remote_machine
+#     def get_remote_repr(self, add_machine: bool = False):
+#         _ = add_machine
+#         host = f"{getpass.getuser()}@{platform.node()}"
+#         return f"SelfSSH({host}) REMOTE"
+#     def get_local_repr(self, add_machine: bool = False): return self.get_remote_repr(add_machine=add_machine).replace("REMOTE", "LOCAL")
+#     def open_console(self, cmd: str = '', new_window: bool = True, terminal: Optional[str] = None, shell: str = "pwsh"):
+#         _ = cmd, shell, new_window, terminal
+#         # return Terminal().run_async("", new_window=True, shell=shell)
+#         # Terminal().run_async(*(self.get_ssh_conn_str(cmd=cmd).split(" ")), new_window=new_window, terminal=terminal, shell=shell)
+#         if platform.system() == "Windows":
+#             subprocess.Popen(["wt", "--profile", "pwsh"], stdin=subprocess.PIPE, shell=True)
+#         elif platform.system() in ["Linux", "Darwin"]:
+#             subprocess.Popen(["zellij --session haha"], shell=True, stdin=None, stdout=None, stderr=None)
+#     def copy_to_here(self, source: PLike = '', target: Optional[str] = '', z: bool = True, r: bool = True, desc: str = '', overwrite: bool = False):
+#         _ = source, target, z, r, desc, overwrite
+#         return None
+#     def copy_from_here(self, source: PLike = '', target: Optional[str] = '', z: bool = True, r: bool = True, desc: str = '', overwrite: bool = False):
+#         _ = source, target, z, r, desc, overwrite
+#         return None

machineconfig/{jobs/python → cluster/sessions_managers/archive}/create_zellij_template.py

@@ -4,7 +4,7 @@
 
 import socket
 from machineconfig.utils.utils import choose_ssh_host, write_shell_script_to_default_program_path
-from crocodile.file_management import P
+from machineconfig.utils.path_reduced import P as PathExtended
 
 prefix = """
 
@@ -42,7 +42,9 @@ def build_template(tabs: list[str]):
     for t in tabs:
         res += tab.replace("TABNAME", t).replace("TABCOMMAND", "ssh").replace("TABARGS", t)
     res += suffix.replace("THISMACHINE", socket.gethostname())
-    file = P.tmp().joinpath("tmp_files/templates/zellij_template.kdl").create(parents_only=True).write_text(res)
+    file = PathExtended.tmp().joinpath("tmp_files/templates/zellij_template.kdl")
+    file.parent.mkdir(parents=True, exist_ok=True)
+    file.write_text(res)
     res = f"zellij --layout {file}"
     return res
 
@@ -51,7 +53,7 @@ def launch_from_ssh_config():
     hosts = choose_ssh_host(multi=True)
     assert isinstance(hosts, list)
     res = build_template(hosts)
-    write_shell_script_to_default_program_path(res, execute=False, desc="zellij launch script")
+    write_shell_script_to_default_program_path(res, execute=False, desc="zellij launch script", preserve_cwd=False, display=False)
     return None
 
 

machineconfig/cluster/sessions_managers/archive/session_managers.py

@@ -0,0 +1,184 @@
+
+# """
+# Session Manager
+# """
+
+# from machineconfig.cluster.self_ssh import SelfSSH
+
+# from machineconfig.utils.io_save import save_yaml
+# import time
+# import subprocess
+# from typing import Union
+
+
+# class Zellij:
+#     @staticmethod
+#     def get_current_zellij_session() -> str:
+#         try:
+#                 output_lines = Terminal().run("zellij ls --no-formatting").op.split("\n")
+#                 current_lines = [line for line in output_lines if "(current)" in line]
+#                 return current_lines[0].split(" [Created")[0]
+#         except IndexError as ie:
+#             print("""Fails if there is no zellij session running, fails if there is no (current) suffix against the session name.""")
+#             raise ie
+#     @staticmethod
+#     def get_new_session_command(sess_name: str) -> str: return f"zellij attach {sess_name} -c "  # -c means create if not exists.
+#     @staticmethod
+#     def get_new_session_ssh_command(ssh: Union[SSH, SelfSSH], sess_name: str):
+#         if isinstance(ssh, SelfSSH): return Zellij.get_new_session_command(sess_name=sess_name)
+#         return f"{ssh.get_ssh_conn_str()} -t {Zellij.get_new_session_command(sess_name=sess_name)}"
+#     @staticmethod
+#     def open_console(ssh: Union[SSH, SelfSSH], sess_name: str):
+#         if isinstance(ssh, SelfSSH):
+#             # return Terminal().run_async(Zellij.get_new_session_command(sess_name=sess_name), shell="powershell")
+#             # currently, there is a limitation in zellij on creating a detached sessions, there is no way to fix this now.
+#             # this will get stuck in the new session and won't run parallel.
+#             return subprocess.Popen(["zellij", "--session", sess_name], shell=True, stdin=None, stdout=None, stderr=None)
+#         return Terminal().run_async(Zellij.get_new_session_ssh_command(ssh=ssh, sess_name=sess_name))
+#     @staticmethod
+#     def asssert_session_started(ssh: Union[SSH, SelfSSH], sess_name: str):
+#         while True:
+#             raw_resp = ssh.run("zellij ls --no-formatting", verbose=False).op.split("\n")
+#             current_sessions = [item.split(" [Created")[0] for item in raw_resp if "EXITED" not in item]
+#             if sess_name in current_sessions:
+#                 print(f"--> Session {sess_name} has started at the remote.")
+#                 time.sleep(6)
+#                 break
+#             time.sleep(2)
+#             print(f"--> Waiting for zellij session {sess_name} to start before sending fire commands ...")
+
+#     @staticmethod
+#     def close_tab(sess_name: str, tab_name: str):
+#         cmd = f"""
+# zellij --session {sess_name} action close-tab --tab-name '{tab_name}'
+# zellij --session {sess_name} action new-tab --name '🖥️{tab_name}'
+# zellij --session {sess_name} action new-tab --name '🔍{tab_name}'
+# zellij --session {sess_name} action new-tab --name '🪪{tab_name}'
+# zellij --session {sess_name} action new-tab --name '🧑‍💻{tab_name}'
+# """
+#         print(f"Closing tab `{tab_name}` in zellij session `{sess_name}` with command \n{cmd}")
+#         return Terminal().run_script(cmd)
+
+#     @staticmethod
+#     def setup_layout(ssh: Union[SSH, SelfSSH], sess_name: str, cmd: str = "", run: bool = False, job_wd: str = "$HOME/tmp_results/remote_machines", tab_name: str = "", compact: bool = False):
+#         sleep = 0.9
+#         if run:
+#             if cmd.startswith(". "): cmd = cmd[2:]
+#             elif cmd.startswith("source "): cmd = cmd[7:]
+#             else: pass
+#             exe = f"""
+# zellij --session {sess_name} action new-tab --name '{tab_name}'; sleep {sleep}
+# zellij --session {sess_name} run -d down -- /bin/bash {cmd}; sleep {sleep}
+# zellij --session {sess_name} action move-focus up; sleep {sleep}
+# zellij --session {sess_name} action close-pane; sleep {sleep}
+# """
+#         else: exe = f"""
+# zellij --session {sess_name} action write-chars "{cmd}"
+# """
+#         if not compact: cmd = f"""
+# zellij --session {sess_name} action new-tab --name '{tab_name}'; sleep {sleep}
+# zellij --session {sess_name} action rename-tab '🖥️{tab_name}'; sleep {sleep}  # rename the focused first tab
+# zellij --session {sess_name} action new-tab --name '🔍{tab_name}'; sleep {sleep}
+# zellij --session {sess_name} action write-chars htop; sleep {sleep}
+
+# zellij --session {sess_name} action new-tab --name '📁{tab_name}'; sleep {sleep}
+# zellij --session {sess_name} run --direction down --cwd {job_wd} -- lf; sleep {sleep}
+# zellij --session {sess_name} action move-focus up; sleep {sleep}
+# zellij --session {sess_name} action close-pane; sleep {sleep}
+
+# zellij --session {sess_name} action new-tab --name '🪪{tab_name}'; sleep {sleep}
+# zellij --session {sess_name} run --direction down -- neofetch;cpufetch; sleep {sleep}
+# zellij --session {sess_name} action move-focus up; sleep {sleep}
+# zellij --session {sess_name} action close-pane; sleep {sleep}
+
+# zellij --session {sess_name} action new-tab --name '🧑‍💻{tab_name}'; sleep {sleep}
+# zellij --session {sess_name} action write-chars "cd {job_wd}"; sleep {sleep}
+# zellij --session {sess_name} action go-to-tab 1; sleep {sleep}
+# {exe}
+
+# """
+#         else: cmd = exe
+#         if isinstance(ssh, SelfSSH):
+#             # print(1)
+#             print(f"Setting up zellij layout `{sess_name}` on `{ssh.get_remote_repr()}` to run `{P(job_wd).name}`")
+#             # return Terminal().run_script(cmd)  # Zellij not happy with launching scripts of zellij commands.
+#             return Response.from_completed_process(subprocess.run(cmd, shell=True, check=True, capture_output=True, text=True))
+#         # print(2)
+#         return ssh.run(cmd, desc=f"Setting up zellij layout on `{ssh.get_remote_repr()}`", verbose=False)
+#     @staticmethod
+#     def kill_session(ssh: Union[SSH, SelfSSH], sess_name: str):
+#         cmd = f'zellij kill-session {sess_name}'
+#         return ssh.run(cmd, desc=f"Killing zellij session `{sess_name}` on `{ssh.get_remote_repr()}`", verbose=False)
+
+
+# class WindowsTerminal:
+#     @staticmethod
+#     def kill_session(sess_name: str):
+#         from machineconfig.utils.procs import ProcessManager
+#         pm = ProcessManager()
+#         pm.kill(commands=[sess_name])
+#     @staticmethod
+#     def open_reference(): PathExtended(r"https://learn.microsoft.com/en-us/windows/terminal/command-line-arguments?tabs=windows")()
+#     @staticmethod
+#     def get_new_session_command(sess_name: str): return f"wt -w {sess_name} -d ."
+#     @staticmethod
+#     def get_new_session_ssh_command(ssh: Union[SSH, SelfSSH], sess_name: str):
+#         if isinstance(ssh, SelfSSH): return WindowsTerminal.get_new_session_command(sess_name=sess_name)
+#         return f"{ssh.get_ssh_conn_str()} -t {WindowsTerminal.get_new_session_command(sess_name=sess_name)}"
+#     @staticmethod
+#     def open_console(ssh: Union[SSH, SelfSSH], sess_name: str):
+#         if isinstance(ssh, SelfSSH):
+#             # return Terminal().run_async(WindowsTerminal.get_new_session_command(sess_name=sess_name), shell="powershell")
+#             return subprocess.Popen(["wt", "--window", sess_name], shell=True, stdin=None, stdout=None, stderr=None)
+#         return Terminal().run_async(WindowsTerminal.get_new_session_ssh_command(ssh=ssh, sess_name=sess_name), shell="pwsh")
+#     @staticmethod
+#     def asssert_session_started(ssh: Union[SSH, SelfSSH], sess_name: str):
+#         _ = sess_name, ssh
+#         time.sleep(6)
+#         return True
+#     @staticmethod
+#     def setup_layout(ssh: Union[SSH, SelfSSH], sess_name: str, tab_name: str = "", cmd: str = "", run: bool = True, job_wd: str = "$HOME/tmp_results/remote_machines", compact: bool = True):
+#         if run:
+#             if cmd.startswith(". "): cmd = cmd[2:]
+#             elif cmd.startswith("source "): cmd = cmd[7:]
+#             else: pass
+#             exe: str = f"""
+# wt --window {sess_name} new-tab --title '{tab_name}' pwsh -noExit -Command {cmd}
+# """
+#         else: raise NotImplementedError("I don't know how to write-chars in Windows Terminal")  # exe = f""" wt --window {sess_name} action write-chars "{cmd}" """
+#         sleep = 0.9
+#         if compact: cmd = f"""
+# wt --window {sess_name} new-tab --title '💻{tab_name}' htop `; split-pane --horizontal  --title '📁{tab_name}' --startingDirectory {job_wd} --profile pwsh lf `;  split-pane --vertical  --title '🪪{tab_name}' powershell -noExit "$HOME/scripts/neofetch.ps1" `; move-focus up `;  split-pane --vertical --startingDirectory {job_wd} --title '🧑‍💻{tab_name}' --profile pwsh
+# """  # when pane-splitting, the tab title goes to the last pane declared.
+#         else: cmd = f"""'
+# wt --window {sess_name} new-tab --title '💻{tab_name}' htop; sleep {sleep}
+# wt --window {sess_name} new-tab --title '📁{tab_name}' --startingDirectory {job_wd} lf; sleep {sleep}
+# wt --window {sess_name} new-tab --title '🪪{tab_name}' powershell -noExit "$HOME/scripts/neofetch.ps1"; sleep {sleep}
+# wt --window {sess_name} new-tab --title '🧑‍💻{tab_name}' --startingDirectory {job_wd} --profile pwsh; sleep {sleep}
+# """
+#         cmd = cmd + f"\nsleep {sleep};" + exe
+#         # print(cmd)
+#         if isinstance(ssh, SelfSSH):
+#             print(f"Firing WindowsTerminal Session `{sess_name}` on `{ssh.get_remote_repr()}` to run `{P(job_wd).name}`")
+#             return Terminal().run_script(cmd, shell="pwsh")
+#         return ssh.run(cmd, desc=f"Setting up WindowsTerminal layout on `{ssh.get_remote_repr()}`", verbose=False)
+
+
+# class Mprocs:
+#     @staticmethod
+#     def get_template():
+#         import machineconfig
+#         return PathExtended(machineconfig.__file__).parent.joinpath(r"settings/mprocs/windows/mprocs.yaml").readit()
+#     # def get_new_session_name(self): return f"mprocs{self.id}"
+#     @staticmethod
+#     def get_ssh_command(): return ""
+#     def open_console(self, cmd: str, shell: str = "powershell"):
+#         _ = cmd, shell
+#         return "wt -w 0 -d ."
+#     def get_layout(self):
+#         temp = self.get_template()
+#         temp.procs['main']['shell']['windows'] = "croshell"
+#         _template_file = save_yaml(obj=temp, path=PathExtended.tmpfile(suffix=".yaml"))
+#     def asssert_session_started(self):
+#         time.sleep(3)
+#         return True

machineconfig/cluster/sessions_managers/enhanced_command_runner.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""
+Enhanced command execution utilities with Rich formatting for better user experience.
+"""
+
+import subprocess
+import re
+from typing import Optional, Dict, Any
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich import box
+
+console = Console()
+
+def run_enhanced_command(
+    command: str, 
+    description: Optional[str] = None,
+    show_progress: bool = True,
+    timeout: Optional[int] = None
+) -> Dict[str, Any]:
+    """
+    Run a command with enhanced Rich formatting and user feedback.
+    
+    Args:
+        command: The command to execute
+        description: Optional description for progress display
+        show_progress: Whether to show a progress spinner
+        timeout: Optional timeout in seconds
+    
+    Returns:
+        Dictionary with success status, output, and error information
+    """
+    
+    if description is None:
+        description = f"Executing: {command[:50]}..."
+    
+    try:
+        if show_progress:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+                transient=True
+            ) as progress:
+                task = progress.add_task(f"[cyan]{description}[/cyan]", total=None)
+                
+                result = subprocess.run(
+                    command,
+                    shell=True,
+                    capture_output=True,
+                    text=True,
+                    timeout=timeout
+                )
+                
+                progress.update(task, completed=True)
+        else:
+            result = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=timeout
+            )
+        
+        # Enhanced output processing
+        stdout = result.stdout.strip() if result.stdout else ""
+        stderr = result.stderr.strip() if result.stderr else ""
+        
+        # Process common Zellij messages with enhanced formatting
+        if "Session:" in stdout and "successfully deleted" in stdout:
+            session_match = re.search(r'Session: "([^"]+)" successfully deleted', stdout)
+            if session_match:
+                session_name = session_match.group(1)
+                console.print(f"[bold red]🗑️  Session[/bold red] [yellow]'{session_name}'[/yellow] [red]successfully deleted[/red]")
+        
+        if "zellij layout is running" in stdout:
+            console.print(stdout.replace("zellij layout is running @", 
+                                       "[bold green]🚀 Zellij layout is running[/bold green] [yellow]@[/yellow]"))
+        
+        # Handle pseudo-terminal warnings with less alarming appearance
+        if "Pseudo-terminal will not be allocated" in stderr:
+            console.print("[dim yellow]ℹ️  Note: Running in non-interactive mode[/dim yellow]")
+            stderr = stderr.replace("Pseudo-terminal will not be allocated because stdin is not a terminal.\n", "")
+        
+        if result.returncode == 0:
+            if stdout and not any(msg in stdout for msg in ["Session:", "zellij layout is running"]):
+                console.print(f"[green]{stdout}[/green]")
+            return {
+                "success": True,
+                "returncode": result.returncode,
+                "stdout": stdout,
+                "stderr": stderr
+            }
+        else:
+            if stderr:
+                console.print(f"[bold red]Error:[/bold red] [red]{stderr}[/red]")
+            return {
+                "success": False,
+                "returncode": result.returncode,
+                "stdout": stdout,
+                "stderr": stderr
+            }
+            
+    except subprocess.TimeoutExpired:
+        console.print(f"[bold red]⏰ Command timed out after {timeout} seconds[/bold red]")
+        return {
+            "success": False,
+            "error": "Timeout",
+            "timeout": timeout
+        }
+    except Exception as e:
+        console.print(f"[bold red]💥 Unexpected error:[/bold red] [red]{str(e)}[/red]")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+def enhanced_zellij_session_start(session_name: str, layout_path: str) -> Dict[str, Any]:
+    """
+    Start a Zellij session with enhanced visual feedback.
+    """
+    console.print()
+    console.print(Panel.fit(f"🚀 Starting Zellij Session: [bold cyan]{session_name}[/bold cyan]", 
+                          style="green", box=box.ROUNDED))
+    
+    # Delete existing session first (suppress normal output)
+    delete_cmd = f"zellij delete-session --force {session_name}"
+    run_enhanced_command(
+        delete_cmd, 
+        f"Cleaning up existing session '{session_name}'",
+        show_progress=False,
+        timeout=5  # Quick timeout for cleanup
+    )
+    
+    # Start new session (use -b for background to avoid hanging)
+    start_cmd = f"zellij --layout {layout_path} a -b {session_name}"
+    start_result = run_enhanced_command(
+        start_cmd,
+        f"Starting session '{session_name}' with layout",
+        show_progress=False,
+        timeout=10  # Add timeout to prevent hanging
+    )
+    
+    if start_result["success"]:
+        console.print(Panel(f"[bold green]✅ Session '{session_name}' is now running![/bold green]\n[dim]Layout: {layout_path}[/dim]", 
+                           style="green", title="🎉 Success"))
+    else:
+        console.print(Panel(f"[bold red]❌ Failed to start session '{session_name}'[/bold red]\n[red]{start_result.get('stderr', 'Unknown error')}[/red]", 
+                           style="red", title="💥 Error"))
+    
+    return start_result
+
+if __name__ == "__main__":
+    # Demo the enhanced command execution
+    console.print(Panel.fit("🎨 Enhanced Command Execution Demo", style="bold cyan"))
+    
+    # Test with a simple command
+    result = run_enhanced_command("echo 'Hello, Rich world!'", "Testing enhanced output")
+    console.print(f"Result: {result}")