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

machineconfig/cluster/sessions_managers/zellij_remote_manager.py

@@ -2,10 +2,11 @@ from datetime import datetime
 import json
 import uuid
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Dict
 from machineconfig.utils.utils5 import Scheduler
 from machineconfig.cluster.sessions_managers.zellij_local import run_command_in_zellij_tab
 from machineconfig.cluster.sessions_managers.zellij_remote import ZellijRemoteLayoutGenerator
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 from machineconfig.logger import get_logger
 
 
@@ -14,13 +15,13 @@ logger = get_logger("cluster.sessions_managers.zellij_remote_manager")
 
 
 class ZellijSessionManager:
-    def __init__(self, machine2zellij_tabs: dict[str, dict[str, tuple[str, str]]], session_name_prefix: str = "JobMgr"):
+    def __init__(self, machine_layouts: Dict[str, LayoutConfig], session_name_prefix: str = "JobMgr"):
         self.session_name_prefix = session_name_prefix
-        self.machine2zellij_tabs = machine2zellij_tabs  # Store the original config
+        self.machine_layouts = machine_layouts  # Store the original config
         self.managers: list[ZellijRemoteLayoutGenerator] = []
-        for machine, tab_config in machine2zellij_tabs.items():
+        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(tab_config=tab_config)
+            an_m.create_zellij_layout(layout_config=layout_config)
             self.managers.append(an_m)
 
     def ssh_to_all_machines(self) -> str:
@@ -93,13 +94,13 @@ class ZellijSessionManager:
         session_dir = TMP_SERIALIAZATION_DIR / session_id
         session_dir.mkdir(parents=True, exist_ok=True)
 
-        # Save the machine2zellij_tabs configuration
-        config_file = session_dir / "machine2zellij_tabs.json"
-        text = json.dumps(self.machine2zellij_tabs, indent=2, ensure_ascii=False)
+        # Save the machine_layouts configuration
+        config_file = session_dir / "machine_layouts.json"
+        text = json.dumps(self.machine_layouts, indent=2, ensure_ascii=False)
         config_file.write_text(text, encoding="utf-8")
 
         # Save session metadata
-        metadata = {"session_name_prefix": self.session_name_prefix, "created_at": str(datetime.now()), "num_managers": len(self.managers), "machines": list(self.machine2zellij_tabs.keys())}
+        metadata = {"session_name_prefix": self.session_name_prefix, "created_at": str(datetime.now()), "num_managers": len(self.managers), "machines": list(self.machine_layouts.keys())}
         metadata_file = session_dir / "metadata.json"
         text = json.dumps(metadata, indent=2, ensure_ascii=False)
         metadata_file.write_text(text, encoding="utf-8")
@@ -120,11 +121,11 @@ class ZellijSessionManager:
 
         if not session_dir.exists():
             raise FileNotFoundError(f"Session directory not found: {session_dir}")
-        config_file = session_dir / "machine2zellij_tabs.json"
+        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:
-            machine2zellij_tabs = json.load(f)
+            machine_layouts = json.load(f)
 
         # Load metadata
         metadata_file = session_dir / "metadata.json"
@@ -134,7 +135,7 @@ class ZellijSessionManager:
                 metadata = json.load(f)
                 session_name_prefix = metadata.get("session_name_prefix", "JobMgr")
         # Create new instance (this will create new managers)
-        instance = cls(machine2zellij_tabs=machine2zellij_tabs, session_name_prefix=session_name_prefix)
+        instance = cls(machine_layouts=machine_layouts, session_name_prefix=session_name_prefix)
         # Load saved managers to restore their states
         managers_dir = session_dir / "managers"
         if managers_dir.exists():

machineconfig/cluster/sessions_managers/zellij_utils/example_usage.py

@@ -4,17 +4,21 @@ Example usage of the modularized Zellij remote layout generator.
 """
 
 from machineconfig.cluster.sessions_managers.zellij_remote import ZellijRemoteLayoutGenerator
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
 
 def example_usage():
     """Demonstrate the refactored modular usage."""
 
-    # Sample tab configuration
-    sample_tabs = {
-        "🤖Bot1": ("~/code/bytesense/bithence", "~/scripts/fire -mO go1.py bot1 --kw create_new_bot True"),
-        "🤖Bot2": ("~/code/bytesense/bithence", "~/scripts/fire -mO go2.py bot2 --kw create_new_bot True"),
-        "📊Monitor": ("~", "htop"),
-        "📝Logs": ("/var/log", "tail -f /var/log/app.log"),
+    # Sample layout configuration using new schema
+    sample_layout: LayoutConfig = {
+        "layoutName": "ExampleRemoteSession",
+        "layoutTabs": [
+            {"tabName": "🤖Bot1", "startDir": "~/code/bytesense/bithence", "command": "~/scripts/fire -mO go1.py bot1 --kw create_new_bot True"},
+            {"tabName": "🤖Bot2", "startDir": "~/code/bytesense/bithence", "command": "~/scripts/fire -mO go2.py bot2 --kw create_new_bot True"},
+            {"tabName": "📊Monitor", "startDir": "~", "command": "htop"},
+            {"tabName": "📝Logs", "startDir": "/var/log", "command": "tail -f /var/log/app.log"},
+        ],
     }
 
     # Replace 'myserver' with an actual SSH config alias
@@ -26,11 +30,11 @@ def example_usage():
         generator = ZellijRemoteLayoutGenerator(remote_name=remote_name, session_name_prefix=session_name)
 
         # Create layout file
-        layout_path = generator.create_zellij_layout(sample_tabs)
+        layout_path = generator.create_zellij_layout(sample_layout)
         print(f"✅ Remote layout created successfully: {layout_path}")
 
         # Preview the layout content
-        preview = generator.get_layout_preview(sample_tabs)
+        preview = generator.get_layout_preview(sample_layout)
         print(f"📄 Layout preview:\n{preview}")
 
         # Check status using the modular components
@@ -44,11 +48,11 @@ def example_usage():
         print(f"Remote executor: {generator.remote_executor.remote_name}")
 
         # Use layout generator directly
-        layout_content = generator.layout_generator.generate_layout_content(sample_tabs)
+        layout_content = generator.layout_generator.generate_layout_content(sample_layout)
         print(f"Layout content length: {len(layout_content)} characters")
 
         # Use process monitor directly
-        status = generator.process_monitor.check_all_commands_status(sample_tabs)
+        status = generator.process_monitor.check_all_commands_status(sample_layout)
         print(f"Command status check completed for {len(status)} commands")
 
         print("\n✅ All modular components working correctly!")

machineconfig/cluster/sessions_managers/zellij_utils/layout_generator.py

@@ -6,11 +6,12 @@ Zellij layout generation utilities for creating KDL layout files.
 import shlex
 import random
 import string
-from typing import Dict, List, Tuple
+from typing import List, Tuple
 from pathlib import Path
 import logging
 
 from rich.console import Console
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
 logger = logging.getLogger(__name__)
 console = Console()
@@ -77,36 +78,51 @@ class LayoutGenerator:
         return tab_section
 
     @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():
+    def validate_tab_config(layout_config: LayoutConfig) -> None:
+        """Validate layout configuration format and content."""
+        if not layout_config:
+            raise ValueError("Layout configuration cannot be empty")
+
+        if not layout_config.get("layoutName", "").strip():
+            raise ValueError("Layout name cannot be empty")
+
+        layout_tabs = layout_config.get("layoutTabs", [])
+        if not layout_tabs:
+            raise ValueError("Layout must have at least one tab")
+
+        for tab in layout_tabs:
+            tab_name = tab.get("tabName", "")
+            command = tab.get("command", "")
+            start_dir = tab.get("startDir", "")
+
             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}")
+            if not start_dir.strip():
+                raise ValueError(f"Invalid startDir for tab '{tab_name}': {start_dir}")
 
-    def generate_layout_content(self, tab_config: Dict[str, Tuple[str, str]]) -> str:
+    def generate_layout_content(self, layout_config: LayoutConfig) -> str:
         """Generate complete KDL layout content."""
-        self.validate_tab_config(tab_config)
+        self.validate_tab_config(layout_config)
 
         layout_content = self.LAYOUT_TEMPLATE
-        for tab_name, (cwd, command) in tab_config.items():
-            layout_content += "\n" + self.create_tab_section(tab_name, cwd, command)
+        for tab in layout_config["layoutTabs"]:
+            tab_name = tab["tabName"]
+            start_dir = tab["startDir"]
+            command = tab["command"]
+            layout_content += "\n" + self.create_tab_section(tab_name, start_dir, command)
         layout_content += "\n}\n"
 
         return layout_content
 
-    def create_layout_file(self, tab_config: Dict[str, Tuple[str, str]], output_dir: Path, session_name: str) -> str:
+    def create_layout_file(self, layout_config: LayoutConfig, output_dir: Path, session_name: str) -> str:
         """Create a layout file and return its absolute path."""
-        self.validate_tab_config(tab_config)
+        self.validate_tab_config(layout_config)
 
         # Generate unique suffix for this layout
         random_suffix = self.generate_random_suffix()
-        layout_content = self.generate_layout_content(tab_config)
+        layout_content = self.generate_layout_content(layout_config)
 
         try:
             # Create output directory if it doesn't exist

machineconfig/cluster/sessions_managers/zellij_utils/process_monitor.py

@@ -6,8 +6,9 @@ Process monitoring and status checking utilities for remote commands.
 import json
 import shlex
 import logging
-from typing import Dict, Tuple, Any
-from .remote_executor import RemoteExecutor
+from typing import Dict, Any
+from machineconfig.cluster.sessions_managers.zellij_utils.remote_executor import RemoteExecutor
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
 logger = logging.getLogger(__name__)
 
@@ -18,20 +19,37 @@ class ProcessMonitor:
     def __init__(self, remote_executor: RemoteExecutor):
         self.remote_executor = remote_executor
 
-    def check_command_status(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]], use_verification: bool = True) -> Dict[str, Any]:
+    def check_command_status(self, tab_name: str, layout_config: LayoutConfig, use_verification: bool = True) -> Dict[str, Any]:
         """Check command status with optional process verification."""
-        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, "remote": self.remote_executor.remote_name}
+        # 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, "remote": self.remote_executor.remote_name}
 
         # Use the verified method by default for more accurate results
         if use_verification:
-            return self.get_verified_process_status(tab_name, tab_config)
+            return self.get_verified_process_status(tab_name, layout_config)
 
-        return self._basic_process_check(tab_name, tab_config)
+        return self._basic_process_check(tab_name, layout_config)
 
-    def _basic_process_check(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def _basic_process_check(self, tab_name: str, layout_config: LayoutConfig) -> Dict[str, Any]:
         """Basic process checking without verification."""
-        _, command = tab_config[tab_name]
+        # 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, "command": None, "remote": self.remote_executor.remote_name}
+
+        command = tab_config["command"]
 
         try:
             check_script = self._create_process_check_script(command)
@@ -106,12 +124,19 @@ if __name__ == "__main__":
     print(json.dumps(processes))
 """
 
-    def force_fresh_process_check(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def force_fresh_process_check(self, tab_name: str, layout_config: LayoutConfig) -> Dict[str, Any]:
         """Force a fresh process check with additional validation."""
-        if tab_name not in tab_config:
-            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in tracked configuration", "running": False, "command": None, "remote": self.remote_executor.remote_name}
+        # 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, "command": None, "remote": self.remote_executor.remote_name}
 
-        _, command = tab_config[tab_name]
+        command = tab_config["command"]
 
         try:
             # Get timestamp for freshness validation
@@ -230,9 +255,9 @@ if __name__ == "__main__":
         except Exception:
             return False
 
-    def get_verified_process_status(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def get_verified_process_status(self, tab_name: str, layout_config: LayoutConfig) -> Dict[str, Any]:
         """Get process status with additional verification that processes are actually alive."""
-        status = self.force_fresh_process_check(tab_name, tab_config)
+        status = self.force_fresh_process_check(tab_name, layout_config)
 
         if status.get("running") and status.get("processes"):
             verified_processes = []
@@ -252,13 +277,14 @@ if __name__ == "__main__":
 
         return status
 
-    def check_all_commands_status(self, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Dict[str, Any]]:
-        """Check status of all commands in the tab configuration."""
-        if not tab_config:
-            logger.warning("No tab configuration provided.")
+    def check_all_commands_status(self, layout_config: LayoutConfig) -> Dict[str, Dict[str, Any]]:
+        """Check status of all commands in the layout configuration."""
+        if not layout_config or not layout_config.get("layoutTabs"):
+            logger.warning("No layout configuration provided.")
             return {}
 
         status_report = {}
-        for tab_name in tab_config:
-            status_report[tab_name] = self.check_command_status(tab_name, tab_config)
+        for tab in layout_config["layoutTabs"]:
+            tab_name = tab["tabName"]
+            status_report[tab_name] = self.check_command_status(tab_name, layout_config)
         return status_report

machineconfig/cluster/sessions_managers/zellij_utils/session_manager.py

@@ -9,7 +9,7 @@ from pathlib import Path
 
 from rich.console import Console
 
-from .remote_executor import RemoteExecutor
+from machineconfig.cluster.sessions_managers.zellij_utils.remote_executor import RemoteExecutor
 
 logger = logging.getLogger(__name__)
 console = Console()

machineconfig/cluster/sessions_managers/zellij_utils/status_reporter.py

@@ -4,9 +4,10 @@ Status reporting utilities for Zellij remote layouts.
 """
 
 import logging
-from typing import Dict, Any, Tuple
-from .process_monitor import ProcessMonitor
-from .session_manager import SessionManager
+from typing import Dict, Any
+from machineconfig.cluster.sessions_managers.zellij_utils.process_monitor import ProcessMonitor
+from machineconfig.cluster.sessions_managers.zellij_utils.session_manager import SessionManager
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
 logger = logging.getLogger(__name__)
 
@@ -18,10 +19,10 @@ class StatusReporter:
         self.process_monitor = process_monitor
         self.session_manager = session_manager
 
-    def get_comprehensive_status(self, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def get_comprehensive_status(self, layout_config: LayoutConfig) -> Dict[str, Any]:
         """Get comprehensive status including Zellij session and all commands."""
         zellij_status = self.session_manager.check_zellij_session_status()
-        commands_status = self.process_monitor.check_all_commands_status(tab_config)
+        commands_status = self.process_monitor.check_all_commands_status(layout_config)
 
         running_count = sum(1 for status in commands_status.values() if status.get("running", False))
         total_count = len(commands_status)
@@ -38,9 +39,9 @@ class StatusReporter:
             },
         }
 
-    def print_status_report(self, tab_config: Dict[str, Tuple[str, str]]) -> None:
+    def print_status_report(self, layout_config: LayoutConfig) -> None:
         """Print a formatted status report to console."""
-        status = self.get_comprehensive_status(tab_config)
+        status = self.get_comprehensive_status(layout_config)
         remote_name = self.session_manager.remote_executor.remote_name
         session_name = self.session_manager.session_name
 

machineconfig/cluster/templates/utils.py

@@ -1,7 +1,7 @@
-
 from typing import Optional
 from machineconfig.utils.path_reduced import PathExtended, PLike
 
+
 def to_cloud(
     localpath: PLike,
     cloud: str,

machineconfig/profile/create.py

@@ -24,9 +24,12 @@ ERROR_LIST: list[Any] = []  # append to this after every exception captured.
 
 SYSTEM = system.lower()
 
+
 def get_other_systems(current_system: str) -> list[str]:
     all_systems = ["linux", "windows", "darwin"]
     return [s for s in all_systems if s != current_system.lower()]
+
+
 OTHER_SYSTEMS = get_other_systems(SYSTEM)
 
 
@@ -59,6 +62,7 @@ def main_symlinks(choice: Optional[str] = None):
             choice_selected = "all"  # i.e. program_keys = program_keys
         # overwrite = display_options(msg="Overwrite existing source file?", options=["yes", "no"], default="yes") == "yes"
         from rich.prompt import Confirm
+
         overwrite = Confirm.ask("Overwrite existing source file?", default=True)
     else:
         choice_selected = choice

machineconfig/scripts/linux/checkout_versions

@@ -1,8 +1,2 @@
 #!/usr/bin/env bash
-
-source ~/code/machineconfig/.venv/bin/activate
-python -m fire machineconfig.jobs.python.checkout_version main
-if [ -n "$VIRTUAL_ENV" ]; then
-  deactivate || true
-
-fi
+uv run --no-dev --project $HOME/code/machineconfig python -m fire machineconfig.jobs.python.checkout_version main

machineconfig/scripts/linux/choose_wezterm_theme

@@ -1,9 +1,3 @@
 #!/usr/bin/env bash
-
-source ~/code/machineconfig/.venv/bin/activate
-python -m fire machineconfig.scripts.python.choose_wezterm_theme main
+uv run --no-dev --project $HOME/code/machineconfig python -m fire machineconfig.scripts.python.choose_wezterm_theme main
 source ~/.bashrc  # reload the profile
-if [ -n "$VIRTUAL_ENV" ]; then
-  deactivate || true
-
-fi

machineconfig/scripts/linux/cloud_copy

@@ -1,9 +1,2 @@
 #!/usr/bin/env bash
-
-source ~/code/machineconfig/.venv/bin/activate
-
-python -m machineconfig.scripts.python.cloud_copy "$@"
-
-if [ -n "$VIRTUAL_ENV" ]; then
-  deactivate || true
-fi
+uv run --no-dev --project $HOME/code/machineconfig python -m machineconfig.scripts.python.cloud_copy "$@"

machineconfig/scripts/linux/cloud_manager

@@ -1,8 +1,2 @@
 #!/usr/bin/env bash
-
-source ~/code/machineconfig/.venv/bin/activate
-python -i -m machineconfig.scripts.python.cloud_manager "$@"
-
-if [ -n "$VIRTUAL_ENV" ]; then
-  deactivate || true
-fi
+uv run --no-dev --project $HOME/code/machineconfig python -i -m machineconfig.scripts.python.cloud_manager "$@"

machineconfig/scripts/linux/cloud_mount

@@ -1,24 +1,2 @@
 #!/usr/bin/env bash
-
-# check below if VIRTUAL_ENV is set
-# if [ -z "$VIRTUAL_ENV" ]; then
-source ~/code/machineconfig/.venv/bin/activate
-# fi
-
-op_script=$HOME/tmp_results/shells/python_return_command.sh
-if [ -f "$op_script" ]; then
-  rm $op_script
-fi
-
-python -m machineconfig.scripts.python.cloud_mount "$@"
-
-if [ -f "$op_script" ]; then
-  chmod +x $op_script
-  source $op_script
-fi
-
-# check below if VIRTUAL_ENV enviroment variable exist, then deactivate it, other wise skip
-if [ -n "$VIRTUAL_ENV" ]; then
-  deactivate || true
-
-fi
+uv run --no-dev --project $HOME/code/machineconfig python -m machineconfig.scripts.python.cloud_mount "$@"

machineconfig/scripts/linux/cloud_repo_sync

@@ -1,22 +1,2 @@
 #!/usr/bin/env bash
-
-op_script=$HOME/tmp_results/shells/python_return_command.sh
-if [ -f "$op_script" ]; then
-  rm $op_script
-fi
-
-
-source ~/code/machineconfig/.venv/bin/activate
-
-python $(dirname $(dirname $0))/python/cloud_repo_sync.py "$@"
-
-if [ -f "$op_script" ]; then
-  chmod +x $op_script
-  source $op_script
-fi
-
-
-if [ -n "$VIRTUAL_ENV" ]; then
-  deactivate || true
-
-fi
+uv run --no-dev --project $HOME/code/machineconfig python $(dirname $(dirname $0))/python/cloud_repo_sync.py "$@"

machineconfig/scripts/linux/cloud_sync

@@ -1,24 +1,2 @@
 #!/usr/bin/env bash
-
-# check below if VIRTUAL_ENV is set
-# if [ -z "$VIRTUAL_ENV" ]; then
-source ~/code/machineconfig/.venv/bin/activate
-# fi
-
-op_script=$HOME/tmp_results/shells/python_return_command.sh
-if [ -f "$op_script" ]; then
-  rm $op_script
-fi
-
-python -m machineconfig.scripts.python.cloud_sync "$@"
-
-if [ -f "$op_script" ]; then
-  chmod +x $op_script
-  source $op_script
-fi
-
-# check below if VIRTUAL_ENV enviroment variable exist, then deactivate it, other wise skip
-if [ -n "$VIRTUAL_ENV" ]; then
-  deactivate
-fi
-
+uv run --no-dev --project $HOME/code/machineconfig python -m machineconfig.scripts.python.cloud_sync "$@"

machineconfig/scripts/linux/croshell

@@ -1,24 +1,2 @@
 #!/usr/bin/env bash
-
-
-op_script=$HOME/tmp_results/shells/python_return_command.sh
-if [ -f "$op_script" ]; then
-  rm $op_script
-fi
-
-source ~/code/machineconfig/.venv/bin/activate
-
-python -m machineconfig.scripts.python.croshell "$@"
-# python $(dirname $(dirname $0))/python/fire_jobs.py "$@"
-
-
-if [ -f "$op_script" ]; then
-  chmod +x $op_script
-  set --  # clear all positional parameters
-  source $op_script  # sourcing the script means the args passed to the this script are passed to the sourced script which cofuses the sources script as it contains activate_ve and it doesn't understand first.sh arguments.
-fi
-
-# check below if VIRTUAL_ENV enviroment variable exist, then deactivate it, otherwise skip
-if [ -n "$VIRTUAL_ENV" ]; then
-  deactivate || true
-fi
+uv run --no-dev --project $HOME/code/machineconfig python -m machineconfig.scripts.python.croshell "$@"

machineconfig/scripts/linux/devops

@@ -1,24 +1,3 @@
 #!/usr/bin/env bash
-
-op_script=$HOME/tmp_results/shells/python_return_command.sh
-if [ -f "$op_script" ]; then
-  rm $op_script
-fi
-
-# source ~/code/machineconfig/.venv/bin/activate
-# python -m machineconfig.scripts.python.devops "$@"
-# echo "🔄 Running devops script..."
 uv run --no-dev --project $HOME/code/machineconfig python -m machineconfig.scripts.python.devops "$@"
 # uv run --with machineconfig python -m machineconfig.scripts.python.devops "$@"
-
-
-if [ -f "$op_script" ]; then
-  chmod +x $op_script
-  source $op_script
-fi
-
-
-# check below if VIRTUAL_ENV enviroment variable exist, then deactivate it, other wise skip
-if [ -n "$VIRTUAL_ENV" ]; then
-  deactivate
-fi

machineconfig/scripts/linux/fire

@@ -1,28 +1,2 @@
 #!/usr/bin/env bash
-
-source ~/code/machineconfig/.venv/bin/activate
-
-# Generate random string of length 5
-random_str=$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 10 | head -n 1)
-export op_script=$HOME/tmp_results/shells/$random_str/python_return_command.sh
-# op_script=$HOME/tmp_results/shells/$random_str/python_return_command.sh
-
-if [ -f "$op_script" ]; then
-  rm $op_script
-fi
-
-
-python -m machineconfig.scripts.python.fire_jobs "$@"
-
-
-if [ -f "$op_script" ]; then
-  echo "Running $op_script"
-  chmod +x $op_script
-  set --  # clear all positional parameters
-  source $op_script  # sourcing the script means the args passed to the this script are passed to the sourced script which cofuses the sources script as it contains activate_ve and it doesn't understand first.sh arguments.
-fi
-
-
-if [ -n "$VIRTUAL_ENV" ]; then
-  deactivate || true
-fi
+uv run --no-dev --project $HOME/code/machineconfig python -m machineconfig.scripts.python.fire_jobs "$@"

machineconfig/scripts/linux/fire_agents

@@ -1,27 +1,2 @@
 #!/usr/bin/env bash
-
-source ~/code/machineconfig/.venv/bin/activate
-
-
-# Generate random string of length 5
-random_str=$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 10 | head -n 1)
-export op_script=$HOME/tmp_results/shells/$random_str/python_return_command.sh
-# op_script=$HOME/tmp_results/shells/$random_str/python_return_command.sh
-
-if [ -f "$op_script" ]; then
-  rm $op_script
-fi
-
-python -m machineconfig.scripts.python.fire_agents "$@"
-
-if [ -f "$op_script" ]; then
-  echo "Running $op_script"
-  chmod +x $op_script
-  set --  # clear all positional parameters
-  source $op_script  # sourcing the script means the args passed to the this script are passed to the sourced script which cofuses the sources script as it  and it doesn't understand first.sh arguments.
-fi
-
-
-if [ -n "$VIRTUAL_ENV" ]; then
-  deactivate || true
-fi
+uv run --no-dev --project $HOME/code/machineconfig python -m machineconfig.scripts.python.fire_agents "$@"