machineconfig 6.82__py3-none-any.whl → 7.98__py3-none-any.whl

machineconfig/cluster/remote/cloud_manager.py

@@ -243,7 +243,7 @@
 #         The reason it is not automated for remotes is because even though the server might have failed, the processes therein might be running, so there is no automated way to tell."""
 #         log = self.read_log()
 #         jobs_all: list[str] = [p.name for p in self.base_path.expanduser().joinpath("jobs").iterdir()]
-#         jobs_selected = choose_from_options(options=jobs_all, msg="Select Jobs to Redo", multi=True, fzf=True)
+#         jobs_selected = choose_from_options(options=jobs_all, msg="Select Jobs to Redo", multi=True, tv=True)
 #         for a_job in jobs_selected:
 #             # find in which log list does this job live:
 #             found_log_type = None

machineconfig/cluster/sessions_managers/utils/maker.py

@@ -4,49 +4,61 @@ from typing import Optional, Literal
 from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig
 from pathlib import Path
 
-def get_fire_tab_using_uv(func: FunctionType, import_module: bool, uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> tuple[TabConfig, Path]:
+def get_fire_tab_using_uv(func: FunctionType, tab_weight: int, import_module: bool, uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> tuple[TabConfig, Path]:
     from machineconfig.utils.meta import lambda_to_python_script
-    py_script =  lambda_to_python_script(lmb=lambda: func, in_global=True, import_module=import_module)
+    if func.__name__ == "<lambda>":
+        py_script =  lambda_to_python_script(func,
+                                             in_global=True, import_module=import_module)
+    else:
+        py_script =  lambda_to_python_script(lambda: func(),
+                                             in_global=True, import_module=import_module)
     from machineconfig.utils.code import get_uv_command_executing_python_script
     command_to_run, py_script_path = get_uv_command_executing_python_script(python_script=py_script, uv_with=uv_with, uv_project_dir=uv_project_dir)
     tab_config: TabConfig = {
         "command": command_to_run,
         "startDir": "$HOME",
-        "tabName": func.__name__
+        "tabName": func.__name__,
+        "tabWeight": tab_weight
     }
     return tab_config, py_script_path
-def get_fire_tab_using_fire(func: FunctionType):
+def get_fire_tab_using_fire(func: FunctionType, tab_weight: int) -> TabConfig:
     import inspect
     from machineconfig.utils.source_of_truth import CONFIG_ROOT
     import platform
     if platform.system().lower() == "windows":
-        mcfgs = CONFIG_ROOT / "scripts/windows/mcfgs.ps1"
-        mcfgs = f'& "{mcfgs}"'
+        wrap_mcfg = CONFIG_ROOT / "scripts/wrap_mcfg.ps1"
+        wrap_mcfg = f'& "{wrap_mcfg}"'
     elif platform.system().lower() == "linux" or platform.system().lower() == "darwin":
-        mcfgs = CONFIG_ROOT / "scripts/linux/mcfgs"
+        wrap_mcfg = CONFIG_ROOT / "scripts/wrap_mcfg"
     else:
         raise ValueError(f"Unsupported platform: {platform.system()}")
     path = Path(inspect.getfile(func))
     path_relative = path.relative_to(Path.home())
-    command_to_run = f"""{mcfgs} fire {path_relative} {func.__name__} """
+    command_to_run = f"""{wrap_mcfg} fire {path_relative} {func.__name__} """
     tab_config: TabConfig = {
         "command": command_to_run,
         "startDir": "$HOME",
-        "tabName": func.__name__
+        "tabName": func.__name__,
+        "tabWeight": tab_weight
     }
     return tab_config
 
 
 
-def make_layout_from_functions(functions: list[FunctionType], import_module: bool, tab_configs: list[TabConfig], layout_name: str, method: Literal["script", "fire"]="fire") -> LayoutConfig:
+def make_layout_from_functions(functions: list[FunctionType], functions_weights: Optional[list[int]], import_module: bool, tab_configs: list[TabConfig],
+                               layout_name: str, method: Literal["script", "fire"],
+                               uv_with: Optional[list[str]] = None, uv_project_dir: Optional[str] = None
+                               ) -> LayoutConfig:
     tabs2artifacts: list[tuple[TabConfig, list[Path]]] = []
-    for a_func in functions:
+    for a_func, tab_weight in zip(functions, functions_weights or [1]*len(functions)):
         match method:
             case "script":
-                tab_config, artifact_files_1 = get_fire_tab_using_uv(a_func, import_module=import_module, uv_with=None, uv_project_dir=None)
+                tab_config, artifact_files_1 = get_fire_tab_using_uv(a_func, tab_weight=tab_weight, import_module=import_module,
+                                                                     uv_with=uv_with, uv_project_dir=uv_project_dir
+                                                                     )
                 artifact_files = [artifact_files_1]
             case "fire":
-                tab_config = get_fire_tab_using_fire(a_func)
+                tab_config = get_fire_tab_using_fire(a_func, tab_weight=tab_weight)
                 artifact_files = []
         tabs2artifacts.append((tab_config, artifact_files))
     list_of_tabs = [tab for tab, _ in tabs2artifacts] + tab_configs

machineconfig/cluster/sessions_managers/wt_local.py

@@ -7,11 +7,7 @@ https://github.com/ruby9455/app_management/tree/main/app_management
 
 """
 
-import shlex
 import subprocess
-import random
-import string
-import json
 import platform
 from typing import Optional, Any
 from pathlib import Path
@@ -22,6 +18,14 @@ from rich.panel import Panel
 from rich.table import Table
 
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
+from machineconfig.cluster.sessions_managers.wt_utils.wt_helpers import (
+    generate_random_suffix,
+    # escape_for_wt,
+    validate_layout_config,
+    generate_wt_command_string,
+    check_wt_session_status,
+    check_command_status,
+)
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -37,52 +41,11 @@ class WTLayoutGenerator:
     def __init__(self, layout_config: LayoutConfig, session_name: str):
         self.session_name: str = session_name
         self.layout_config: LayoutConfig = layout_config.copy()
-        self.script_path: Optional[str] = None  # Store the full path to the PowerShell script
-
-    @staticmethod
-    def _generate_random_suffix(length: int) -> str:
-        """Generate a random string suffix for unique PowerShell script names."""
-        return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
-
-    @staticmethod
-    def _parse_command(command: str) -> tuple[str, list[str]]:
-        try:
-            parts = shlex.split(command)
-            if not parts:
-                raise ValueError("Empty command provided")
-            return parts[0], parts[1:] if len(parts) > 1 else []
-        except ValueError as e:
-            logger.error(f"Error parsing command '{command}': {e}")
-            parts = command.split()
-            return parts[0] if parts else "", parts[1:] if len(parts) > 1 else []
-
-    @staticmethod
-    def _escape_for_wt(text: str) -> str:
-        """Escape text for use in Windows Terminal commands."""
-        # Windows Terminal uses PowerShell-style escaping
-        text = text.replace('"', '""')  # Escape quotes for PowerShell
-        if " " in text or ";" in text or "&" in text or "|" in text:
-            return f'"{text}"'
-        return text
-
-
-
-    @staticmethod
-    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']}")
+        self.script_path: Optional[str] = None
 
     def create_layout_file(self) -> bool:
         """Create Windows Terminal layout file and return success status."""
-        WTLayoutGenerator._validate_layout_config(self.layout_config)
+        validate_layout_config(self.layout_config)
         tab_count = len(self.layout_config['layoutTabs'])
         layout_name = self.layout_config['layoutName']
         console.print(f"[bold cyan]📋 Creating Windows Terminal layout[/bold cyan] [bright_green]'{layout_name}' with {tab_count} tabs[/bright_green]")
@@ -90,17 +53,13 @@ class WTLayoutGenerator:
         for tab in self.layout_config['layoutTabs']:
             console.print(f"  [yellow]→[/yellow] [bold]{tab['tabName']}[/bold] [dim]in[/dim] [blue]{tab['startDir']}[/blue]")
 
-        # Generate Windows Terminal command
-        wt_command = self._generate_wt_command_string(self.layout_config, self.session_name)
+        wt_command = generate_wt_command_string(self.layout_config, self.session_name)
 
-        random_suffix = WTLayoutGenerator._generate_random_suffix(8)
-        # Create PowerShell script content
+        random_suffix = generate_random_suffix(8)
         script_content = f"""# Windows Terminal layout for {self.session_name}
 # Generated with random suffix: {random_suffix}
 {wt_command}
 """
-        # Write to file
-        random_suffix = WTLayoutGenerator._generate_random_suffix(8)
         tmp_dir = Path(TMP_LAYOUT_DIR)
         tmp_dir.mkdir(parents=True, exist_ok=True)
         script_file = tmp_dir / f"wt_layout_{self.session_name}_{random_suffix}.ps1"
@@ -110,46 +69,10 @@ class WTLayoutGenerator:
         console.print(f"[bold green]✅ Layout created successfully:[/bold green] [cyan]{self.script_path}[/cyan]")
         return True
 
-    def _generate_wt_command_string(self, layout_config: LayoutConfig, window_name: str) -> str:
-        """Generate complete Windows Terminal command string."""
-        # Build the complete Windows Terminal command
-        command_parts = []
-        
-        for i, tab in enumerate(layout_config["layoutTabs"]):
-            is_first = i == 0
-            
-            if is_first:
-                # First tab: start with wt command and window name
-                tab_parts = ["wt", "-w", WTLayoutGenerator._escape_for_wt(window_name)]
-            else:
-                # Subsequent tabs: use new-tab
-                tab_parts = ["new-tab"]
-            
-            # Add common tab arguments
-            tab_name = tab["tabName"]
-            cwd = tab["startDir"]
-            command = tab["command"]
-            
-            # Convert paths to Windows format if needed
-            if cwd.startswith("~/"):
-                cwd = cwd.replace("~/", f"{Path.home()}/")
-            elif cwd == "~":
-                cwd = str(Path.home())
-            
-            # Add arguments in the correct order
-            tab_parts.extend(["-d", WTLayoutGenerator._escape_for_wt(cwd)])
-            tab_parts.extend(["--title", WTLayoutGenerator._escape_for_wt(tab_name)])
-            tab_parts.append(WTLayoutGenerator._escape_for_wt(command))
-            
-            command_parts.append(" ".join(tab_parts))
-        
-        # Join all tab commands with escaped semicolons for PowerShell
-        return " `; ".join(command_parts)
-
     def get_wt_layout_preview(self, layout_config: LayoutConfig) -> str:
         """Generate preview of the Windows Terminal command that would be created."""
-        WTLayoutGenerator._validate_layout_config(layout_config)
-        return self._generate_wt_command_string(layout_config, "preview")
+        validate_layout_config(layout_config)
+        return generate_wt_command_string(layout_config, "preview")
 
     def check_all_commands_status(self) -> dict[str, dict[str, Any]]:
         if not self.layout_config:
@@ -159,137 +82,13 @@ class WTLayoutGenerator:
         status_report = {}
         for tab in self.layout_config["layoutTabs"]:
             tab_name = tab["tabName"]
-            status_report[tab_name] = WTLayoutGenerator.check_command_status(tab_name, self.layout_config)
+            status_report[tab_name] = check_command_status(tab_name, self.layout_config)
 
         return status_report
 
-    @staticmethod
-    def check_wt_session_status(session_name: str) -> dict[str, Any]:
-        try:
-            # Simplified Windows Terminal process check
-            ps_script = """
-try {
-    $wtProcesses = Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue
-    if ($wtProcesses) {
-        $processInfo = @()
-        $wtProcesses | ForEach-Object {
-            $info = @{
-                "Id" = $_.Id
-                "ProcessName" = $_.ProcessName
-                "StartTime" = $_.StartTime.ToString()
-            }
-            $processInfo += $info
-        }
-        $processInfo | ConvertTo-Json -Depth 2
-    }
-} catch {
-    # No Windows Terminal processes found
-}
-"""
-
-            result = subprocess.run([POWERSHELL_CMD, "-Command", ps_script], capture_output=True, text=True, timeout=5)
-
-            if result.returncode == 0:
-                output = result.stdout.strip()
-                if output and output != "":
-                    try:
-                        processes = json.loads(output)
-                        if not isinstance(processes, list):
-                            processes = [processes]
-
-                        # For simplicity, assume session exists if WT is running
-                        return {
-                            "wt_running": True, 
-                            "session_exists": len(processes) > 0, 
-                            "session_name": session_name, 
-                            "all_windows": processes, 
-                            "session_windows": processes  # Simplified - assume all windows could be session windows
-                        }
-                    except Exception as e:
-                        return {"wt_running": True, "session_exists": False, "error": f"Failed to parse process info: {e}", "session_name": session_name}
-                else:
-                    return {"wt_running": False, "session_exists": False, "session_name": session_name, "all_windows": []}
-            else:
-                return {"wt_running": False, "error": result.stderr, "session_name": session_name}
-
-        except subprocess.TimeoutExpired:
-            return {"wt_running": False, "error": "Timeout while checking Windows Terminal processes", "session_name": session_name}
-        except FileNotFoundError:
-            return {"wt_running": False, "error": f"PowerShell ({POWERSHELL_CMD}) not found in PATH", "session_name": session_name}
-        except Exception as e:
-            return {"wt_running": False, "error": str(e), "session_name": session_name}
-
-    @staticmethod
-    def check_command_status(tab_name: str, layout_config: LayoutConfig) -> dict[str, Any]:
-        """Check if a command is running by looking for processes."""
-        # 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["command"]
-
-        try:
-            # Extract the primary executable name from command
-            primary_cmd = command.split()[0] if command.strip() else ""
-            if not primary_cmd:
-                return {"status": "error", "error": "Empty command", "running": False, "command": command, "tab_name": tab_name}
-
-            # Use a much simpler PowerShell script that just checks for process names
-            ps_script = f"""
-try {{
-    $processes = Get-Process -Name '{primary_cmd}' -ErrorAction SilentlyContinue
-    if ($processes) {{
-        $processes | ForEach-Object {{
-            $procInfo = @{{
-                "pid" = $_.Id
-                "name" = $_.ProcessName
-                "start_time" = $_.StartTime.ToString()
-            }}
-            Write-Output ($procInfo | ConvertTo-Json -Compress)
-        }}
-    }}
-}} catch {{
-    # No processes found or other error
-}}
-"""
-
-            result = subprocess.run([POWERSHELL_CMD, "-Command", ps_script], capture_output=True, text=True, timeout=5)
-
-            if result.returncode == 0:
-                output_lines = [line.strip() for line in result.stdout.strip().split("\n") if line.strip()]
-                matching_processes = []
-
-                for line in output_lines:
-                    if line.startswith("{") and line.endswith("}"):
-                        try:
-                            proc_info = json.loads(line)
-                            matching_processes.append(proc_info)
-                        except json.JSONDecodeError:
-                            continue
-
-                if matching_processes:
-                    return {"status": "running", "running": True, "processes": matching_processes, "command": command, "tab_name": tab_name}
-                else:
-                    return {"status": "not_running", "running": False, "processes": [], "command": command, "tab_name": tab_name}
-            else:
-                return {"status": "error", "error": f"Command failed: {result.stderr}", "running": False, "command": command, "tab_name": tab_name}
-
-        except subprocess.TimeoutExpired:
-            logger.error(f"Timeout checking command status for tab '{tab_name}'")
-            return {"status": "timeout", "error": "Timeout checking process status", "running": False, "command": command, "tab_name": tab_name}
-        except Exception as e:
-            logger.error(f"Error checking command status for tab '{tab_name}': {e}")
-            return {"status": "error", "error": str(e), "running": False, "command": command, "tab_name": tab_name}
-
     def get_status_report(self) -> dict[str, Any]:
         """Get status report for this layout including Windows Terminal and commands."""
-        wt_status = WTLayoutGenerator.check_wt_session_status(self.session_name or "default")
+        wt_status = check_wt_session_status(self.session_name or "default")
         commands_status = self.check_all_commands_status()
 
         running_count = sum(1 for status in commands_status.values() if status.get("running", False))
@@ -382,14 +181,11 @@ def run_wt_layout(layout_config: LayoutConfig) -> None:
     session_name = layout_config["layoutName"]
     generator = WTLayoutGenerator(layout_config=layout_config, session_name=session_name)
     generator.create_layout_file()
-    
     if generator.script_path is None:
         raise RuntimeError("Script path was not set after creating layout file")
-
     # Execute the script
     cmd = f'powershell -ExecutionPolicy Bypass -File "{generator.script_path}"'
     result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
-
     if result.returncode == 0:
         print(f"Windows Terminal layout is running @ {layout_config['layoutName']}")
     else:
@@ -400,7 +196,6 @@ def run_wt_layout(layout_config: LayoutConfig) -> None:
 def run_command_in_wt_tab(command: str, tab_name: str, cwd: Optional[str]) -> str:
     """Create a command to run in a new Windows Terminal tab."""
     cwd_part = f'-d "{cwd}"' if cwd else ""
-
     return f"""
 echo "Creating new Windows Terminal tab: {tab_name}"
 wt new-tab --title "{tab_name}" {cwd_part} "{command}"