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

machineconfig/cluster/sessions_managers/zellij_remote.py

@@ -21,7 +21,6 @@ TMP_LAYOUT_DIR = Path.home().joinpath("tmp_results", "zellij_layouts", "layout_m
 
 
 class ZellijRemoteLayoutGenerator:
-
     def __init__(self, remote_name: str, session_name_prefix: str):
         self.remote_name = remote_name
         self.session_name = session_name_prefix + "_" + LayoutGenerator.generate_random_suffix()
@@ -96,14 +95,7 @@ class ZellijRemoteLayoutGenerator:
         return executor.run_command(command, timeout)
 
     def to_dict(self) -> Dict[str, Any]:
-        return {
-            "remote_name": self.remote_name,
-            "session_name": self.session_name,
-            "tab_config": self.tab_config,
-            "layout_path": self.layout_path,
-            "created_at": datetime.now().isoformat(),
-            "class_name": self.__class__.__name__
-        }
+        return {"remote_name": self.remote_name, "session_name": self.session_name, "tab_config": self.tab_config, "layout_path": self.layout_path, "created_at": datetime.now().isoformat(), "class_name": self.__class__.__name__}
 
     def to_json(self, file_path: Optional[Union[str, Path]] = None) -> str:
         # Generate file path if not provided
@@ -116,8 +108,8 @@ class ZellijRemoteLayoutGenerator:
             file_path_obj = Path(file_path)
 
         # Ensure .json extension
-        if not str(file_path_obj).endswith('.json'):
-            file_path_obj = file_path_obj.with_suffix('.json')
+        if not str(file_path_obj).endswith(".json"):
+            file_path_obj = file_path_obj.with_suffix(".json")
 
         # Ensure parent directory exists
         file_path_obj.parent.mkdir(parents=True, exist_ok=True)
@@ -132,38 +124,38 @@ class ZellijRemoteLayoutGenerator:
         return str(file_path_obj)
 
     @classmethod
-    def from_json(cls, file_path: Union[str, Path]) -> 'ZellijRemoteLayoutGenerator':
+    def from_json(cls, file_path: Union[str, Path]) -> "ZellijRemoteLayoutGenerator":
         file_path = Path(file_path)
 
         # Ensure .json extension
-        if not str(file_path).endswith('.json'):
-            file_path = file_path.with_suffix('.json')
+        if not str(file_path).endswith(".json"):
+            file_path = file_path.with_suffix(".json")
 
         if not file_path.exists():
             raise FileNotFoundError(f"JSON file not found: {file_path}")
 
         # Load JSON data
-        with open(file_path, 'r', encoding='utf-8') as f:
+        with open(file_path, "r", encoding="utf-8") as f:
             data = json.load(f)
 
         # Validate that it's the correct class
-        if data.get('class_name') != cls.__name__:
+        if data.get("class_name") != cls.__name__:
             logger.warning(f"Class name mismatch: expected {cls.__name__}, got {data.get('class_name')}")
 
         # Create new instance
         # Extract session name prefix by removing the suffix
-        session_name = data['session_name']
-        if '_' in session_name:
-            session_name_prefix = '_'.join(session_name.split('_')[:-1])
+        session_name = data["session_name"]
+        if "_" in session_name:
+            session_name_prefix = "_".join(session_name.split("_")[:-1])
         else:
             session_name_prefix = session_name
 
-        instance = cls(remote_name=data['remote_name'], session_name_prefix=session_name_prefix)
+        instance = cls(remote_name=data["remote_name"], session_name_prefix=session_name_prefix)
 
         # Restore state
-        instance.session_name = data['session_name']
-        instance.tab_config = data['tab_config']
-        instance.layout_path = data['layout_path']
+        instance.session_name = data["session_name"]
+        instance.tab_config = data["tab_config"]
+        instance.layout_path = data["layout_path"]
 
         logger.info(f"✅ Loaded ZellijRemoteLayoutGenerator from: {file_path}")
         return instance
@@ -181,13 +173,14 @@ class ZellijRemoteLayoutGenerator:
         json_files = [f.name for f in directory_path.glob("*.json")]
         return sorted(json_files)
 
+
 if __name__ == "__main__":
     # Example usage
     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")
+        "📝Logs": ("/var/log", "tail -f /var/log/app.log"),
     }
 
     # Replace 'myserver' with an actual SSH config alias

machineconfig/cluster/sessions_managers/zellij_remote_manager.py

@@ -39,10 +39,7 @@ class ZellijSessionManager:
 
     def kill_all_sessions(self) -> None:
         for an_m in self.managers:
-            ZellijRemoteLayoutGenerator.run_remote_command(
-                remote_name=an_m.remote_name,
-                command="zellij kill-all-sessions --yes"
-            )
+            ZellijRemoteLayoutGenerator.run_remote_command(remote_name=an_m.remote_name, command="zellij kill-all-sessions --yes")
 
     def start_zellij_sessions(self) -> None:
         for an_m in self.managers:
@@ -84,6 +81,7 @@ 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)
         sched.run()
 
@@ -101,12 +99,7 @@ class ZellijSessionManager:
         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.machine2zellij_tabs.keys())}
         metadata_file = session_dir / "metadata.json"
         text = json.dumps(metadata, indent=2, ensure_ascii=False)
         metadata_file.write_text(text, encoding="utf-8")
@@ -122,7 +115,7 @@ class ZellijSessionManager:
         return session_id
 
     @classmethod
-    def load(cls, session_id: str) -> 'ZellijSessionManager':
+    def load(cls, session_id: str) -> "ZellijSessionManager":
         session_dir = TMP_SERIALIAZATION_DIR / session_id
 
         if not session_dir.exists():
@@ -130,14 +123,14 @@ class ZellijSessionManager:
         config_file = session_dir / "machine2zellij_tabs.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:
+        with open(config_file, "r", encoding="utf-8") as f:
             machine2zellij_tabs = json.load(f)
 
         # Load metadata
         metadata_file = session_dir / "metadata.json"
         session_name_prefix = "JobMgr"  # default fallback
         if metadata_file.exists():
-            with open(metadata_file, 'r', encoding='utf-8') as f:
+            with open(metadata_file, "r", encoding="utf-8") as f:
                 metadata = json.load(f)
                 session_name_prefix = metadata.get("session_name_prefix", "JobMgr")
         # Create new instance (this will create new managers)
@@ -180,6 +173,7 @@ class ZellijSessionManager:
 
         try:
             import shutil
+
             shutil.rmtree(session_dir)
             logger.info(f"✅ Deleted session: {session_id}")
             return True

machineconfig/cluster/sessions_managers/zellij_utils/example_usage.py

@@ -5,6 +5,7 @@ Example usage of the modularized Zellij remote layout generator.
 
 from machineconfig.cluster.sessions_managers.zellij_remote import ZellijRemoteLayoutGenerator
 
+
 def example_usage():
     """Demonstrate the refactored modular usage."""
 
@@ -13,7 +14,7 @@ def example_usage():
         "🤖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")
+        "📝Logs": ("/var/log", "tail -f /var/log/app.log"),
     }
 
     # Replace 'myserver' with an actual SSH config alias
@@ -37,7 +38,7 @@ def example_usage():
         generator.print_status_report()
 
         # The individual components can also be used directly:
-        print(f"\n🔧 Direct component usage examples:")
+        print("\n🔧 Direct component usage examples:")
 
         # Use remote executor directly
         print(f"Remote executor: {generator.remote_executor.remote_name}")
@@ -60,5 +61,6 @@ def example_usage():
     except Exception as e:
         print(f"❌ Error: {e}")
 
+
 if __name__ == "__main__":
     example_usage()

machineconfig/cluster/sessions_managers/zellij_utils/layout_generator.py

@@ -2,6 +2,7 @@
 """
 Zellij layout generation utilities for creating KDL layout files.
 """
+
 import shlex
 import random
 import string
@@ -31,7 +32,7 @@ class LayoutGenerator:
     @staticmethod
     def generate_random_suffix(length: int = 8) -> str:
         """Generate a random string suffix for unique layout 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]]:
@@ -53,7 +54,7 @@ class LayoutGenerator:
             return ""
         formatted_args = []
         for arg in args:
-            if ' ' in arg or '"' in arg or "'" in arg:
+            if " " in arg or '"' in arg or "'" in arg:
                 escaped_arg = arg.replace('"', '\\"')
                 formatted_args.append(f'"{escaped_arg}"')
             else:
@@ -71,8 +72,8 @@ class LayoutGenerator:
         tab_section = f'  tab name="{escaped_tab_name}" cwd="{tab_cwd}" {{\n'
         tab_section += f'    pane command="{cmd}" {{\n'
         if args_str:
-            tab_section += f'      args {args_str}\n'
-        tab_section += '    }\n  }\n'
+            tab_section += f"      args {args_str}\n"
+        tab_section += "    }\n  }\n"
         return tab_section
 
     @staticmethod
@@ -99,8 +100,7 @@ class LayoutGenerator:
 
         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, tab_config: Dict[str, Tuple[str, str]], output_dir: Path, session_name: str) -> str:
         """Create a layout file and return its absolute path."""
         self.validate_tab_config(tab_config)
 

machineconfig/cluster/sessions_managers/zellij_utils/process_monitor.py

@@ -2,6 +2,7 @@
 """
 Process monitoring and status checking utilities for remote commands.
 """
+
 import json
 import shlex
 import logging
@@ -17,18 +18,10 @@ 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, tab_config: Dict[str, Tuple[str, str]], 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
-            }
+            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}
 
         # Use the verified method by default for more accurate results
         if use_verification:
@@ -42,7 +35,7 @@ class ProcessMonitor:
 
         try:
             check_script = self._create_process_check_script(command)
-            remote_cmd = f"$HOME/venvs/ve/bin/python -c {shlex.quote(check_script)}"
+            remote_cmd = f"$HOME/code/machineconfig/.venv/bin/python -c {shlex.quote(check_script)}"
             result = self.remote_executor.run_command(remote_cmd, timeout=15)
 
             if result.returncode == 0:
@@ -50,53 +43,18 @@ class ProcessMonitor:
                     matching_processes = json.loads(result.stdout.strip())
 
                     if matching_processes:
-                        return {
-                            "status": "running",
-                            "running": True,
-                            "processes": matching_processes,
-                            "command": command,
-                            "tab_name": tab_name,
-                            "remote": self.remote_executor.remote_name
-                        }
+                        return {"status": "running", "running": True, "processes": matching_processes, "command": command, "tab_name": tab_name, "remote": self.remote_executor.remote_name}
                     else:
-                        return {
-                            "status": "not_running",
-                            "running": False,
-                            "processes": [],
-                            "command": command,
-                            "tab_name": tab_name,
-                            "remote": self.remote_executor.remote_name
-                        }
+                        return {"status": "not_running", "running": False, "processes": [], "command": command, "tab_name": tab_name, "remote": self.remote_executor.remote_name}
                 except json.JSONDecodeError as e:
                     logger.error(f"Failed to parse remote process check output: {e}")
-                    return {
-                        "status": "error",
-                        "error": f"Failed to parse remote output: {e}",
-                        "running": False,
-                        "command": command,
-                        "tab_name": tab_name,
-                        "remote": self.remote_executor.remote_name
-                    }
+                    return {"status": "error", "error": f"Failed to parse remote output: {e}", "running": False, "command": command, "tab_name": tab_name, "remote": self.remote_executor.remote_name}
             else:
-                return {
-                    "status": "error",
-                    "error": f"Remote command failed: {result.stderr}",
-                    "running": False,
-                    "command": command,
-                    "tab_name": tab_name,
-                    "remote": self.remote_executor.remote_name
-                }
+                return {"status": "error", "error": f"Remote command failed: {result.stderr}", "running": False, "command": command, "tab_name": tab_name, "remote": self.remote_executor.remote_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,
-                "remote": self.remote_executor.remote_name
-            }
+            return {"status": "error", "error": str(e), "running": False, "command": command, "tab_name": tab_name, "remote": self.remote_executor.remote_name}
 
     def _create_process_check_script(self, command: str) -> str:
         """Create Python script for checking processes on remote machine."""
@@ -151,13 +109,7 @@ if __name__ == "__main__":
     def force_fresh_process_check(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> 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
-            }
+            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in tracked configuration", "running": False, "command": None, "remote": self.remote_executor.remote_name}
 
         _, command = tab_config[tab_name]
 
@@ -167,7 +119,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/venvs/ve/bin/python -c {shlex.quote(check_script)}"
+            remote_cmd = f"$HOME/code/machineconfig/.venv/bin/python -c {shlex.quote(check_script)}"
             result = self.remote_executor.run_command(remote_cmd, timeout=15)
 
             if result.returncode == 0:
@@ -183,45 +135,23 @@ if __name__ == "__main__":
                         "tab_name": tab_name,
                         "remote": self.remote_executor.remote_name,
                         "check_timestamp": check_timestamp,
-                        "method": "force_fresh_check"
+                        "method": "force_fresh_check",
                     }
                 except json.JSONDecodeError as e:
                     logger.error(f"Failed to parse fresh check output: {e}")
-                    return {
-                        "status": "error",
-                        "error": f"Failed to parse output: {e}",
-                        "running": False,
-                        "command": command,
-                        "tab_name": tab_name,
-                        "remote": self.remote_executor.remote_name,
-                        "raw_output": result.stdout
-                    }
+                    return {"status": "error", "error": f"Failed to parse output: {e}", "running": False, "command": command, "tab_name": tab_name, "remote": self.remote_executor.remote_name, "raw_output": result.stdout}
             else:
-                return {
-                    "status": "error",
-                    "error": f"Remote command failed: {result.stderr}",
-                    "running": False,
-                    "command": command,
-                    "tab_name": tab_name,
-                    "remote": self.remote_executor.remote_name
-                }
+                return {"status": "error", "error": f"Remote command failed: {result.stderr}", "running": False, "command": command, "tab_name": tab_name, "remote": self.remote_executor.remote_name}
 
         except Exception as e:
             logger.error(f"Error in fresh process check for tab '{tab_name}': {e}")
-            return {
-                "status": "error",
-                "error": str(e),
-                "running": False,
-                "command": command,
-                "tab_name": tab_name,
-                "remote": self.remote_executor.remote_name
-            }
+            return {"status": "error", "error": str(e), "running": False, "command": command, "tab_name": tab_name, "remote": self.remote_executor.remote_name}
 
     def _create_fresh_check_script(self, command: str) -> str:
         """Create enhanced process checking script with freshness validation."""
         escaped_command = command.replace("'", "\\'").replace('"', '\\"')
 
-        return f'''
+        return f"""
 import psutil
 import json
 import os
@@ -286,7 +216,7 @@ def force_fresh_check():
 if __name__ == "__main__":
     result = force_fresh_check()
     print(json.dumps(result))
-'''
+"""
 
     def verify_process_alive(self, pid: int) -> bool:
         """Verify if a process with given PID is actually alive."""
@@ -295,7 +225,7 @@ if __name__ == "__main__":
             result = self.remote_executor.run_command(verify_cmd, timeout=5)
 
             if result.returncode == 0:
-                return result.stdout.strip() == 'alive'
+                return result.stdout.strip() == "alive"
             return False
         except Exception:
             return False

machineconfig/cluster/sessions_managers/zellij_utils/remote_executor.py

@@ -2,6 +2,7 @@
 """
 Remote command execution utilities for SSH operations.
 """
+
 import subprocess
 import logging
 from typing import Dict, Any
@@ -19,12 +20,7 @@ class RemoteExecutor:
         """Execute a command on the remote machine via SSH."""
         ssh_cmd = ["ssh", self.remote_name, command]
         try:
-            result = subprocess.run(
-                ssh_cmd,
-                capture_output=True,
-                text=True,
-                timeout=timeout
-            )
+            result = subprocess.run(ssh_cmd, capture_output=True, text=True, timeout=timeout)
             return result
         except subprocess.TimeoutExpired:
             logger.error(f"SSH command timed out after {timeout}s: {command}")

machineconfig/cluster/sessions_managers/zellij_utils/session_manager.py

@@ -2,6 +2,7 @@
 """
 Zellij session management utilities for remote operations.
 """
+
 import logging
 from typing import Dict, Any, Optional
 from pathlib import Path
@@ -43,34 +44,18 @@ class SessionManager:
     def check_zellij_session_status(self) -> Dict[str, Any]:
         """Check if the Zellij session exists and is running."""
         try:
-            result = self.remote_executor.run_command('zellij list-sessions', timeout=10)
+            result = self.remote_executor.run_command("zellij list-sessions", timeout=10)
 
             if result.returncode == 0:
-                sessions = result.stdout.strip().split('\n') if result.stdout.strip() else []
+                sessions = result.stdout.strip().split("\n") if result.stdout.strip() else []
                 session_running = any(self.session_name in session for session in sessions)
 
-                return {
-                    "zellij_running": True,
-                    "session_exists": session_running,
-                    "session_name": self.session_name,
-                    "all_sessions": sessions,
-                    "remote": self.remote_executor.remote_name
-                }
+                return {"zellij_running": True, "session_exists": session_running, "session_name": self.session_name, "all_sessions": sessions, "remote": self.remote_executor.remote_name}
             else:
-                return {
-                    "zellij_running": False,
-                    "error": result.stderr,
-                    "session_name": self.session_name,
-                    "remote": self.remote_executor.remote_name
-                }
+                return {"zellij_running": False, "error": result.stderr, "session_name": self.session_name, "remote": self.remote_executor.remote_name}
 
         except Exception as e:
-            return {
-                "zellij_running": False,
-                "error": str(e),
-                "session_name": self.session_name,
-                "remote": self.remote_executor.remote_name
-            }
+            return {"zellij_running": False, "error": str(e), "session_name": self.session_name, "remote": self.remote_executor.remote_name}
 
     def start_zellij_session(self, layout_file_path: Optional[str] = None) -> Dict[str, Any]:
         """Start a Zellij session on the remote machine with the generated layout."""
@@ -82,7 +67,9 @@ class SessionManager:
                 raise ValueError("No layout file path provided.")
 
             # Enhanced Rich logging for session start
-            console.print(f"[bold cyan]🚀 Starting Zellij session[/bold cyan] [yellow]'{self.session_name}'[/yellow] [dim]on remote[/dim] [bold yellow]'{self.remote_executor.remote_name}'[/bold yellow] [dim]with layout:[/dim] [blue]{remote_layout_file}[/blue]")
+            console.print(
+                f"[bold cyan]🚀 Starting Zellij session[/bold cyan] [yellow]'{self.session_name}'[/yellow] [dim]on remote[/dim] [bold yellow]'{self.remote_executor.remote_name}'[/bold yellow] [dim]with layout:[/dim] [blue]{remote_layout_file}[/blue]"
+            )
 
             # Start Zellij session with layout
             start_cmd = f"zellij --layout {remote_layout_file} a -b {self.session_name}"
@@ -91,28 +78,13 @@ class SessionManager:
 
             if result.returncode == 0:
                 console.print(f"[bold green]✅ Zellij session[/bold green] [yellow]'{self.session_name}'[/yellow] [green]started successfully on[/green] [bold yellow]{self.remote_executor.remote_name}[/bold yellow]")
-                return {
-                    "success": True,
-                    "session_name": self.session_name,
-                    "remote": self.remote_executor.remote_name,
-                    "message": "Session started successfully"
-                }
+                return {"success": True, "session_name": self.session_name, "remote": self.remote_executor.remote_name, "message": "Session started successfully"}
             else:
-                return {
-                    "success": False,
-                    "error": result.stderr,
-                    "session_name": self.session_name,
-                    "remote": self.remote_executor.remote_name
-                }
+                return {"success": False, "error": result.stderr, "session_name": self.session_name, "remote": self.remote_executor.remote_name}
 
         except Exception as e:
             logger.error(f"Failed to start Zellij session on {self.remote_executor.remote_name}: {e}")
-            return {
-                "success": False,
-                "error": str(e),
-                "session_name": self.session_name,
-                "remote": self.remote_executor.remote_name
-            }
+            return {"success": False, "error": str(e), "session_name": self.session_name, "remote": self.remote_executor.remote_name}
 
     def attach_to_session(self) -> None:
         """Attach to the Zellij session on the remote machine via SSH."""

machineconfig/cluster/sessions_managers/zellij_utils/status_reporter.py

@@ -2,6 +2,7 @@
 """
 Status reporting utilities for Zellij remote layouts.
 """
+
 import logging
 from typing import Dict, Any, Tuple
 from .process_monitor import ProcessMonitor
@@ -33,8 +34,8 @@ class StatusReporter:
                 "running_commands": running_count,
                 "stopped_commands": total_count - running_count,
                 "session_healthy": zellij_status.get("session_exists", False),
-                "remote": self.session_manager.remote_executor.remote_name
-            }
+                "remote": self.session_manager.remote_executor.remote_name,
+            },
         }
 
     def print_status_report(self, tab_config: Dict[str, Tuple[str, str]]) -> None:

machineconfig/cluster/templates/cli_click.py

@@ -1,4 +1,3 @@
-
 # """Trogon
 # """
 

machineconfig/cluster/templates/cli_gooey.py

@@ -1,4 +1,3 @@
-
 # """Gooey
 # """
 
@@ -12,7 +11,6 @@
 # # from typing import Any, Optional
 
 
-
 # @Gooey(program_name="Cluster Launcher", program_description='Cofigure remote cluster and launch jobs.')  # type: ignore
 # def main() -> RemoteMachineConfig:
 #     # parser = GooeyParser(description='Example of Gooey\'s basic functionality')

machineconfig/cluster/templates/cli_trogon.py

@@ -1,4 +1,3 @@
-
 # """Trogon
 # """
 

machineconfig/cluster/templates/run_cloud.py

@@ -1,4 +1,3 @@
-
 # """Run with sane defaults for a remote machine.
 # """
 

machineconfig/cluster/templates/run_cluster.py

@@ -1,4 +1,3 @@
-
 # """
 # Cluster Template
 # """

machineconfig/cluster/templates/run_remote.py

@@ -1,4 +1,3 @@
-
 # """
 # This file contains a template for a remote machine. It is not meant to be run, but rather to be used as a template for
 # """