machineconfig 2.98__py3-none-any.whl → 3.1__py3-none-any.whl

machineconfig/cluster/sessions_managers/zellij_local_manager.py

@@ -10,7 +10,7 @@ from typing import Optional, List
 
 from rich.console import Console
 
-from machineconfig.cluster.sessions_managers.zellij_utils.monitoring_types import SessionReport, GlobalSummary, StartResult, ActiveSessionInfo
+from machineconfig.cluster.sessions_managers.zellij_utils.monitoring_types import SessionReport, GlobalSummary, StartResult, ActiveSessionInfo, StatusRow
 from machineconfig.utils.utils5 import Scheduler
 from machineconfig.cluster.sessions_managers.zellij_local import ZellijLayoutGenerator
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
@@ -36,7 +36,7 @@ class ZellijLocalManager:
             session_name = layout_config["layoutName"].replace(" ", "_")
             manager = ZellijLayoutGenerator()
             full_session_name = f"{self.session_name_prefix}_{session_name}"
-            manager.create_zellij_layout(layout_config=layout_config, session_name=full_session_name)
+            manager.create_zellij_layout(layout_config=layout_config, output_dir=None, session_name=full_session_name)
             self.managers.append(manager)
 
         # Enhanced Rich logging for initialization
@@ -46,7 +46,7 @@ class ZellijLocalManager:
         """Get all managed session names."""
         return [manager.session_name for manager in self.managers if manager.session_name is not None]
 
-    def start_all_sessions(self, poll_seconds: float = 5.0, poll_interval: float = 0.25) -> dict[str, StartResult]:
+    def start_all_sessions(self, poll_seconds: float, poll_interval: float) -> dict[str, StartResult]:
         """Start all zellij sessions with their layouts without blocking on the interactive TUI.
 
         Rationale:
@@ -135,7 +135,7 @@ class ZellijLocalManager:
 
         return results
 
-    def attach_to_session(self, session_name: Optional[str] = None) -> str:
+    def attach_to_session(self, session_name: Optional[str]) -> str:
         """
         Generate command to attach to a specific session or list attachment commands for all.
 
@@ -153,7 +153,7 @@ class ZellijLocalManager:
             raise ValueError(f"Session '{session_name}' not found")
         else:
             # Return commands for all sessions
-            commands = []
+            commands: list[str] = []
             for manager in self.managers:
                 commands.append(f"# Attach to session '{manager.session_name}':")
                 commands.append(f"zellij attach {manager.session_name}")
@@ -253,12 +253,13 @@ class ZellijLocalManager:
 
         print("=" * 80)
 
-    def run_monitoring_routine(self, wait_ms: int = 30000) -> None:
+    def run_monitoring_routine(self, wait_ms: int) -> None:
         """
         Run a continuous monitoring routine that checks status periodically.
 
         Args:
-            wait_ms: How long to wait between checks in milliseconds (default: 30000ms = 30s)
+            wait_ms: How long to wait between checks in milliseconds
+            kill_sessions_on_completion: If True, kill all managed zellij sessions when monitoring stops
         """
 
         def routine(scheduler: Scheduler):
@@ -270,7 +271,7 @@ class ZellijLocalManager:
                 all_status = self.check_all_sessions_status()
 
                 # Create DataFrame for easier viewing
-                status_data = []
+                status_data: list[StatusRow] = []
                 for session_name, status in all_status.items():
                     for tab_name, cmd_status in status["commands_status"].items():
                         status_data.append(
@@ -314,7 +315,7 @@ class ZellijLocalManager:
         sched = Scheduler(routine=routine, wait_ms=wait_ms, logger=logger)
         sched.run()
 
-    def save(self, session_id: Optional[str] = None) -> str:
+    def save(self, session_id: Optional[str]) -> str:
         """Save the manager state to disk."""
         if session_id is None:
             session_id = str(uuid.uuid4())[:8]
@@ -360,8 +361,8 @@ class ZellijLocalManager:
         if not config_file.exists():
             raise FileNotFoundError(f"Configuration file not found: {config_file}")
 
-        with open(config_file, "r", encoding="utf-8") as f:
-            session_layouts = json.load(f)
+        text = config_file.read_text(encoding="utf-8")
+        session_layouts = json.loads(text)
 
         # Create new instance
         instance = cls(session_layouts=session_layouts)
@@ -374,8 +375,8 @@ class ZellijLocalManager:
 
             for manager_file in manager_files:
                 try:
-                    with open(manager_file, "r", encoding="utf-8") as f:
-                        manager_data = json.load(f)
+                    text = manager_file.read_text(encoding="utf-8")
+                    manager_data = json.loads(text)
 
                     # Recreate the manager
                     manager = ZellijLayoutGenerator()
@@ -493,7 +494,7 @@ if __name__ == "__main__":
 
         # Print attachment commands (without actually starting)
         print("\n📎 Attachment commands:")
-        print(manager.attach_to_session())
+        print(manager.attach_to_session(None))
 
         # Show current status
         print("\n🔍 Current status:")
@@ -501,7 +502,7 @@ if __name__ == "__main__":
 
         # Demonstrate save/load
         print("\n💾 Demonstrating save/load...")
-        session_id = manager.save()
+        session_id = manager.save(None)
         print(f"✅ Saved session: {session_id}")
 
         # List saved sessions
@@ -515,6 +516,8 @@ if __name__ == "__main__":
         # Show how to start monitoring (commented out to prevent infinite loop in demo)
         print("\n⏰ To start monitoring, run:")
         print("manager.run_monitoring_routine(wait_ms=30000)  # 30 seconds")
+        print("# Or with session cleanup:")
+        print("manager.run_monitoring_routine(wait_ms=30000, kill_sessions_on_completion=True)")
 
     except Exception as e:
         print(f"❌ Error: {e}")

machineconfig/cluster/sessions_managers/zellij_remote.py

@@ -24,7 +24,7 @@ TMP_LAYOUT_DIR = Path.home().joinpath("tmp_results", "zellij_layouts", "layout_m
 class ZellijRemoteLayoutGenerator:
     def __init__(self, remote_name: str, session_name_prefix: str):
         self.remote_name = remote_name
-        self.session_name = session_name_prefix + "_" + LayoutGenerator.generate_random_suffix()
+        self.session_name = session_name_prefix + "_" + LayoutGenerator.generate_random_suffix(8)
         self.layout_config: Optional[LayoutConfig] = None
         self.layout_path: Optional[str] = None
 
@@ -35,10 +35,7 @@ class ZellijRemoteLayoutGenerator:
         self.session_manager = SessionManager(self.remote_executor, self.session_name, TMP_LAYOUT_DIR)
         self.status_reporter = StatusReporter(self.process_monitor, self.session_manager)
 
-    def copy_layout_to_remote(self, local_layout_file: Path, random_suffix: str) -> str:
-        return self.session_manager.copy_layout_to_remote(local_layout_file, random_suffix)
-
-    def create_zellij_layout(self, layout_config: LayoutConfig, output_dir: Optional[str] = None) -> str:
+    def create_zellij_layout(self, layout_config: LayoutConfig, output_dir: Optional[str]) -> str:
         # Enhanced Rich logging for remote layout creation
         tab_count = len(layout_config["layoutTabs"])
         layout_name = layout_config["layoutName"]
@@ -56,63 +53,16 @@ class ZellijRemoteLayoutGenerator:
         self.layout_path = self.layout_generator.create_layout_file(layout_config, output_path, self.session_name)
         return self.layout_path
 
-    def get_layout_preview(self, layout_config: LayoutConfig) -> str:
-        return self.layout_generator.generate_layout_content(layout_config)
-
-    def check_command_status(self, tab_name: str, use_verification: bool = True) -> Dict[str, Any]:
-        if not self.layout_config:
-            return {"status": "error", "error": "No layout config available", "running": False}
-        return self.process_monitor.check_command_status(tab_name, self.layout_config, use_verification)
-
-    def check_all_commands_status(self) -> Dict[str, Dict[str, Any]]:
-        if not self.layout_config:
-            return {}
-        return self.process_monitor.check_all_commands_status(self.layout_config)
-
-    def check_zellij_session_status(self) -> Dict[str, Any]:
-        return self.session_manager.check_zellij_session_status()
-
-    def get_comprehensive_status(self) -> Dict[str, Any]:
-        if not self.layout_config:
-            return {"error": "No layout config available"}
-        return self.status_reporter.get_comprehensive_status(self.layout_config)
-
-    def print_status_report(self) -> None:
-        if not self.layout_config:
-            console.print("[bold red]❌ No layout config available[/bold red]")
-            return
-        self.status_reporter.print_status_report(self.layout_config)
-
-    def start_zellij_session(self, layout_file_path: Optional[str] = None) -> Dict[str, Any]:
-        return self.session_manager.start_zellij_session(layout_file_path or self.layout_path)
-
-    def attach_to_session(self) -> None:
-        self.session_manager.attach_to_session()
-
-    # Legacy methods for backward compatibility
-    def force_fresh_process_check(self, tab_name: str) -> Dict[str, Any]:
-        if not self.layout_config:
-            return {"error": "No layout config available"}
-        return self.process_monitor.force_fresh_process_check(tab_name, self.layout_config)
-
-    def verify_process_alive(self, pid: int) -> bool:
-        return self.process_monitor.verify_process_alive(pid)
-
-    def get_verified_process_status(self, tab_name: str) -> Dict[str, Any]:
-        if not self.layout_config:
-            return {"error": "No layout config available"}
-        return self.process_monitor.get_verified_process_status(tab_name, self.layout_config)
-
     # Static methods for backward compatibility
     @staticmethod
-    def run_remote_command(remote_name: str, command: str, timeout: int = 30):
+    def run_remote_command(remote_name: str, command: str, timeout: int):
         executor = RemoteExecutor(remote_name)
         return executor.run_command(command, timeout)
 
     def to_dict(self) -> Dict[str, Any]:
         return {"remote_name": self.remote_name, "session_name": self.session_name, "layout_config": self.layout_config, "layout_path": self.layout_path, "created_at": datetime.now().isoformat(), "class_name": self.__class__.__name__}
 
-    def to_json(self, file_path: Optional[Union[str, Path]] = None) -> str:
+    def to_json(self, file_path: Optional[Union[str, Path]]) -> str:
         # Generate file path if not provided
         if file_path is None:
             random_id = str(uuid.uuid4())[:8]
@@ -150,8 +100,8 @@ class ZellijRemoteLayoutGenerator:
             raise FileNotFoundError(f"JSON file not found: {file_path}")
 
         # Load JSON data
-        with open(file_path, "r", encoding="utf-8") as f:
-            data = json.load(f)
+        text = Path(file_path).read_text(encoding="utf-8")
+        data = json.loads(text)
 
         # Validate that it's the correct class
         if data.get("class_name") != cls.__name__:
@@ -176,7 +126,7 @@ class ZellijRemoteLayoutGenerator:
         return instance
 
     @staticmethod
-    def list_saved_sessions(directory_path: Optional[Union[str, Path]] = None) -> List[str]:
+    def list_saved_sessions(directory_path: Optional[Union[str, Path]]) -> List[str]:
         if directory_path is None:
             directory_path = Path.home() / "tmp_results" / "zellij_sessions" / "serialized"
         else:
@@ -208,16 +158,16 @@ if __name__ == "__main__":
     try:
         # Create layout using the remote generator
         generator = ZellijRemoteLayoutGenerator(remote_name=remote_name, session_name_prefix=session_name)
-        layout_path = generator.create_zellij_layout(sample_layout)
+        layout_path = generator.create_zellij_layout(sample_layout, None)
         print(f"✅ Remote layout created successfully: {layout_path}")
 
         # Demonstrate serialization
         print("\n💾 Demonstrating serialization...")
-        saved_path = generator.to_json()
+        saved_path = generator.to_json(None)
         print(f"✅ Session saved to: {saved_path}")
 
         # List all saved sessions
-        saved_sessions = ZellijRemoteLayoutGenerator.list_saved_sessions()
+        saved_sessions = ZellijRemoteLayoutGenerator.list_saved_sessions(None)
         print(f"📋 Available saved sessions: {saved_sessions}")
 
         # Demonstrate loading (using the full path)
@@ -229,7 +179,10 @@ if __name__ == "__main__":
 
         # Demonstrate status checking
         print(f"\n🔍 Checking command status on remote '{remote_name}':")
-        generator.print_status_report()
+        if not generator.layout_config:
+            console.print("[bold red]❌ No layout config available[/bold red]")
+        else:
+            generator.status_reporter.print_status_report(generator.layout_config)
 
         # Start the session (uncomment to actually start)
         # start_result = generator.start_zellij_session()

machineconfig/cluster/sessions_managers/zellij_remote_manager.py

@@ -15,13 +15,13 @@ logger = get_logger("cluster.sessions_managers.zellij_remote_manager")
 
 
 class ZellijSessionManager:
-    def __init__(self, machine_layouts: Dict[str, LayoutConfig], session_name_prefix: str = "JobMgr"):
+    def __init__(self, machine_layouts: Dict[str, LayoutConfig], session_name_prefix: str):
         self.session_name_prefix = session_name_prefix
         self.machine_layouts = machine_layouts  # Store the original config
         self.managers: list[ZellijRemoteLayoutGenerator] = []
         for machine, layout_config in machine_layouts.items():
             an_m = ZellijRemoteLayoutGenerator(remote_name=machine, session_name_prefix=self.session_name_prefix)
-            an_m.create_zellij_layout(layout_config=layout_config)
+            an_m.create_zellij_layout(layout_config=layout_config, output_dir=None)
             self.managers.append(an_m)
 
     def ssh_to_all_machines(self) -> str:
@@ -40,18 +40,21 @@ class ZellijSessionManager:
 
     def kill_all_sessions(self) -> None:
         for an_m in self.managers:
-            ZellijRemoteLayoutGenerator.run_remote_command(remote_name=an_m.remote_name, command="zellij kill-all-sessions --yes")
+            ZellijRemoteLayoutGenerator.run_remote_command(remote_name=an_m.remote_name, command="zellij kill-all-sessions --yes", timeout=30)
 
     def start_zellij_sessions(self) -> None:
         for an_m in self.managers:
-            an_m.start_zellij_session()
+            an_m.session_manager.start_zellij_session(an_m.layout_path)
 
     def run_monitoring_routine(self) -> None:
         def routine(scheduler: Scheduler):
             if scheduler.cycle % 2 == 0:
                 statuses = []
                 for _idx, an_m in enumerate(self.managers):
-                    a_status = an_m.check_all_commands_status()
+                    if not an_m.layout_config:
+                        a_status = {}
+                    else:
+                        a_status = an_m.process_monitor.check_all_commands_status(an_m.layout_config)
                     statuses.append(a_status)
                 keys = []
                 for item in statuses:
@@ -76,7 +79,7 @@ class ZellijSessionManager:
             else:
                 statuses = []
                 for _idx, an_m in enumerate(self.managers):
-                    a_status = an_m.check_zellij_session_status()
+                    a_status = an_m.session_manager.check_zellij_session_status()
                     statuses.append(a_status)
 
                 # Print statuses
@@ -86,7 +89,7 @@ class ZellijSessionManager:
         sched = Scheduler(routine=routine, wait_ms=60_000, logger=logger)
         sched.run()
 
-    def save(self, session_id: Optional[str] = None) -> str:
+    def save(self, session_id: Optional[str]) -> str:
         if session_id is None:
             session_id = str(uuid.uuid4())[:8]
 
@@ -124,16 +127,16 @@ class ZellijSessionManager:
         config_file = session_dir / "machine_layouts.json"
         if not config_file.exists():
             raise FileNotFoundError(f"Configuration file not found: {config_file}")
-        with open(config_file, "r", encoding="utf-8") as f:
-            machine_layouts = json.load(f)
+        text = config_file.read_text(encoding="utf-8")
+        machine_layouts = json.loads(text)
 
         # Load metadata
         metadata_file = session_dir / "metadata.json"
         session_name_prefix = "JobMgr"  # default fallback
         if metadata_file.exists():
-            with open(metadata_file, "r", encoding="utf-8") as f:
-                metadata = json.load(f)
-                session_name_prefix = metadata.get("session_name_prefix", "JobMgr")
+            text = metadata_file.read_text(encoding="utf-8")
+            metadata = json.loads(text)
+            session_name_prefix = metadata.get("session_name_prefix", "JobMgr")
         # Create new instance (this will create new managers)
         instance = cls(machine_layouts=machine_layouts, session_name_prefix=session_name_prefix)
         # Load saved managers to restore their states

machineconfig/cluster/sessions_managers/zellij_utils/example_usage.py

@@ -3,9 +3,12 @@
 Example usage of the modularized Zellij remote layout generator.
 """
 
+from rich.console import Console
 from machineconfig.cluster.sessions_managers.zellij_remote import ZellijRemoteLayoutGenerator
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
 
+console = Console()
+
 
 def example_usage():
     """Demonstrate the refactored modular usage."""
@@ -30,16 +33,19 @@ def example_usage():
         generator = ZellijRemoteLayoutGenerator(remote_name=remote_name, session_name_prefix=session_name)
 
         # Create layout file
-        layout_path = generator.create_zellij_layout(sample_layout)
+        layout_path = generator.create_zellij_layout(sample_layout, None)
         print(f"✅ Remote layout created successfully: {layout_path}")
 
         # Preview the layout content
-        preview = generator.get_layout_preview(sample_layout)
+        preview = generator.layout_generator.generate_layout_content(sample_layout)
         print(f"📄 Layout preview:\n{preview}")
 
         # Check status using the modular components
         print(f"\n🔍 Checking command status on remote '{remote_name}':")
-        generator.print_status_report()
+        if not generator.layout_config:
+            console.print("[bold red]❌ No layout config available[/bold red]")
+        else:
+            generator.status_reporter.print_status_report(generator.layout_config)
 
         # The individual components can also be used directly:
         print("\n🔧 Direct component usage examples:")

machineconfig/cluster/sessions_managers/zellij_utils/layout_generator.py

@@ -31,7 +31,7 @@ class LayoutGenerator:
 """
 
     @staticmethod
-    def generate_random_suffix(length: int = 8) -> str:
+    def generate_random_suffix(length: int) -> str:
         """Generate a random string suffix for unique layout file names."""
         return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
 
@@ -121,7 +121,7 @@ class LayoutGenerator:
         self.validate_tab_config(layout_config)
 
         # Generate unique suffix for this layout
-        random_suffix = self.generate_random_suffix()
+        random_suffix = self.generate_random_suffix(8)
         layout_content = self.generate_layout_content(layout_config)
 
         try:

machineconfig/cluster/sessions_managers/zellij_utils/monitoring_types.py

@@ -1,7 +1,5 @@
-# TypedDict definitions for better type safety
-from typing import NotRequired, TypedDict, Optional
 
-# Import concrete types to replace Any usage
+from typing import NotRequired, TypedDict, Optional
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
 
 
@@ -10,47 +8,37 @@ class ProcessInfo(TypedDict):
     name: str
     cmdline: list[str]
     status: str
+    cmdline_str: NotRequired[str]
+    create_time: NotRequired[float]
+    is_direct_command: NotRequired[bool]
+    verified_alive: NotRequired[bool]
+    memory_mb: NotRequired[float]
+
 
 class CommandStatus(TypedDict):
-    status: str
-    running: bool
-    processes: list[ProcessInfo]
-    command: str
-    cwd: str
-    tab_name: str
+    status: str                   # e.g. running | not_running | unknown | error
+    running: bool                 # Convenience boolean
+    processes: list[ProcessInfo]  # Matching processes (can be empty)
+    command: str                  # Original command string ('' if unknown)
+    tab_name: str                 # Tab identifier
+    # Optional / contextual fields
+    cwd: NotRequired[str]
     error: NotRequired[str]
     pid: NotRequired[int]
-
-
-class SessionStatus(TypedDict):
-    session_exists: bool
-    zellij_running: bool
-    session_name: str
-    all_sessions: list[str]
-    error: NotRequired[str]
-
-
+    remote: NotRequired[str]
+    check_timestamp: NotRequired[str | float]
+    method: NotRequired[str]
+    raw_output: NotRequired[str]
+    verification_method: NotRequired[str]
 class CommandSummary(TypedDict):
     total_commands: int
     running_commands: int
     stopped_commands: int
     session_healthy: bool
 
-
-class CommandStatusResult(TypedDict):
-    status: str
-    running: bool
-    processes: list[ProcessInfo]
-    command: str
-    cwd: str
-    tab_name: str
-    error: NotRequired[str]
-    pid: NotRequired[int]
-
-
 class ZellijSessionStatus(TypedDict):
     zellij_running: bool
-    session_exists: NotRequired[bool]
+    session_exists: bool
     session_name: str
     all_sessions: list[str]
     error: NotRequired[str]
@@ -58,8 +46,27 @@ class ZellijSessionStatus(TypedDict):
 
 class SessionReport(TypedDict):
     session_status: ZellijSessionStatus  # ZellijSessionStatus from zellij_local
-    commands_status: dict[str, CommandStatusResult]  # dict[str, CommandStatusResult from zellij_local]  
+    commands_status: dict[str, CommandStatus]  # dict[str, CommandStatus from zellij_local]
     summary: CommandSummary
+class ComprehensiveStatus(TypedDict):
+    zellij_session: ZellijSessionStatus
+    commands: dict[str, CommandStatus]
+    summary: CommandSummary
+class SessionMetadata(TypedDict):
+    session_name_prefix: str
+    created_at: str
+    num_managers: int
+    sessions: list[str]
+    manager_type: str
+class ManagerData(TypedDict):
+    session_name: Optional[str]
+    layout_config: Optional[LayoutConfig]  # Will be LayoutConfig from layout_types
+    layout_path: Optional[str]
+class ActiveSessionInfo(TypedDict):
+    session_name: str
+    is_active: bool
+    tab_count: int
+    tabs: list[str]
 
 
 class GlobalSummary(TypedDict):
@@ -77,8 +84,6 @@ class StartResult(TypedDict):
     success: bool
     message: NotRequired[str]
     error: NotRequired[str]
-
-
 class StatusRow(TypedDict):
     session: str
     tab: str
@@ -87,35 +92,3 @@ class StatusRow(TypedDict):
     processes: int
 
 
-class SessionMetadata(TypedDict):
-    session_name_prefix: str
-    created_at: str
-    num_managers: int
-    sessions: list[str]
-    manager_type: str
-
-
-class ManagerData(TypedDict):
-    session_name: Optional[str]
-    layout_config: Optional[LayoutConfig]  # Will be LayoutConfig from layout_types
-    layout_path: Optional[str]
-
-
-class ActiveSessionInfo(TypedDict):
-    session_name: str
-    is_active: bool
-    tab_count: int
-    tabs: list[str]
-
-
-class StatusSummary(TypedDict):
-    total_commands: int
-    running_commands: int
-    stopped_commands: int
-    session_healthy: bool
-
-
-class ComprehensiveStatus(TypedDict):
-    zellij_session: ZellijSessionStatus
-    commands: dict[str, CommandStatusResult]
-    summary: StatusSummary