Update deployer/simulator_interface.py

deployer/simulator_interface.py

@@ -1,95 +1,67 @@
-# simulator_interface.py - Enhanced Virtual Robot Implementation
 import time
 import logging
 from typing import Optional
 
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[logging.StreamHandler()]
-)
-
 class VirtualRobot:
-    """Enhanced virtual robot with state management and error handling."""
+    """Enhanced virtual robot with state management and logging."""
     
-    VALID_STATES = {"IDLE", "WAVING", "SPEAKING", "ERROR"}
-    VALID_ACTIONS = {"wave", "say"}
-
     def __init__(self):
+        """Initialize the virtual robot with default state."""
         self.state = "IDLE"
-        self.last_action_time = time.time()
-        logging.info("[🤖] Virtual Robot initialized in state: %s", self.state)
-
-    def _validate_state(self) -> bool:
-        """Ensure robot is in a valid state."""
-        if self.state not in self.VALID_STATES:
-            self.state = "ERROR"
-            logging.error("Invalid robot state detected!")
-            return False
-        return True
-
-    def wave(self) -> str:
-        """Perform waving action with state management."""
-        if not self._validate_state():
-            return "❌ System error - invalid state"
-            
-        try:
-            self.state = "WAVING"
-            self.last_action_time = time.time()
-            logging.info("[🖐️] Performing wave action")
-            time.sleep(0.5)  # Simulate action duration
-            response = "🤖 *waves hello!*"
-            return response
-        except Exception as e:
-            self.state = "ERROR"
-            logging.error("Wave action failed: %s", str(e))
-            return f"❌ Wave failed: {str(e)}"
-        finally:
-            self.state = "IDLE"
-
-    def speak(self, phrase: str) -> str:
-        """Perform speaking action with validation."""
-        if not phrase or not isinstance(phrase, str):
-            logging.warning("Invalid phrase received")
-            return "❌ Invalid phrase"
-
-        if not self._validate_state():
-            return "❌ System error - invalid state"
-
-        try:
-            self.state = "SPEAKING"
-            self.last_action_time = time.time()
-            logging.info("[💬] Speaking: '%s'", phrase)
-            time.sleep(len(phrase) * 0.05)  # Dynamic delay based on phrase length
-            return f"🗣️ {phrase}"
-        except Exception as e:
-            self.state = "ERROR"
-            logging.error("Speak action failed: %s", str(e))
-            return f"❌ Speak failed: {str(e)}"
-        finally:
-            self.state = "IDLE"
-
+        self._setup_logging()
+        logging.info("🤖 Virtual Robot initialized in %s state", self.state)
+    
+    def _setup_logging(self):
+        """Configure logging settings."""
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(levelname)s - %(message)s',
+            handlers=[logging.StreamHandler()]
+        )
+    
     def perform_action(self, action: str) -> str:
-        """Main action dispatcher with comprehensive validation."""
+        """
+        Process robot actions with validation and error handling.
+        
+        Args:
+            action: The action command (e.g., "wave" or "say hello")
+            
+        Returns:
+            Response string from the robot
+        """
         if not action or not isinstance(action, str):
             logging.warning("Invalid action command received")
-            return "❌ Invalid action command"
-
-        action = action.strip().lower()
+            return "❌ Invalid command"
+            
+        action = action.lower().strip()
         
         try:
             if action == "wave":
-                return self.wave()
+                return self._wave()
             elif action.startswith("say"):
-                phrase = action[3:].strip()
-                if not phrase:
-                    return "❌ Please provide something to say"
-                return self.speak(phrase)
+                return self._speak(action[3:].strip())
             else:
                 logging.warning("Unknown action: %s", action)
                 return "❓ Unknown action - try 'wave' or 'say [message]'"
         except Exception as e:
-            self.state = "ERROR"
-            logging.error("Action processing failed: %s", str(e))
-            return f"❌ System error: {str(e)}"
+            logging.error("Action failed: %s", str(e))
+            return f"❌ Error: {str(e)}"
+    
+    def _wave(self) -> str:
+        """Perform waving animation."""
+        self.state = "WAVING"
+        logging.info("Performing wave action")
+        time.sleep(0.8)  # Simulate animation time
+        self.state = "IDLE"
+        return "👋 *waves enthusiastically*"
+    
+    def _speak(self, message: str) -> str:
+        """Generate speech response."""
+        if not message:
+            return "❌ Please provide something to say"
+            
+        self.state = "SPEAKING"
+        logging.info("Speaking: '%s'", message)
+        time.sleep(max(0.5, len(message)*0.07))  # Dynamic delay
+        self.state = "IDLE"
+        return f"🗣️ {message.capitalize()}"