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

machineconfig/cluster/sessions_managers/zellij_remote.py

@@ -21,20 +21,19 @@ 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()
         self.tab_config: Dict[str, Tuple[str, str]] = {}
         self.layout_path: Optional[str] = None
-        
+
         # Initialize modular components
         self.remote_executor = RemoteExecutor(remote_name)
         self.layout_generator = LayoutGenerator()
         self.process_monitor = ProcessMonitor(self.remote_executor)
         self.session_manager = SessionManager(self.remote_executor, self.session_name, TMP_LAYOUT_DIR)
         self.status_reporter = StatusReporter(self.process_monitor, self.session_manager)
-    
+
     def copy_layout_to_remote(self, local_layout_file: Path, random_suffix: str) -> str:
         return self.session_manager.copy_layout_to_remote(local_layout_file, random_suffix)
 
@@ -42,22 +41,22 @@ class ZellijRemoteLayoutGenerator:
         # Enhanced Rich logging for remote layout creation
         tab_count = len(tab_config)
         console.print(f"[bold cyan]📋 Creating Zellij layout[/bold cyan] [bright_green]with {tab_count} tabs[/bright_green] [magenta]for remote[/magenta] [bold yellow]'{self.remote_name}'[/bold yellow]")
-        
+
         # Display tab summary for remote
         for tab_name, (cwd, _) in tab_config.items():
             console.print(f"  [yellow]→[/yellow] [bold]{tab_name}[/bold] [dim]in[/dim] [blue]{cwd}[/blue] [dim]on[/dim] [yellow]{self.remote_name}[/yellow]")
-        
+
         self.tab_config = tab_config.copy()
         if output_dir:
             output_path = Path(output_dir)
         else:
             output_path = TMP_LAYOUT_DIR
-        self.layout_path = self.layout_generator.create_layout_file(tab_config, output_path, self.session_name)        
+        self.layout_path = self.layout_generator.create_layout_file(tab_config, output_path, self.session_name)
         return self.layout_path
-    
+
     def get_layout_preview(self, tab_config: Dict[str, Tuple[str, str]]) -> str:
         return self.layout_generator.generate_layout_content(tab_config)
-    
+
     def check_command_status(self, tab_name: str, use_verification: bool = True) -> Dict[str, Any]:
         return self.process_monitor.check_command_status(tab_name, self.tab_config, use_verification)
 
@@ -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
@@ -114,57 +106,57 @@ class ZellijRemoteLayoutGenerator:
             file_path_obj = default_dir / f"zellij_session_{random_id}.json"
         else:
             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)
-        
+
         # Serialize to JSON
         data = self.to_dict()
-        
-        with open(file_path_obj, 'w', encoding='utf-8') as f:
-            json.dump(data, f, indent=2, ensure_ascii=False)
-        
+
+        text = json.dumps(data, indent=2, ensure_ascii=False)
+        file_path_obj.write_text(text, encoding="utf-8")
+
         logger.info(f"✅ Serialized ZellijRemoteLayoutGenerator to: {file_path_obj}")
         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
 
@@ -174,56 +166,57 @@ class ZellijRemoteLayoutGenerator:
             directory_path = Path.home() / "tmp_results" / "zellij_sessions" / "serialized"
         else:
             directory_path = Path(directory_path)
-            
+
         if not directory_path.exists():
             return []
-        
+
         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"), 
+        "🤖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
     remote_name = "myserver"  # This should be in ~/.ssh/config
     session_name = "test_remote_session"
-    
+
     try:
         # Create layout using the remote generator
         generator = ZellijRemoteLayoutGenerator(remote_name=remote_name, session_name_prefix=session_name)
         layout_path = generator.create_zellij_layout(sample_tabs)
         print(f"✅ Remote layout created successfully: {layout_path}")
-        
+
         # Demonstrate serialization
         print("\n💾 Demonstrating serialization...")
         saved_path = generator.to_json()
         print(f"✅ Session saved to: {saved_path}")
-        
+
         # List all saved sessions
         saved_sessions = ZellijRemoteLayoutGenerator.list_saved_sessions()
         print(f"📋 Available saved sessions: {saved_sessions}")
-        
+
         # Demonstrate loading (using the full path)
         loaded_generator = ZellijRemoteLayoutGenerator.from_json(saved_path)
         print(f"✅ Session loaded successfully: {loaded_generator.session_name}")
         print(f"📊 Loaded tabs: {list(loaded_generator.tab_config.keys())}")
-        
+
         # Demonstrate status checking
         print(f"\n🔍 Checking command status on remote '{remote_name}':")
         generator.print_status_report()
-        
+
         # Start the session (uncomment to actually start)
         # start_result = generator.start_zellij_session()
         # print(f"Session start result: {start_result}")
-        
+
         # Attach to session (uncomment to attach)
         # generator.attach_to_session()
-        
+
     except Exception as e:
         print(f"❌ Error: {e}")

machineconfig/cluster/sessions_managers/zellij_remote_manager.py

@@ -1,15 +1,16 @@
 from datetime import datetime
 import json
 import uuid
-import logging
 from pathlib import Path
 from typing import Optional
 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.logger import get_logger
 
 
 TMP_SERIALIAZATION_DIR = Path.home().joinpath("tmp_results", "session_manager", "zellij", "remote_manager")
+logger = get_logger("cluster.sessions_managers.zellij_remote_manager")
 
 
 class ZellijSessionManager:
@@ -35,14 +36,11 @@ class ZellijSessionManager:
             a_cmd = run_command_in_zellij_tab(command=ssh_cmd, tab_name=hostname, cwd=None)
             cmds += a_cmd + "\n"
         return cmds
-    
+
     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:
             an_m.start_zellij_session()
@@ -65,12 +63,12 @@ class ZellijSessionManager:
                 for i, key in enumerate(keys):
                     if i < len(values):
                         status_data.append({"tabName": key, "status": values[i]})
-                
+
                 # Check if all stopped
                 running_count = sum(1 for item in status_data if item.get("status", {}).get("running", False))
                 if running_count == 0:  # they all stopped
                     sched.max_cycles = sched.cycle  # stop the scheduler from calling this routine again
-                
+
                 # Print status
                 for item in status_data:
                     print(f"Tab: {item['tabName']}, Status: {item['status']}")
@@ -79,67 +77,62 @@ class ZellijSessionManager:
                 for _idx, an_m in enumerate(self.managers):
                     a_status = an_m.check_zellij_session_status()
                     statuses.append(a_status)
-                
+
                 # Print statuses
                 for i, status in enumerate(statuses):
                     print(f"Manager {i}: {status}")
-        sched = Scheduler(routine=routine, wait_ms=60000)  # 60 seconds
+
+        sched = Scheduler(routine=routine, wait_ms=60_000, logger=logger)
         sched.run()
 
     def save(self, session_id: Optional[str] = None) -> str:
         if session_id is None:
             session_id = str(uuid.uuid4())[:8]
-        
+
         # Create session directory
         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"
-        with open(config_file, 'w', encoding='utf-8') as f:
-            json.dump(self.machine2zellij_tabs, f, indent=2, ensure_ascii=False)
-        
+        text = json.dumps(self.machine2zellij_tabs, 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.machine2zellij_tabs.keys())}
         metadata_file = session_dir / "metadata.json"
-        with open(metadata_file, 'w', encoding='utf-8') as f:
-            json.dump(metadata, f, indent=2, ensure_ascii=False)
-        
+        text = json.dumps(metadata, indent=2, ensure_ascii=False)
+        metadata_file.write_text(text, encoding="utf-8")
+
         # Save each ZellijRemoteLayoutGenerator
         managers_dir = session_dir / "managers"
         managers_dir.mkdir(exist_ok=True)
-        
+
         for i, manager in enumerate(self.managers):
             manager_file = managers_dir / f"manager_{i}_{manager.remote_name}.json"
             manager.to_json(str(manager_file))
-        
-        logging.info(f"✅ Saved ZellijSessionManager session to: {session_dir}")
+        logger.info(f"✅ Saved ZellijSessionManager session to: {session_dir}")
         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():
-            raise FileNotFoundError(f"Session directory not found: {session_dir}")        
+            raise FileNotFoundError(f"Session directory not found: {session_dir}")
         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:
+            raise FileNotFoundError(f"Configuration file not found: {config_file}")
+        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")        
+                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)
         # Load saved managers to restore their states
@@ -148,41 +141,42 @@ class ZellijSessionManager:
             # Clear the auto-created managers and load the saved ones
             instance.managers = []
             # Get all manager files and sort them
-            manager_files = sorted(managers_dir.glob("manager_*.json"))            
+            manager_files = sorted(managers_dir.glob("manager_*.json"))
             for manager_file in manager_files:
                 try:
                     loaded_manager = ZellijRemoteLayoutGenerator.from_json(str(manager_file))
                     instance.managers.append(loaded_manager)
                 except Exception as e:
-                    logging.warning(f"Failed to load manager from {manager_file}: {e}")
-        logging.info(f"✅ Loaded ZellijSessionManager session from: {session_dir}")
+                    logger.warning(f"Failed to load manager from {manager_file}: {e}")
+        logger.info(f"✅ Loaded ZellijSessionManager session from: {session_dir}")
         return instance
 
     @staticmethod
     def list_saved_sessions() -> list[str]:
         if not TMP_SERIALIAZATION_DIR.exists():
             return []
-        
+
         sessions = []
         for item in TMP_SERIALIAZATION_DIR.iterdir():
             if item.is_dir() and (item / "metadata.json").exists():
                 sessions.append(item.name)
-        
+
         return sorted(sessions)
 
     @staticmethod
     def delete_session(session_id: str) -> bool:
         session_dir = TMP_SERIALIAZATION_DIR / session_id
-        
+
         if not session_dir.exists():
-            logging.warning(f"Session directory not found: {session_dir}")
+            logger.warning(f"Session directory not found: {session_dir}")
             return False
-        
+
         try:
             import shutil
+
             shutil.rmtree(session_dir)
-            logging.info(f"✅ Deleted session: {session_id}")
+            logger.info(f"✅ Deleted session: {session_id}")
             return True
         except Exception as e:
-            logging.error(f"Failed to delete session {session_id}: {e}")
+            logger.error(f"Failed to delete session {session_id}: {e}")
             return False

machineconfig/cluster/sessions_managers/zellij_utils/example_usage.py

@@ -5,60 +5,62 @@ 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."""
-    
+
     # 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"), 
+        "🤖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
     remote_name = "myserver"  # This should be in ~/.ssh/config
     session_name = "test_remote_session"
-    
+
     try:
         # Create layout using the remote generator
         generator = ZellijRemoteLayoutGenerator(remote_name=remote_name, session_name_prefix=session_name)
-        
+
         # Create layout file
         layout_path = generator.create_zellij_layout(sample_tabs)
         print(f"✅ Remote layout created successfully: {layout_path}")
-        
+
         # Preview the layout content
         preview = generator.get_layout_preview(sample_tabs)
         print(f"📄 Layout preview:\n{preview}")
-        
+
         # Check status using the modular components
         print(f"\n🔍 Checking command status on remote '{remote_name}':")
         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}")
-        
-        # Use layout generator directly  
+
+        # Use layout generator directly
         layout_content = generator.layout_generator.generate_layout_content(sample_tabs)
         print(f"Layout content length: {len(layout_content)} characters")
-        
+
         # Use process monitor directly
         status = generator.process_monitor.check_all_commands_status(sample_tabs)
         print(f"Command status check completed for {len(status)} commands")
-        
+
         print("\n✅ All modular components working correctly!")
-        
+
         # Uncomment these to actually start and attach to the session:
         # start_result = generator.start_zellij_session()
         # print(f"Session start result: {start_result}")
         # generator.attach_to_session()
-        
+
     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
@@ -17,7 +18,7 @@ console = Console()
 
 class LayoutGenerator:
     """Handles generation of Zellij KDL layout files."""
-    
+
     LAYOUT_TEMPLATE = """layout {
     default_tab_template {
         // the default zellij tab-bar and status bar plugins
@@ -27,39 +28,39 @@ class LayoutGenerator:
         children
     }
 """
-    
+
     @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]]:
         """Parse a command string into command and arguments."""
         try:
             parts = shlex.split(command)
-            if not parts: 
+            if not parts:
                 raise ValueError("Empty command provided")
             return parts[0], parts[1:] if len(parts) > 1 else []
         except ValueError as e:
             logger.error(f"Error parsing command '{command}': {e}")
             parts = command.split()
             return parts[0] if parts else "", parts[1:] if len(parts) > 1 else []
-    
+
     @staticmethod
     def format_args_for_kdl(args: List[str]) -> str:
         """Format command arguments for KDL syntax."""
-        if not args: 
+        if not args:
             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:
                 formatted_args.append(f'"{arg}"')
         return " ".join(formatted_args)
-    
+
     @staticmethod
     def create_tab_section(tab_name: str, cwd: str, command: str) -> str:
         """Create a KDL tab section for the layout."""
@@ -67,60 +68,58 @@ class LayoutGenerator:
         args_str = LayoutGenerator.format_args_for_kdl(args)
         tab_cwd = cwd or "~"
         escaped_tab_name = tab_name.replace('"', '\\"')
-        
+
         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'
+        if args_str:
+            tab_section += f"      args {args_str}\n"
+        tab_section += "    }\n  }\n"
         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: 
+        if not tab_config:
             raise ValueError("Tab configuration cannot be empty")
         for tab_name, (cwd, command) in tab_config.items():
-            if not tab_name.strip(): 
+            if not tab_name.strip():
                 raise ValueError(f"Invalid tab name: {tab_name}")
-            if not command.strip(): 
+            if not command.strip():
                 raise ValueError(f"Invalid command for tab '{tab_name}': {command}")
-            if not cwd.strip(): 
+            if not cwd.strip():
                 raise ValueError(f"Invalid cwd for tab '{tab_name}': {cwd}")
-    
+
     def generate_layout_content(self, tab_config: Dict[str, Tuple[str, str]]) -> str:
         """Generate complete KDL layout content."""
         self.validate_tab_config(tab_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)
         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, 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)
-        
+
         # Generate unique suffix for this layout
         random_suffix = self.generate_random_suffix()
         layout_content = self.generate_layout_content(tab_config)
-        
+
         try:
             # Create output directory if it doesn't exist
             output_dir.mkdir(parents=True, exist_ok=True)
             layout_file = output_dir / f"zellij_layout_{session_name}_{random_suffix}.kdl"
-            
+
             # Write layout file
-            with open(layout_file, 'w', encoding='utf-8') as f:
-                f.write(layout_content)
-            
+            layout_file.write_text(layout_content, encoding="utf-8")
+
             # Enhanced Rich logging
             console.print(f"[bold green]✅ Zellij layout file created:[/bold green] [cyan]{layout_file.absolute()}[/cyan]")
             return str(layout_file.absolute())
-            
+
         except OSError as e:
             logger.error(f"Failed to create layout file: {e}")
             raise