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

machineconfig/cluster/cloud_manager.py

@@ -1,6 +1,3 @@
-
-
-
 # from machineconfig.utils.utils2 import read_ini
 # from machineconfig.utils.io_save import save_pickle
 

machineconfig/cluster/data_transfer.py

@@ -2,7 +2,6 @@
 # """
 
 
-
 # from machineconfig.cluster.remote_machine import RemoteMachine, FileManager
 
 

machineconfig/cluster/file_manager.py

@@ -1,4 +1,3 @@
-
 # from rich.console import Console
 # from machineconfig.utils.utils2 import pprint
 # from datetime import datetime

machineconfig/cluster/job_params.py

@@ -1,6 +1,3 @@
-
-
-
 # import git
 
 # from typing import Optional, Callable, Union, Any

machineconfig/cluster/loader_runner.py

@@ -1,4 +1,3 @@
-
 # """
 # Runner
 # """
@@ -124,7 +123,6 @@
 #         )
 
 
-
 # @dataclass
 # class RemoteMachineConfig:
 #     # conn
@@ -179,6 +177,5 @@
 #             except (FileNotFoundError, KeyError, IndexError) as err: raise ValueError(f"Email config name is not provided. 🤷‍♂️ & default could not be read @ `{DEFAULTS_PATH}`") from err
 
 
-
 # if __name__ == '__main__':
 #     pass

machineconfig/cluster/remote_machine.py

@@ -144,7 +144,6 @@
 # echo "~~~~~~~~~~~~~~~~SHELL START~~~~~~~~~~~~~~~"
 # {'~/scripts/devops -w update' if self.config.update_essential_repos else ''}
 # {f'cd {P(self.job_params.repo_path_rh).collapseuser().as_posix()}'}
-# . activate_ve {ve_name}
 # {'git pull' if self.config.update_repo else ''}
 # {'pip install -e .' if self.config.install_repo else ''}
 # echo "~~~~~~~~~~~~~~~~SHELL  END ~~~~~~~~~~~~~~~"

machineconfig/cluster/script_notify_upon_completion.py

@@ -1,4 +1,3 @@
-
 # """
 # Notify User Upon Completion
 # """

machineconfig/cluster/sessions_managers/archive/create_zellij_template.py

@@ -1,10 +1,9 @@
-
-"""ZT
-"""
+"""ZT"""
 
 import socket
-from machineconfig.utils.utils import choose_ssh_host, write_shell_script_to_default_program_path
-from machineconfig.utils.path_reduced import P as PathExtended
+from machineconfig.utils.options import choose_ssh_host
+from machineconfig.utils.code import write_shell_script_to_default_program_path
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
 
 prefix = """
 
@@ -57,5 +56,5 @@ def launch_from_ssh_config():
     return None
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     launch_from_ssh_config()

machineconfig/cluster/sessions_managers/archive/session_managers.py

@@ -1,4 +1,3 @@
-
 # """
 # Session Manager
 # """

machineconfig/cluster/sessions_managers/enhanced_command_runner.py

@@ -13,12 +13,8 @@ from rich import box
 
 console = Console()
 
-def run_enhanced_command(
-    command: str,
-    description: Optional[str] = None,
-    show_progress: bool = True,
-    timeout: Optional[int] = None
-) -> Dict[str, Any]:
+
+def run_enhanced_command(command: str, description: Optional[str] = None, show_progress: bool = True, timeout: Optional[int] = None) -> Dict[str, Any]:
     """
     Run a command with enhanced Rich formatting and user feedback.
 
@@ -37,31 +33,14 @@ def run_enhanced_command(
 
     try:
         if show_progress:
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description}"),
-                console=console,
-                transient=True
-            ) as progress:
+            with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), console=console, transient=True) as progress:
                 task = progress.add_task(f"[cyan]{description}[/cyan]", total=None)
 
-                result = subprocess.run(
-                    command,
-                    shell=True,
-                    capture_output=True,
-                    text=True,
-                    timeout=timeout
-                )
+                result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=timeout)
 
                 progress.update(task, completed=True)
         else:
-            result = subprocess.run(
-                command,
-                shell=True,
-                capture_output=True,
-                text=True,
-                timeout=timeout
-            )
+            result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=timeout)
 
         # Enhanced output processing
         stdout = result.stdout.strip() if result.stdout else ""
@@ -75,8 +54,7 @@ def run_enhanced_command(
                 console.print(f"[bold red]🗑️  Session[/bold red] [yellow]'{session_name}'[/yellow] [red]successfully deleted[/red]")
 
         if "zellij layout is running" in stdout:
-            console.print(stdout.replace("zellij layout is running @",
-                                       "[bold green]🚀 Zellij layout is running[/bold green] [yellow]@[/yellow]"))
+            console.print(stdout.replace("zellij layout is running @", "[bold green]🚀 Zellij layout is running[/bold green] [yellow]@[/yellow]"))
 
         # Handle pseudo-terminal warnings with less alarming appearance
         if "Pseudo-terminal will not be allocated" in stderr:
@@ -86,43 +64,26 @@ def run_enhanced_command(
         if result.returncode == 0:
             if stdout and not any(msg in stdout for msg in ["Session:", "zellij layout is running"]):
                 console.print(f"[green]{stdout}[/green]")
-            return {
-                "success": True,
-                "returncode": result.returncode,
-                "stdout": stdout,
-                "stderr": stderr
-            }
+            return {"success": True, "returncode": result.returncode, "stdout": stdout, "stderr": stderr}
         else:
             if stderr:
                 console.print(f"[bold red]Error:[/bold red] [red]{stderr}[/red]")
-            return {
-                "success": False,
-                "returncode": result.returncode,
-                "stdout": stdout,
-                "stderr": stderr
-            }
+            return {"success": False, "returncode": result.returncode, "stdout": stdout, "stderr": stderr}
 
     except subprocess.TimeoutExpired:
         console.print(f"[bold red]⏰ Command timed out after {timeout} seconds[/bold red]")
-        return {
-            "success": False,
-            "error": "Timeout",
-            "timeout": timeout
-        }
+        return {"success": False, "error": "Timeout", "timeout": timeout}
     except Exception as e:
         console.print(f"[bold red]💥 Unexpected error:[/bold red] [red]{str(e)}[/red]")
-        return {
-            "success": False,
-            "error": str(e)
-        }
+        return {"success": False, "error": str(e)}
+
 
 def enhanced_zellij_session_start(session_name: str, layout_path: str) -> Dict[str, Any]:
     """
     Start a Zellij session with enhanced visual feedback.
     """
     console.print()
-    console.print(Panel.fit(f"🚀 Starting Zellij Session: [bold cyan]{session_name}[/bold cyan]",
-                          style="green", box=box.ROUNDED))
+    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}"
@@ -130,7 +91,7 @@ def enhanced_zellij_session_start(session_name: str, layout_path: str) -> Dict[s
         delete_cmd,
         f"Cleaning up existing session '{session_name}'",
         show_progress=False,
-        timeout=5  # Quick timeout for cleanup
+        timeout=5,  # Quick timeout for cleanup
     )
 
     # Start new session (use -b for background to avoid hanging)
@@ -139,18 +100,17 @@ def enhanced_zellij_session_start(session_name: str, layout_path: str) -> Dict[s
         start_cmd,
         f"Starting session '{session_name}' with layout",
         show_progress=False,
-        timeout=10  # Add timeout to prevent hanging
+        timeout=10,  # Add timeout to prevent hanging
     )
 
     if start_result["success"]:
-        console.print(Panel(f"[bold green]✅ Session '{session_name}' is now running![/bold green]\n[dim]Layout: {layout_path}[/dim]",
-                           style="green", title="🎉 Success"))
+        console.print(Panel(f"[bold green]✅ Session '{session_name}' is now running![/bold green]\n[dim]Layout: {layout_path}[/dim]", style="green", title="🎉 Success"))
     else:
-        console.print(Panel(f"[bold red]❌ Failed to start session '{session_name}'[/bold red]\n[red]{start_result.get('stderr', 'Unknown error')}[/red]",
-                           style="red", title="💥 Error"))
+        console.print(Panel(f"[bold red]❌ Failed to start session '{session_name}'[/bold red]\n[red]{start_result.get('stderr', 'Unknown error')}[/red]", style="red", title="💥 Error"))
 
     return start_result
 
+
 if __name__ == "__main__":
     # Demo the enhanced command execution
     console.print(Panel.fit("🎨 Enhanced Command Execution Demo", style="bold cyan"))

machineconfig/cluster/sessions_managers/wt_local.py

@@ -3,6 +3,7 @@
 Windows Terminal local layout generator and session manager.
 Equivalent to zellij_local.py but for Windows Terminal.
 """
+
 import shlex
 import subprocess
 import random
@@ -26,13 +27,14 @@ class WTLayoutGenerator:
     @staticmethod
     def _generate_random_suffix(length: int = 8) -> str:
         """Generate a random string suffix for unique script file names."""
-        return ''.join(random.choices(string.ascii_lowercase + string.digits, k=length))
+        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")
+            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}")
@@ -44,7 +46,7 @@ class WTLayoutGenerator:
         """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:
+        if " " in text or ";" in text or "&" in text or "|" in text:
             return f'"{text}"'
         return text
 
@@ -52,9 +54,9 @@ class WTLayoutGenerator:
     def _create_tab_command(tab_name: str, cwd: str, command: str, is_first_tab: bool = False) -> str:
         """Create a Windows Terminal tab command string."""
         # Convert paths to Windows format if needed
-        if cwd.startswith('~/'):
-            cwd = cwd.replace('~/', f"{Path.home()}/")
-        elif cwd == '~':
+        if cwd.startswith("~/"):
+            cwd = cwd.replace("~/", f"{Path.home()}/")
+        elif cwd == "~":
             cwd = str(Path.home())
 
         # Build the wt command parts
@@ -117,7 +119,7 @@ REM Windows Terminal layout for {self.session_name}
             script_file.write_text(text, encoding="utf-8")
 
             # Also create PowerShell script for better command handling
-            ps1_file = script_file.with_suffix('.ps1')
+            ps1_file = script_file.with_suffix(".ps1")
             text = f"""# Windows Terminal layout for {self.session_name}
 # Generated with random suffix: {random_suffix}
 {wt_command}
@@ -179,12 +181,7 @@ REM Windows Terminal layout for {self.session_name}
     def check_wt_session_status(session_name: str) -> Dict[str, Any]:
         try:
             # Check for Windows Terminal processes
-            wt_check_cmd = [
-                "powershell", "-Command",
-                "Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue | "
-                "Select-Object Id, ProcessName, StartTime, MainWindowTitle | "
-                "ConvertTo-Json -Depth 2"
-            ]
+            wt_check_cmd = ["powershell", "-Command", "Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, StartTime, MainWindowTitle | ConvertTo-Json -Depth 2"]
 
             result = subprocess.run(wt_check_cmd, capture_output=True, text=True, timeout=10)
 
@@ -193,6 +190,7 @@ REM Windows Terminal layout for {self.session_name}
                 if output and output != "":
                     try:
                         import json
+
                         processes = json.loads(output)
                         if not isinstance(processes, list):
                             processes = [processes]
@@ -204,75 +202,37 @@ REM Windows Terminal layout for {self.session_name}
                             if session_name in window_title or not window_title:
                                 session_windows.append(proc)
 
-                        return {
-                            "wt_running": True,
-                            "session_exists": len(session_windows) > 0,
-                            "session_name": session_name,
-                            "all_windows": processes,
-                            "session_windows": session_windows
-                        }
+                        return {"wt_running": True, "session_exists": len(session_windows) > 0, "session_name": session_name, "all_windows": processes, "session_windows": 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
-                        }
+                        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": []
-                    }
+                    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
-                }
+                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
-            }
+            return {"wt_running": False, "error": "Timeout while checking Windows Terminal processes", "session_name": session_name}
         except FileNotFoundError:
-            return {
-                "wt_running": False,
-                "error": "PowerShell not found in PATH",
-                "session_name": session_name
-            }
+            return {"wt_running": False, "error": "PowerShell not found in PATH", "session_name": session_name}
         except Exception as e:
-            return {
-                "wt_running": False,
-                "error": str(e),
-                "session_name": 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]:
         """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
-            }
+            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in tracked configuration", "running": False, "pid": None, "command": None}
 
         _, command = tab_config[tab_name]
 
         try:
             # Create PowerShell script to check for processes
             cmd_parts = [part for part in command.split() if len(part) > 2]
-            primary_cmd = cmd_parts[0] if cmd_parts else ''
+            primary_cmd = cmd_parts[0] if cmd_parts else ""
 
             ps_script = f"""
 $targetCommand = '{command.replace("'", "''")}'
-$cmdParts = @({', '.join([f"'{part}'" for part in cmd_parts])})
+$cmdParts = @({", ".join([f"'{part}'" for part in cmd_parts])})
 $primaryCmd = '{primary_cmd}'
 $currentPid = $PID
 $matchingProcesses = @()
@@ -314,19 +274,14 @@ Get-Process | ForEach-Object {{
 }}
 """
 
-            result = subprocess.run(
-                ["powershell", "-Command", ps_script],
-                capture_output=True,
-                text=True,
-                timeout=15
-            )
+            result = subprocess.run(["powershell", "-Command", ps_script], capture_output=True, text=True, timeout=15)
 
             if result.returncode == 0:
-                output_lines = [line.strip() for line in result.stdout.strip().split('\n') if line.strip()]
+                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('}'):
+                    if line.startswith("{") and line.endswith("}"):
                         try:
                             proc_info = json.loads(line)
                             matching_processes.append(proc_info)
@@ -334,39 +289,15 @@ Get-Process | ForEach-Object {{
                             continue
 
                 if matching_processes:
-                    return {
-                        "status": "running",
-                        "running": True,
-                        "processes": matching_processes,
-                        "command": command,
-                        "tab_name": tab_name
-                    }
+                    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
-                    }
+                    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
-                }
+                return {"status": "error", "error": f"Command failed: {result.stderr}", "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
-            }
+            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."""
@@ -379,12 +310,7 @@ Get-Process | ForEach-Object {{
         return {
             "wt_session": wt_status,
             "commands": commands_status,
-            "summary": {
-                "total_commands": total_count,
-                "running_commands": running_count,
-                "stopped_commands": total_count - running_count,
-                "session_healthy": wt_status.get("session_exists", False)
-            }
+            "summary": {"total_commands": total_count, "running_commands": running_count, "stopped_commands": total_count - running_count, "session_healthy": wt_status.get("session_exists", False)},
         }
 
     def print_status_report(self) -> None:
@@ -439,13 +365,14 @@ def create_wt_layout(tab_config: Dict[str, tuple[str, str]], output_dir: Optiona
     generator = WTLayoutGenerator()
     return generator.create_wt_layout(tab_config, output_dir)
 
+
 def run_wt_layout(tab_config: Dict[str, tuple[str, str]], session_name: Optional[str] = None) -> str:
     """Create and run a Windows Terminal layout."""
     generator = WTLayoutGenerator()
     script_path = generator.create_wt_layout(tab_config, session_name=session_name)
 
     # Execute the script
-    cmd = f"powershell -ExecutionPolicy Bypass -File \"{script_path}\""
+    cmd = f'powershell -ExecutionPolicy Bypass -File "{script_path}"'
     result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
 
     if result.returncode == 0:
@@ -455,9 +382,10 @@ def run_wt_layout(tab_config: Dict[str, tuple[str, str]], session_name: Optional
         logger.error(f"Failed to run Windows Terminal layout: {result.stderr}")
         raise RuntimeError(f"Failed to run layout: {result.stderr}")
 
+
 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 ""
+    cwd_part = f'-d "{cwd}"' if cwd else ""
 
     return f"""
 echo "Creating new Windows Terminal tab: {tab_name}"
@@ -467,10 +395,7 @@ wt new-tab --title "{tab_name}" {cwd_part} "{command}"
 
 if __name__ == "__main__":
     # Example usage
-    sample_tabs = {
-        "Frontend": ("~/code", "btm"),
-        "Monitor": ("~", "lf"),
-    }
+    sample_tabs = {"Frontend": ("~/code", "btm"), "Monitor": ("~", "lf")}
 
     try:
         # Create layout using the generator
@@ -488,9 +413,10 @@ if __name__ == "__main__":
 
         # Show how to run the layout
         print("\n▶️  To run this layout, execute:")
-        print(f"   powershell -ExecutionPolicy Bypass -File \"{script_path}\"")
+        print(f'   powershell -ExecutionPolicy Bypass -File "{script_path}"')
 
     except Exception as e:
         print(f"❌ Error: {e}")
         import traceback
+
         traceback.print_exc()