Update deployer/gradio_generator.py

deployer/gradio_generator.py

@@ -1,107 +1,116 @@
-# gradio_generator.py - Robust Gradio Interface
 import gradio as gr
-from simulator_interface import VirtualRobot
-from typing import Optional
+from .simulator_interface import VirtualRobot  # Relative import
 import logging
 
-logging.basicConfig(level=logging.INFO)
-
-class RoboSageInterface:
-    """Main application interface with lifecycle management."""
+class RoboSageApp:
+    """Main application class for Gradio interface."""
     
     def __init__(self):
+        """Initialize application components."""
         self.robot = VirtualRobot()
-        self.interface = self._create_interface()
-
-    def _robot_response(self, user_input: str) -> str:
-        """Process user input with error handling."""
-        if not user_input or not isinstance(user_input, str):
-            logging.warning("Invalid input received")
-            return "❌ Please enter valid text"
-            
-        try:
-            logging.info("Processing input: %s", user_input)
-            return self.robot.perform_action(user_input)
-        except Exception as e:
-            logging.error("Response generation failed: %s", str(e))
-            return f"❌ System error: {str(e)}"
-
-    def _create_interface(self) -> gr.Blocks:
-        """Build Gradio interface with proper component binding."""
+        self._setup_logging()
+        self.interface = self._build_interface()
+    
+    def _setup_logging(self):
+        """Configure application logging."""
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        self.logger = logging.getLogger(__name__)
+    
+    def _build_interface(self) -> gr.Blocks:
+        """Construct the Gradio interface."""
         with gr.Blocks(
-            title="RoboSage",
-            css=".gradio-container {max-width: 600px !important}"
+            title="RoboSage Assistant",
+            css="""
+                .gradio-container {max-width: 600px !important}
+                .dark {background: #f9f9f9}
+            """
         ) as interface:
             
             # Header section
             gr.Markdown("""
-            # 🤖 RoboSage 
-            ### Your personal virtual assistant
+            # 🤖 RoboSage
+            ### Your Personal Virtual Assistant
             """)
             
             # Interaction panel
             with gr.Row():
-                with gr.Column(scale=4):
-                    self.input_box = gr.Textbox(
-                        label="Command Input",
-                        placeholder="Try 'hello' or 'say something'...",
-                        max_lines=3
-                    )
-                with gr.Column(scale=1):
-                    self.submit_btn = gr.Button(
-                        "Send", 
-                        variant="primary",
-                        size="lg"
-                    )
+                self.input_txt = gr.Textbox(
+                    label="Your Command",
+                    placeholder="Try 'wave' or 'say hello'...",
+                    max_lines=3,
+                    interactive=True
+                )
+                
+            with gr.Row():
+                self.send_btn = gr.Button(
+                    "Submit",
+                    variant="primary",
+                    size="lg"
+                )
+                self.clear_btn = gr.Button(
+                    "Clear",
+                    variant="secondary"
+                )
             
             # Output section
-            self.output_box = gr.Textbox(
+            self.output_txt = gr.Textbox(
                 label="Robot Response",
                 interactive=False,
-                lines=5
+                lines=5,
+                show_copy_button=True
             )
             
-            # History section
-            with gr.Accordion("Session History", open=False):
-                self.history = gr.JSON(
-                    label="Command History",
-                    value={"commands": []}
-                )
-            
             # Event handlers
-            self.submit_btn.click(
-                fn=self._robot_response,
-                inputs=self.input_box,
-                outputs=self.output_box
+            self.send_btn.click(
+                fn=self._process_command,
+                inputs=self.input_txt,
+                outputs=self.output_txt
             )
             
-            self.input_box.submit(
-                fn=self._robot_response,
-                inputs=self.input_box,
-                outputs=self.output_box
+            self.input_txt.submit(
+                fn=self._process_command,
+                inputs=self.input_txt,
+                outputs=self.output_txt
             )
             
+            self.clear_btn.click(
+                fn=lambda: ("", ""),
+                inputs=None,
+                outputs=[self.input_txt, self.output_txt]
+            )
+        
         return interface
+    
+    def _process_command(self, command: str) -> str:
+        """Handle user commands with logging."""
+        self.logger.info("Processing command: %s", command)
+        try:
+            response = self.robot.perform_action(command)
+            self.logger.info("Generated response: %s", response)
+            return response
+        except Exception as e:
+            self.logger.error("Command processing failed: %s", str(e))
+            return f"⚠️ System error: {str(e)}"
 
-def launch_application() -> gr.Blocks:
+def launch_app() -> gr.Blocks:
     """Initialize and return the application interface."""
     try:
-        logging.info("Initializing RoboSage application")
-        app = RoboSageInterface()
+        app = RoboSageApp()
         return app.interface
     except Exception as e:
         logging.critical("Application failed to initialize: %s", str(e))
         raise
 
 if __name__ == "__main__":
-    # Production configuration
-    app = launch_application()
-    app.launch(
+    # Local development configuration
+    interface = launch_app()
+    interface.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
         favicon_path=None,
-        auth=None,
-        ssl_verify=True,
         debug=False
     )