machineconfig 2.2__py3-none-any.whl → 2.4__py3-none-any.whl

machineconfig/__init__.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+from pathlib import Path
+import tomllib
+
+
+def _get_version() -> str:
+	name: str = "machineconfig"
+	try:
+		return _pkg_version(name)
+	except PackageNotFoundError:
+		pass
+
+	root: Path = Path(__file__).resolve().parents[2]
+	pyproject: Path = root / "pyproject.toml"
+	if pyproject.is_file():
+		with pyproject.open("rb") as f:
+			data: dict[str, object] = tomllib.load(f)
+		project = data.get("project")
+		if isinstance(project, dict):
+			version = project.get("version")
+			if isinstance(version, str) and version:
+				return version
+	return "0.0.0"
+
+
+__version__: str = _get_version()
+__all__: list[str] = ["__version__"]
+

machineconfig/cluster/sessions_managers/enhanced_command_runner.py

@@ -84,7 +84,6 @@ def enhanced_zellij_session_start(session_name: str, layout_path: str) -> Dict[s
     """
     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(
@@ -93,7 +92,6 @@ def enhanced_zellij_session_start(session_name: str, layout_path: str) -> Dict[s
         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(

machineconfig/cluster/sessions_managers/layout_types.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""
+Type definitions for the standardized layout configuration schema.
+This module defines the data structures that match the layout.json schema.
+"""
+
+from typing import TypedDict, List
+
+
+class TabConfig(TypedDict):
+    """Configuration for a single tab in a layout."""
+
+    tabName: str
+    startDir: str
+    command: str
+
+
+class LayoutConfig(TypedDict):
+    """Configuration for a complete layout with its tabs."""
+
+    layoutName: str
+    layoutTabs: List[TabConfig]
+
+
+class LayoutsFile(TypedDict):
+    """Complete layout file structure."""
+
+    version: str
+    layouts: List[LayoutConfig]

machineconfig/cluster/sessions_managers/wt_local.py

@@ -13,6 +13,8 @@ from typing import Dict, List, Optional, Any
 from pathlib import Path
 import logging
 
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig, TabConfig
+
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 TMP_LAYOUT_DIR = Path.home().joinpath("tmp_results", "session_manager", "wt", "layout_manager")
@@ -21,12 +23,12 @@ TMP_LAYOUT_DIR = Path.home().joinpath("tmp_results", "session_manager", "wt", "l
 class WTLayoutGenerator:
     def __init__(self):
         self.session_name: Optional[str] = None
-        self.tab_config: Dict[str, tuple[str, str]] = {}  # Store entire tab config (cwd, command) for status checking
-        self.script_path: Optional[str] = None  # Store the full path to the script file
+        self.layout_config: Optional[LayoutConfig] = None  # Store the complete layout config
+        self.script_path: Optional[str] = None  # Store the full path to the PowerShell script
 
     @staticmethod
     def _generate_random_suffix(length: int = 8) -> str:
-        """Generate a random string suffix for unique script file names."""
+        """Generate a random string suffix for unique PowerShell script names."""
         return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
 
     @staticmethod
@@ -51,8 +53,12 @@ class WTLayoutGenerator:
         return text
 
     @staticmethod
-    def _create_tab_command(tab_name: str, cwd: str, command: str, is_first_tab: bool = False) -> str:
-        """Create a Windows Terminal tab command string."""
+    def _create_tab_command(tab_config: TabConfig, is_first_tab: bool = False) -> str:
+        """Create a Windows Terminal tab command string from tab config."""
+        tab_name = tab_config["tabName"]
+        cwd = tab_config["startDir"]
+        command = tab_config["command"]
+
         # Convert paths to Windows format if needed
         if cwd.startswith("~/"):
             cwd = cwd.replace("~/", f"{Path.home()}/")
@@ -77,63 +83,55 @@ class WTLayoutGenerator:
         return " ".join(tab_parts)
 
     @staticmethod
-    def _validate_tab_config(tab_config: Dict[str, tuple[str, str]]) -> None:
-        """Validate tab configuration format and content."""
-        if not tab_config:
-            raise ValueError("Tab configuration cannot be empty")
-        for tab_name, (cwd, command) in tab_config.items():
-            if not tab_name.strip():
-                raise ValueError(f"Invalid tab name: {tab_name}")
-            if not command.strip():
-                raise ValueError(f"Invalid command for tab '{tab_name}': {command}")
-            if not cwd.strip():
-                raise ValueError(f"Invalid cwd for tab '{tab_name}': {cwd}")
-
-    def create_wt_layout(self, tab_config: Dict[str, tuple[str, str]], output_dir: Optional[str] = None, session_name: Optional[str] = None) -> str:
-        WTLayoutGenerator._validate_tab_config(tab_config)
-        logger.info(f"Creating Windows Terminal layout with {len(tab_config)} tabs")
-
-        # Store session name and entire tab config for status checking
-        self.session_name = session_name or "default"
-        self.tab_config = tab_config.copy()
+    def _validate_layout_config(layout_config: LayoutConfig) -> None:
+        """Validate layout configuration format and content."""
+        if not layout_config["layoutTabs"]:
+            raise ValueError("Layout must contain at least one tab")
+        for tab in layout_config["layoutTabs"]:
+            if not tab["tabName"].strip():
+                raise ValueError(f"Invalid tab name: {tab['tabName']}")
+            if not tab["command"].strip():
+                raise ValueError(f"Invalid command for tab '{tab['tabName']}': {tab['command']}")
+            if not tab["startDir"].strip():
+                raise ValueError(f"Invalid startDir for tab '{tab['tabName']}': {tab['startDir']}")
+
+    def create_wt_layout(self, layout_config: LayoutConfig, output_dir: Optional[str] = None) -> str:
+        WTLayoutGenerator._validate_layout_config(layout_config)
+        logger.info(f"Creating Windows Terminal layout '{layout_config['layoutName']}' with {len(layout_config['layoutTabs'])} tabs")
+
+        # Store session name and layout config for status checking
+        self.session_name = layout_config["layoutName"]
+        self.layout_config = layout_config.copy()
 
         # Generate Windows Terminal command
-        wt_command = self._generate_wt_command_string(tab_config, self.session_name)
+        wt_command = self._generate_wt_command_string(layout_config, self.session_name)
 
         try:
             random_suffix = WTLayoutGenerator._generate_random_suffix()
             if output_dir:
                 output_path = Path(output_dir)
                 output_path.mkdir(parents=True, exist_ok=True)
-                script_file = output_path / f"wt_layout_{random_suffix}.bat"
+                script_file = output_path / f"wt_layout_{random_suffix}.ps1"
             else:
                 # Use the predefined TMP_LAYOUT_DIR for temporary files
                 TMP_LAYOUT_DIR.mkdir(parents=True, exist_ok=True)
-                script_file = TMP_LAYOUT_DIR / f"wt_layout_{self.session_name}_{random_suffix}.bat"
-
-            # Create batch script
-            text = f"""@echo off
-REM Windows Terminal layout for {self.session_name}
-{wt_command}
-"""
-            script_file.write_text(text, encoding="utf-8")
+                script_file = TMP_LAYOUT_DIR / f"wt_layout_{self.session_name}_{random_suffix}.ps1"
 
-            # Also create PowerShell script for better command handling
-            ps1_file = script_file.with_suffix(".ps1")
+            # Create PowerShell script
             text = f"""# Windows Terminal layout for {self.session_name}
 # Generated with random suffix: {random_suffix}
 {wt_command}
 """
-            ps1_file.write_text(text, encoding="utf-8")
+            script_file.write_text(text, encoding="utf-8")
 
             self.script_path = str(script_file.absolute())
-            logger.info(f"Windows Terminal script file created: {self.script_path}")
+            logger.info(f"Windows Terminal PowerShell script created: {self.script_path}")
             return self.script_path
         except OSError as e:
-            logger.error(f"Failed to create script file: {e}")
+            logger.error(f"Failed to create PowerShell script: {e}")
             raise
 
-    def _generate_wt_command_string(self, tab_config: Dict[str, tuple[str, str]], window_name: str) -> str:
+    def _generate_wt_command_string(self, layout_config: LayoutConfig, window_name: str) -> str:
         """Generate complete Windows Terminal command string."""
         # Start building the wt command
         wt_parts = ["wt"]
@@ -143,9 +141,9 @@ REM Windows Terminal layout for {self.session_name}
 
         # Add tabs
         tab_commands = []
-        for i, (tab_name, (cwd, command)) in enumerate(tab_config.items()):
+        for i, tab in enumerate(layout_config["layoutTabs"]):
             is_first = i == 0
-            tab_cmd = self._create_tab_command(tab_name, cwd, command, is_first)
+            tab_cmd = self._create_tab_command(tab, is_first)
             tab_commands.append(tab_cmd)
 
         # Join all parts with semicolons (Windows Terminal command separator)
@@ -161,19 +159,20 @@ REM Windows Terminal layout for {self.session_name}
 
         return " ".join(wt_parts)
 
-    def get_wt_layout_preview(self, tab_config: Dict[str, tuple[str, str]]) -> str:
+    def get_wt_layout_preview(self, layout_config: LayoutConfig) -> str:
         """Generate preview of the Windows Terminal command that would be created."""
-        WTLayoutGenerator._validate_tab_config(tab_config)
-        return self._generate_wt_command_string(tab_config, "preview")
+        WTLayoutGenerator._validate_layout_config(layout_config)
+        return self._generate_wt_command_string(layout_config, "preview")
 
     def check_all_commands_status(self) -> Dict[str, Dict[str, Any]]:
-        if not self.tab_config:
-            logger.warning("No tab config tracked. Make sure to create a layout first.")
+        if not self.layout_config:
+            logger.warning("No layout config tracked. Make sure to create a layout first.")
             return {}
 
         status_report = {}
-        for tab_name in self.tab_config:
-            status_report[tab_name] = WTLayoutGenerator.check_command_status(tab_name, self.tab_config)
+        for tab in self.layout_config["layoutTabs"]:
+            tab_name = tab["tabName"]
+            status_report[tab_name] = WTLayoutGenerator.check_command_status(tab_name, self.layout_config)
 
         return status_report
 
@@ -218,12 +217,19 @@ REM Windows Terminal layout for {self.session_name}
             return {"wt_running": False, "error": str(e), "session_name": session_name}
 
     @staticmethod
-    def check_command_status(tab_name: str, tab_config: Dict[str, tuple[str, str]]) -> Dict[str, Any]:
+    def check_command_status(tab_name: str, layout_config: LayoutConfig) -> Dict[str, Any]:
         """Check if a command is running by looking for processes."""
-        if tab_name not in tab_config:
-            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in tracked configuration", "running": False, "pid": None, "command": None}
+        # Find the tab with the given name
+        tab_config = None
+        for tab in layout_config["layoutTabs"]:
+            if tab["tabName"] == tab_name:
+                tab_config = tab
+                break
+
+        if tab_config is None:
+            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in layout config", "running": False, "pid": None, "command": None}
 
-        _, command = tab_config[tab_name]
+        command = tab_config["command"]
 
         try:
             # Create PowerShell script to check for processes
@@ -361,22 +367,22 @@ Get-Process | ForEach-Object {{
         print("=" * 80)
 
 
-def create_wt_layout(tab_config: Dict[str, tuple[str, str]], output_dir: Optional[str] = None) -> str:
+def create_wt_layout(layout_config: LayoutConfig, output_dir: Optional[str] = None) -> str:
     generator = WTLayoutGenerator()
-    return generator.create_wt_layout(tab_config, output_dir)
+    return generator.create_wt_layout(layout_config, output_dir)
 
 
-def run_wt_layout(tab_config: Dict[str, tuple[str, str]], session_name: Optional[str] = None) -> str:
+def run_wt_layout(layout_config: LayoutConfig) -> str:
     """Create and run a Windows Terminal layout."""
     generator = WTLayoutGenerator()
-    script_path = generator.create_wt_layout(tab_config, session_name=session_name)
+    script_path = generator.create_wt_layout(layout_config)
 
     # Execute the script
     cmd = f'powershell -ExecutionPolicy Bypass -File "{script_path}"'
     result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
 
     if result.returncode == 0:
-        print(f"Windows Terminal layout is running @ {session_name}")
+        print(f"Windows Terminal layout is running @ {layout_config['layoutName']}")
         return script_path
     else:
         logger.error(f"Failed to run Windows Terminal layout: {result.stderr}")
@@ -394,17 +400,17 @@ wt new-tab --title "{tab_name}" {cwd_part} "{command}"
 
 
 if __name__ == "__main__":
-    # Example usage
-    sample_tabs = {"Frontend": ("~/code", "btm"), "Monitor": ("~", "lf")}
+    # Example usage with new schema
+    sample_layout: LayoutConfig = {"layoutName": "TestLayout", "layoutTabs": [{"tabName": "Frontend", "startDir": "~/code", "command": "btm"}, {"tabName": "Monitor", "startDir": "~", "command": "lf"}]}
 
     try:
         # Create layout using the generator
         generator = WTLayoutGenerator()
-        script_path = generator.create_wt_layout(sample_tabs, session_name="test_session")
+        script_path = generator.create_wt_layout(sample_layout)
         print(f"✅ Windows Terminal layout created: {script_path}")
 
         # Show preview
-        preview = generator.get_wt_layout_preview(sample_tabs)
+        preview = generator.get_wt_layout_preview(sample_layout)
         print(f"\n📋 Command Preview:\n{preview}")
 
         # Check status (won't find anything since we haven't run it)

machineconfig/cluster/sessions_managers/wt_local_manager.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from typing import Optional, Dict, List, Any
 from machineconfig.utils.utils5 import Scheduler
 from machineconfig.cluster.sessions_managers.wt_local import WTLayoutGenerator
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -18,24 +19,23 @@ TMP_SERIALIZATION_DIR = Path.home().joinpath("tmp_results", "session_manager", "
 class WTLocalManager:
     """Manages multiple local Windows Terminal sessions and monitors their tabs and processes."""
 
-    def __init__(self, session2wt_tabs: Dict[str, Dict[str, tuple[str, str]]], session_name_prefix: str = "LocalWTMgr"):
+    def __init__(self, session_layouts: list[LayoutConfig], session_name_prefix: str = "LocalWTMgr"):
         """
         Initialize the local Windows Terminal manager.
 
         Args:
-            session2wt_tabs: Dict mapping session names to their tab configs
-                Format: {session_name: {tab_name: (cwd, command), ...}, ...}
+            session_layouts: Dict mapping session names to their layout configs
+                Format: {session_name: LayoutConfig, ...}
             session_name_prefix: Prefix for session names
         """
         self.session_name_prefix = session_name_prefix
-        self.session2wt_tabs = session2wt_tabs  # Store the original config
+        self.session_layouts = session_layouts  # Store the original config
         self.managers: List[WTLayoutGenerator] = []
 
         # Create a WTLayoutGenerator for each session
-        for session_name, tab_config in session2wt_tabs.items():
+        for layout_config in session_layouts:
             manager = WTLayoutGenerator()
-            full_session_name = f"{self.session_name_prefix}_{session_name}"
-            manager.create_wt_layout(tab_config=tab_config, session_name=full_session_name)
+            manager.create_wt_layout(layout_config=layout_config)
             self.managers.append(manager)
 
         logger.info(f"Initialized WTLocalManager with {len(self.managers)} sessions")
@@ -288,12 +288,12 @@ class WTLocalManager:
         session_dir.mkdir(parents=True, exist_ok=True)
 
         # Save the session2wt_tabs configuration
-        config_file = session_dir / "session2wt_tabs.json"
-        text = json.dumps(self.session2wt_tabs, indent=2, ensure_ascii=False)
+        config_file = session_dir / "session_layouts.json"
+        text = json.dumps(self.session_layouts, indent=2, ensure_ascii=False)
         config_file.write_text(text, encoding="utf-8")
 
         # Save metadata
-        metadata = {"session_name_prefix": self.session_name_prefix, "created_at": str(datetime.now()), "num_managers": len(self.managers), "sessions": list(self.session2wt_tabs.keys()), "manager_type": "WTLocalManager"}
+        metadata = {"session_name_prefix": self.session_name_prefix, "created_at": str(datetime.now()), "num_managers": len(self.managers), "sessions": [item["layoutName"] for item in self.session_layouts], "manager_type": "WTLocalManager"}
         metadata_file = session_dir / "metadata.json"
         text = json.dumps(metadata, indent=2, ensure_ascii=False)
         metadata_file.write_text(text, encoding="utf-8")
@@ -303,7 +303,7 @@ class WTLocalManager:
         managers_dir.mkdir(exist_ok=True)
 
         for i, manager in enumerate(self.managers):
-            manager_data = {"session_name": manager.session_name, "tab_config": manager.tab_config, "script_path": manager.script_path}
+            manager_data = {"session_name": manager.session_name, "layout_config": manager.layout_config, "script_path": manager.script_path}
             manager_file = managers_dir / f"manager_{i}_{manager.session_name}.json"
             text = json.dumps(manager_data, indent=2, ensure_ascii=False)
             manager_file.write_text(text, encoding="utf-8")
@@ -320,12 +320,12 @@ class WTLocalManager:
             raise FileNotFoundError(f"Session directory not found: {session_dir}")
 
         # Load configuration
-        config_file = session_dir / "session2wt_tabs.json"
+        config_file = session_dir / "session_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:
-            session2wt_tabs = json.load(f)
+            session_layouts = json.load(f)
 
         # Load metadata
         metadata_file = session_dir / "metadata.json"
@@ -336,7 +336,7 @@ class WTLocalManager:
                 session_name_prefix = metadata.get("session_name_prefix", "LocalWTMgr")
 
         # Create new instance
-        instance = cls(session2wt_tabs=session2wt_tabs, session_name_prefix=session_name_prefix)
+        instance = cls(session_layouts=session_layouts, session_name_prefix=session_name_prefix)
 
         # Load saved manager states
         managers_dir = session_dir / "managers"
@@ -352,7 +352,7 @@ class WTLocalManager:
                     # Recreate the manager
                     manager = WTLayoutGenerator()
                     manager.session_name = manager_data["session_name"]
-                    manager.tab_config = manager_data["tab_config"]
+                    manager.layout_config = manager_data["layout_config"]
                     manager.script_path = manager_data["script_path"]
 
                     instance.managers.append(manager)
@@ -422,7 +422,15 @@ class WTLocalManager:
                         if session_name in window_title or not window_title:
                             session_windows.append(proc)
 
-                    active_sessions.append({"session_name": session_name, "is_active": len(session_windows) > 0, "tab_count": len(manager.tab_config), "tabs": list(manager.tab_config.keys()), "windows": session_windows})
+                    active_sessions.append(
+                        {
+                            "session_name": session_name,
+                            "is_active": len(session_windows) > 0,
+                            "tab_count": len(manager.layout_config["layoutTabs"]) if manager.layout_config else 0,
+                            "tabs": [tab["tabName"] for tab in manager.layout_config["layoutTabs"]] if manager.layout_config else [],
+                            "windows": session_windows,
+                        }
+                    )
 
         except Exception as e:
             logger.error(f"Error listing active sessions: {e}")
@@ -451,12 +459,33 @@ class WTLocalManager:
 
 
 if __name__ == "__main__":
-    # Example usage
-    sample_sessions = {
-        "development": {"🚀Frontend": ("~/code/myapp/frontend", "npm run dev"), "⚙️Backend": ("~/code/myapp/backend", "python manage.py runserver"), "📊Monitor": ("~", "Get-Process | Sort-Object CPU -Descending | Select-Object -First 10")},
-        "testing": {"🧪Tests": ("~/code/myapp", "pytest --watch"), "🔍Coverage": ("~/code/myapp", "python -m coverage run --source=. -m pytest"), "📝Logs": ("~/logs", "Get-Content app.log -Wait")},
-        "deployment": {"🐳Docker": ("~/code/myapp", "docker-compose up"), "☸️K8s": ("~/k8s", "kubectl get pods --watch"), "📈Metrics": ("~", 'Get-Counter "\\Processor(_Total)\\% Processor Time" -SampleInterval 2 -MaxSamples 30')},
-    }
+    # Example usage with new schema
+    sample_sessions: list[LayoutConfig] = [
+        {
+            "layoutName": "DevelopmentEnv",
+            "layoutTabs": [
+                {"tabName": "🚀Frontend", "startDir": "~/code/myapp/frontend", "command": "npm run dev"},
+                {"tabName": "⚙️Backend", "startDir": "~/code/myapp/backend", "command": "python manage.py runserver"},
+                {"tabName": "📊Monitor", "startDir": "~", "command": "Get-Process | Sort-Object CPU -Descending | Select-Object -First 10"},
+            ],
+        },
+        {
+            "layoutName": "TestingEnv",
+            "layoutTabs": [
+                {"tabName": "🧪Tests", "startDir": "~/code/myapp", "command": "pytest --watch"},
+                {"tabName": "🔍Coverage", "startDir": "~/code/myapp", "command": "python -m coverage run --source=. -m pytest"},
+                {"tabName": "📝Logs", "startDir": "~/logs", "command": "Get-Content app.log -Wait"},
+            ],
+        },
+        {
+            "layoutName": "DeploymentEnv",
+            "layoutTabs": [
+                {"tabName": "🐳Docker", "startDir": "~/code/myapp", "command": "docker-compose up"},
+                {"tabName": "☸️K8s", "startDir": "~/k8s", "command": "kubectl get pods --watch"},
+                {"tabName": "📈Metrics", "startDir": "~", "command": 'Get-Counter "\\Processor(_Total)\\% Processor Time" -SampleInterval 2 -MaxSamples 30'},
+            ],
+        },
+    ]
 
     try:
         # Create the local manager