machineconfig 7.50__py3-none-any.whl → 8.12__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,26 +4,32 @@ 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":
-        wrap_mcfg = CONFIG_ROOT / "scripts/windows/wrap_mcfg.ps1"
+        wrap_mcfg = CONFIG_ROOT / "scripts/wrap_mcfg.ps1"
         wrap_mcfg = f'& "{wrap_mcfg}"'
     elif platform.system().lower() == "linux" or platform.system().lower() == "darwin":
-        wrap_mcfg = CONFIG_ROOT / "scripts/linux/wrap_mcfg"
+        wrap_mcfg = CONFIG_ROOT / "scripts/wrap_mcfg"
     else:
         raise ValueError(f"Unsupported platform: {platform.system()}")
     path = Path(inspect.getfile(func))
@@ -32,21 +38,27 @@ def get_fire_tab_using_fire(func: FunctionType):
     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_manager.py

@@ -4,7 +4,7 @@ import logging
 import subprocess
 from pathlib import Path
 from typing import Optional, Any
-from rich.console import Console
+# from rich.console import Console
 from machineconfig.utils.scheduler import Scheduler
 from machineconfig.cluster.sessions_managers.wt_local import WTLayoutGenerator
 from machineconfig.cluster.sessions_managers.wt_utils.wt_helpers import check_wt_session_status
@@ -20,9 +20,6 @@ from machineconfig.cluster.sessions_managers.wt_utils.status_reporting import (
 
 
 
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-console = Console()
 TMP_SERIALIZATION_DIR = Path.home() / "tmp_results" / "wt_sessions" / "serialized"
 
 
@@ -50,8 +47,12 @@ class WTLocalManager:
             manager.create_layout_file()
             self.managers.append(manager)
 
-        logger.info(f"Initialized WTLocalManager with {len(self.managers)} sessions")
 
+        logging.basicConfig(level=logging.INFO)
+        logger = logging.getLogger(__name__)
+        # console = Console()
+        self.logger = logger
+        self.logger.info(f"Initialized WTLocalManager with {len(self.managers)} sessions")
     def get_all_session_names(self) -> list[str]:
         """Get all managed session names."""
         return [manager.session_name for manager in self.managers]
@@ -71,19 +72,19 @@ class WTLocalManager:
                 # Execute the PowerShell script to start Windows Terminal
                 cmd = f'powershell -ExecutionPolicy Bypass -File "{script_path}"'
 
-                logger.info(f"Starting session '{session_name}' with script: {script_path}")
+                self.logger.info(f"Starting session '{session_name}' with script: {script_path}")
                 result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=30)
 
                 if result.returncode == 0:
                     results[session_name] = {"success": True, "message": f"Session '{session_name}' started successfully"}
-                    logger.info(f"✅ Session '{session_name}' started successfully")
+                    self.logger.info(f"✅ Session '{session_name}' started successfully")
                 else:
                     results[session_name] = {"success": False, "error": result.stderr or result.stdout}
-                    logger.error(f"❌ Failed to start session '{session_name}': {result.stderr}")
+                    self.logger.error(f"❌ Failed to start session '{session_name}': {result.stderr}")
 
             except Exception as e:
                 results[session_name] = {"success": False, "error": str(e)}
-                logger.error(f"❌ Exception starting session '{session_name}': {e}")
+                self.logger.error(f"❌ Exception starting session '{session_name}': {e}")
 
         return results
 
@@ -96,7 +97,7 @@ class WTLocalManager:
                 # Kill all Windows Terminal processes (Windows Terminal doesn't have session-specific killing)
                 cmd = "powershell -Command \"Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue | Stop-Process -Force\""
 
-                logger.info(f"Killing Windows Terminal processes for session '{session_name}'")
+                self.logger.info(f"Killing Windows Terminal processes for session '{session_name}'")
                 result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=10)
 
                 results[session_name] = {"success": result.returncode == 0, "message": "Windows Terminal processes killed" if result.returncode == 0 else result.stderr}
@@ -211,8 +212,10 @@ class WTLocalManager:
                 global_summary = self.get_global_summary()
                 print(f"📊 Quick Summary: {global_summary['running_commands']}/{global_summary['total_commands']} commands running across {global_summary['healthy_sessions']}/{global_summary['total_sessions']} sessions")
 
-        logger.info(f"Starting monitoring routine with {wait_ms}ms intervals")
-        sched = Scheduler(routine=routine, wait_ms=wait_ms, logger=logger)
+        self.logger.info(f"Starting monitoring routine with {wait_ms}ms intervals")
+        from machineconfig.utils.scheduler import LoggerTemplate
+        from typing import cast
+        sched = Scheduler(routine=routine, wait_ms=wait_ms, logger=cast(LoggerTemplate, self.logger))
         sched.run(max_cycles=None)
 
     def save(self, session_id: Optional[str] = None) -> str:
@@ -228,11 +231,11 @@ class WTLocalManager:
         for i, manager in enumerate(self.managers):
             manager_data = {"session_name": manager.session_name, "layout_config": manager.layout_config, "script_path": manager.script_path}
             save_json_file(managers_dir / f"manager_{i}_{manager.session_name}.json", manager_data, f"manager {i}")
-        logger.info(f"✅ Saved WTLocalManager session to: {session_dir}")
+        self.logger.info(f"✅ Saved WTLocalManager session to: {session_dir}")
         return session_id
 
-    @classmethod
-    def load(cls, session_id: str) -> "WTLocalManager":
+    @staticmethod
+    def load(session_id: str) -> "WTLocalManager":
         session_dir = TMP_SERIALIZATION_DIR / session_id
         if not session_dir.exists():
             raise FileNotFoundError(f"Session directory not found: {session_dir}")
@@ -241,7 +244,7 @@ class WTLocalManager:
         metadata_data = load_json_file(session_dir / "metadata.json", "Metadata file") if (session_dir / "metadata.json").exists() else {}
         metadata = metadata_data if isinstance(metadata_data, dict) else {}  # type: ignore[arg-type]
         session_name_prefix = metadata.get("session_name_prefix", "LocalWTMgr")  # type: ignore[union-attr]
-        instance = cls(session_layouts=session_layouts, session_name_prefix=session_name_prefix)
+        instance = WTLocalManager(session_layouts=session_layouts, session_name_prefix=session_name_prefix)
         managers_dir = session_dir / "managers"
         if managers_dir.exists():
             instance.managers = []
@@ -253,8 +256,8 @@ class WTLocalManager:
                     manager.script_path = manager_data["script_path"]  # type: ignore[typeddict-item]
                     instance.managers.append(manager)
                 except Exception as e:
-                    logger.warning(f"Failed to load manager from {manager_file}: {e}")
-        logger.info(f"✅ Loaded WTLocalManager session from: {session_dir}")
+                    instance.logger.warning(f"Failed to load manager from {manager_file}: {e}")
+        instance.logger.info(f"✅ Loaded WTLocalManager session from: {session_dir}")
         return instance
 
     @staticmethod
@@ -299,7 +302,7 @@ class WTLocalManager:
                     )
 
         except Exception as e:
-            logger.error(f"Error listing active sessions: {e}")
+            self.logger.error(f"Error listing active sessions: {e}")
 
         return active_sessions
 

machineconfig/cluster/sessions_managers/wt_remote_manager.py

@@ -68,7 +68,9 @@ class WTSessionManager:
             else:
                 statuses = collect_session_statuses(self.managers)
                 print_session_statuses(statuses)
-        sched = Scheduler(routine=routine, wait_ms=wait_ms, logger=logger)
+        from machineconfig.utils.scheduler import LoggerTemplate
+        from typing import cast
+        sched = Scheduler(routine=routine, wait_ms=wait_ms, logger=cast(LoggerTemplate, logger))
         sched.run()
 
     def save(self, session_id: Optional[str] = None) -> str:

machineconfig/cluster/sessions_managers/zellij_local_manager.py

@@ -276,7 +276,9 @@ class ZellijLocalManager:
                 print(f"📊 Quick Summary: {global_summary['running_commands']}/{global_summary['total_commands']} commands running across {global_summary['healthy_sessions']}/{global_summary['total_sessions']} sessions")
 
         logger.info(f"Starting monitoring routine with {wait_ms}ms intervals")
-        sched = Scheduler(routine=routine, wait_ms=wait_ms, logger=logger)
+        from machineconfig.utils.scheduler import LoggerTemplate
+        from typing import cast
+        sched = Scheduler(routine=routine, wait_ms=wait_ms, logger=cast(LoggerTemplate, logger))
         sched.run()
 
     def save(self, session_id: Optional[str]) -> str:

machineconfig/cluster/sessions_managers/zellij_remote_manager.py

@@ -88,8 +88,9 @@ class ZellijSessionManager:
                 # Print statuses
                 for i, status in enumerate(statuses):
                     print(f"Manager {i}: {status}")
-
-        sched = Scheduler(routine=routine, wait_ms=60_000, logger=logger)
+        from machineconfig.utils.scheduler import LoggerTemplate
+        from typing import cast
+        sched = Scheduler(routine=routine, wait_ms=60_000, logger=cast(LoggerTemplate, logger))
         sched.run()
 
     def save(self, session_id: Optional[str]) -> str:

machineconfig/cluster/sessions_managers/zellij_utils/process_monitor.py

@@ -53,7 +53,7 @@ class ProcessMonitor:
         command = tab_config["command"]
         try:
             check_script = self._create_process_check_script(command)
-            remote_cmd = f"$HOME/.local/bin devops self run-python -c {shlex.quote(check_script)}"
+            remote_cmd = f"$HOME/.local/bin devops self python -c {shlex.quote(check_script)}"
             result = self.remote_executor.run_command(remote_cmd, timeout=15)
             if result.returncode == 0:
                 try:
@@ -139,7 +139,7 @@ if __name__ == "__main__":
             check_timestamp = timestamp_result.stdout.strip() if timestamp_result.returncode == 0 else "unknown"
 
             check_script = self._create_fresh_check_script(command)
-            remote_cmd = f"$HOME/.local/bin/devops self run-python -c {shlex.quote(check_script)}"
+            remote_cmd = f"$HOME/.local/bin/devops self python -c {shlex.quote(check_script)}"
             result = self.remote_executor.run_command(remote_cmd, timeout=15)
 
             if result.returncode == 0: