machineconfig 5.22__py3-none-any.whl → 5.23__py3-none-any.whl

machineconfig/cluster/sessions_managers/wt_remote.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-from typing import Dict, Optional, List, Any
+from typing import Optional, Any
 from pathlib import Path
 import logging
 import json
@@ -11,18 +11,18 @@ from machineconfig.cluster.sessions_managers.wt_utils.layout_generator import WT
 from machineconfig.cluster.sessions_managers.wt_utils.process_monitor import WTProcessMonitor
 from machineconfig.cluster.sessions_managers.wt_utils.session_manager import WTSessionManager
 from machineconfig.cluster.sessions_managers.wt_utils.status_reporter import WTStatusReporter
-from machineconfig.utils.schemas.layouts.layout_types import TabConfig
+from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
-TMP_LAYOUT_DIR = Path.home().joinpath("tmp_results", "wt_layouts", "layout_manager")
+TMP_LAYOUT_DIR = Path.home() / "tmp_results" / "wt_layouts"
 
 
 class WTRemoteLayoutGenerator:
-    def __init__(self, remote_name: str, session_name_prefix: str):
-        self.remote_name = remote_name
-        self.session_name = session_name_prefix + "_" + WTLayoutGenerator.generate_random_suffix()
-        self.tabs: List[TabConfig] = []
+    def __init__(self, layout_config: LayoutConfig, remote_name: str, session_name: str):
+        self.remote_name: str = remote_name
+        self.session_name: str = session_name
+        self.layout_config: LayoutConfig = layout_config.copy()
         self.script_path: Optional[str] = None
 
         # Initialize modular components
@@ -32,22 +32,30 @@ class WTRemoteLayoutGenerator:
         self.session_manager = WTSessionManager(self.remote_executor, self.session_name, TMP_LAYOUT_DIR)
         self.status_reporter = WTStatusReporter(self.process_monitor, self.session_manager)
 
-    # Tabs are stored and used as List[TabConfig]; no legacy dict compatibility
-
-    def create_wt_layout(self, tabs: List[TabConfig], output_dir: Optional[str]) -> str:
-        logger.info(f"Creating Windows Terminal layout with {len(tabs)} tabs for remote '{self.remote_name}'")
-        self.tabs = tabs
-        if output_dir:
-            output_path = Path(output_dir)
-        else:
-            output_path = TMP_LAYOUT_DIR
-        self.script_path = self.layout_generator.create_wt_script(self.tabs, output_path, self.session_name)
-        return self.script_path
+    def create_layout_file(self) -> bool:
+        """Create Windows Terminal layout file and return success status."""
+        tab_count = len(self.layout_config["layoutTabs"])
+        logger.info(f"Creating Windows Terminal layout with {tab_count} tabs for remote '{self.remote_name}'")
+        
+        # Extract tabs from layout_config
+        tabs: list[TabConfig] = self.layout_config["layoutTabs"]
+        script_content = self.layout_generator.create_wt_script(tabs, self.session_name, window_name=None)
+        
+        # Write to file
+        tmp_layout_dir = Path.home() / "tmp_results" / "wt_layouts" / "remote"
+        tmp_layout_dir.mkdir(parents=True, exist_ok=True)
+        random_suffix = WTLayoutGenerator.generate_random_suffix(8)
+        script_file = tmp_layout_dir / f"wt_layout_{self.session_name}_{random_suffix}.ps1"
+        script_file.write_text(script_content, encoding="utf-8")
+        self.script_path = str(script_file.absolute())
+        
+        logger.info(f"✅ Remote layout created: {self.script_path}")
+        return True
 
     # Legacy methods for backward compatibility
 
-    def to_dict(self) -> Dict[str, Any]:
-        return {"remote_name": self.remote_name, "session_name": self.session_name, "tabs": self.tabs, "script_path": self.script_path, "created_at": datetime.now().isoformat(), "class_name": self.__class__.__name__}
+    def to_dict(self) -> dict[str, Any]:
+        return {"remote_name": self.remote_name, "session_name": self.session_name, "layout_config": self.layout_config, "script_path": self.script_path, "created_at": datetime.now().isoformat(), "class_name": self.__class__.__name__}
 
     def to_json(self, file_path: Optional[str]) -> str:
         # Generate file path if not provided
@@ -95,29 +103,18 @@ class WTRemoteLayoutGenerator:
             logger.warning(f"Class name mismatch: expected {cls.__name__}, got {data.get('class_name')}")
 
         # Create new instance
-        # Extract session name prefix by removing the suffix
-        session_name = data["session_name"]
-        if "_" in session_name:
-            session_name_prefix = "_".join(session_name.split("_")[:-1])
-        else:
-            session_name_prefix = session_name
-
-        instance = cls(remote_name=data["remote_name"], session_name_prefix=session_name_prefix)
-
-        # Restore state
-        instance.session_name = data["session_name"]
-        # New schema only
-        if "tabs" in data:
-            instance.tabs = data["tabs"]
-        else:
-            instance.tabs = []
+        instance = cls(
+            layout_config=data["layout_config"],
+            remote_name=data["remote_name"],
+            session_name=data["session_name"]
+        )
         instance.script_path = data["script_path"]
 
         logger.info(f"✅ Loaded WTRemoteLayoutGenerator from: {file_path}")
         return instance
 
     @staticmethod
-    def list_saved_sessions(directory_path: Optional[str]) -> List[str]:
+    def list_saved_sessions(directory_path: Optional[str]) -> list[str]:
         if directory_path is None:
             dir_path = Path.home() / "tmp_results" / "wt_sessions" / "serialized"
         else:
@@ -132,7 +129,7 @@ class WTRemoteLayoutGenerator:
 
 if __name__ == "__main__":
     # Example usage
-    sample_tabs: List[TabConfig] = [
+    sample_tabs: list[TabConfig] = [
         {"tabName": "🤖Bot1", "startDir": "~/code/bytesense/bithence", "command": "python bot1.py --create_new_bot True"},
         {"tabName": "🤖Bot2", "startDir": "~/code/bytesense/bithence", "command": "python bot2.py --create_new_bot True"},
         {"tabName": "📊Monitor", "startDir": "~", "command": "Get-Process | Sort-Object CPU -Descending | Select-Object -First 10"},
@@ -144,10 +141,21 @@ if __name__ == "__main__":
     session_name = "test_remote_session"
 
     try:
+        # Create layout config from tabs
+        sample_layout: LayoutConfig = {
+            "layoutName": "RemoteBots",
+            "layoutTabs": sample_tabs
+        }
+        
         # Create layout using the remote generator
-        generator = WTRemoteLayoutGenerator(remote_name=remote_name, session_name_prefix=session_name)
-        script_path = generator.create_wt_layout(sample_tabs, None)
-        print(f"✅ Remote layout created successfully: {script_path}")
+        generator = WTRemoteLayoutGenerator(
+            layout_config=sample_layout,
+            remote_name=remote_name,
+            session_name=session_name
+        )
+        generator.create_layout_file()
+        
+        print(f"✅ Remote layout created successfully: {generator.script_path}")
 
         # Check if Windows Terminal is available on remote
         wt_available = generator.remote_executor.check_wt_available()
@@ -170,7 +178,7 @@ if __name__ == "__main__":
         # Demonstrate loading (using the full path)
         loaded_generator = WTRemoteLayoutGenerator.from_json(saved_path)
         print(f"✅ Session loaded successfully: {loaded_generator.session_name}")
-        print(f"📊 Loaded tabs: {[tab['tabName'] for tab in loaded_generator.tabs]}")
+        print(f"📊 Loaded tabs: {[tab['tabName'] for tab in loaded_generator.layout_config['layoutTabs']]}")
 
         # Show command preview
         preview = generator.layout_generator.generate_wt_command(sample_tabs)
@@ -178,7 +186,7 @@ if __name__ == "__main__":
 
         # Demonstrate status checking
         print(f"\n🔍 Checking command status on remote '{remote_name}':")
-        generator.status_reporter.print_status_report(generator.tabs)
+        generator.status_reporter.print_status_report(sample_tabs)
 
         # Show Windows Terminal overview
         print("\n🖥️  Windows Terminal Overview:")

machineconfig/cluster/sessions_managers/wt_remote_manager.py

@@ -8,13 +8,14 @@ from rich.console import Console
 from machineconfig.utils.scheduler import Scheduler
 from machineconfig.cluster.sessions_managers.wt_local import run_command_in_wt_tab
 from machineconfig.cluster.sessions_managers.wt_remote import WTRemoteLayoutGenerator
-from machineconfig.utils.schemas.layouts.layout_types import TabConfig
+from machineconfig.cluster.sessions_managers.wt_utils.layout_generator import WTLayoutGenerator
+from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig
 
-TMP_SERIALIZATION_DIR = Path.home().joinpath("tmp_results", "session_manager", "wt", "remote_manager")
 
 # Module-level logger to be used throughout this module
 logger = logging.getLogger(__name__)
 console = Console()
+TMP_SERIALIZATION_DIR = Path.home() / "tmp_results" / "wt_sessions" / "serialized"
 
 
 class WTSessionManager:
@@ -23,10 +24,15 @@ class WTSessionManager:
         self.machine2wt_tabs = machine2wt_tabs  # Store the original config
         self.managers: list[WTRemoteLayoutGenerator] = []
         for machine, tab_config in machine2wt_tabs.items():
-            an_m = WTRemoteLayoutGenerator(remote_name=machine, session_name_prefix=self.session_name_prefix)
-            # Convert legacy dict[str, tuple[str,str]] to List[TabConfig]
+            # Convert legacy dict[str, tuple[str,str]] to LayoutConfig
             tabs: list[TabConfig] = [{"tabName": name, "startDir": cwd, "command": cmd} for name, (cwd, cmd) in tab_config.items()]
-            an_m.create_wt_layout(tabs=tabs, output_dir=None)
+            layout_config: LayoutConfig = {
+                "layoutName": f"{session_name_prefix}_{machine}",
+                "layoutTabs": tabs
+            }
+            session_name = f"{session_name_prefix}_{WTLayoutGenerator.generate_random_suffix(8)}"
+            an_m = WTRemoteLayoutGenerator(layout_config=layout_config, remote_name=machine, session_name=session_name)
+            an_m.create_layout_file()
             self.managers.append(an_m)
 
     def ssh_to_all_machines(self) -> str:
@@ -52,7 +58,8 @@ class WTSessionManager:
             if scheduler.cycle % 2 == 0:
                 statuses = []
                 for _idx, an_m in enumerate(self.managers):
-                    a_status = an_m.process_monitor.check_all_commands_status(an_m.tabs)
+                    tabs = an_m.layout_config["layoutTabs"]
+                    a_status = an_m.process_monitor.check_all_commands_status(tabs)
                     statuses.append(a_status)
                 keys = []
                 for item in statuses:
@@ -220,7 +227,8 @@ class WTSessionManager:
                 wt_status = manager.session_manager.check_wt_session_status()
 
                 # Get commands status for this session
-                commands_status = manager.process_monitor.check_all_commands_status(manager.tabs)
+                tabs = manager.layout_config["layoutTabs"]
+                commands_status = manager.process_monitor.check_all_commands_status(tabs)
 
                 # Calculate summary for this session
                 running_count = sum(1 for status in commands_status.values() if status.get("running", False))
@@ -343,7 +351,7 @@ class WTSessionManager:
                 # Get Windows Terminal version
                 wt_version = manager.session_manager.get_wt_version()
 
-                overview[remote_name] = {"windows_info": windows_info, "wt_processes": wt_processes, "wt_version": wt_version, "session_name": manager.session_name, "tab_count": len(manager.tabs)}
+                overview[remote_name] = {"windows_info": windows_info, "wt_processes": wt_processes, "wt_version": wt_version, "session_name": manager.session_name, "tab_count": len(manager.layout_config["layoutTabs"])}
 
             except Exception as e:
                 overview[manager.remote_name] = {"error": str(e), "session_name": manager.session_name}

machineconfig/cluster/sessions_managers/wt_utils/layout_generator.py

@@ -130,34 +130,21 @@ class WTLayoutGenerator:
 
         return " ".join(wt_parts)
 
-    def create_wt_script(self, tabs: List[TabConfig], output_dir: Path, session_name: str, window_name: str | None = None) -> str:
-        """Create a Windows Terminal PowerShell script and return its absolute path."""
+    def create_wt_script(self, tabs: List[TabConfig], session_name: str, window_name: str | None = None) -> str:
+        """Create a Windows Terminal PowerShell script content and return it as string."""
         self.validate_tab_config(tabs)
 
         # Generate unique suffix for this script
         random_suffix = self.generate_random_suffix()
         wt_command = self.generate_wt_command(tabs, window_name or session_name)
 
-        try:
-            # Create output directory if it doesn't exist
-            output_dir.mkdir(parents=True, exist_ok=True)
-
-            # Create PowerShell script
-            ps1_file = output_dir / f"wt_layout_{session_name}_{random_suffix}.ps1"
-
-            # Create PowerShell script content
-            text = f"""# Windows Terminal layout for {session_name}
+        # Create PowerShell script content
+        script_content = f"""# Windows Terminal layout for {session_name}
 # Generated on {random_suffix}
 {wt_command}
 """
-            ps1_file.write_text(text, encoding="utf-8")
-
-            logger.info(f"Windows Terminal PowerShell script created: {ps1_file.absolute()}")
-            return str(ps1_file.absolute())
-
-        except OSError as e:
-            logger.error(f"Failed to create PowerShell script: {e}")
-            raise
+        logger.info("Windows Terminal PowerShell script content generated")
+        return script_content
 
     def generate_split_pane_command(self, tabs: List[TabConfig], window_name: str | None = None) -> str:
         """Generate Windows Terminal command with split panes instead of separate tabs."""