Update app.py

app.py

@@ -4,53 +4,73 @@ VoiceBridge.AI - Production Ready Universal Communication Platform
 Supporting: Blind, Deaf, Non-Verbal, Deaf-Blind Users
 """
 
-import gradio as gr
-import speech_recognition as sr
-
-# Prevent mic usage in headless mode
-recognizer = sr.Recognizer()
-microphone = None   # Disable default mic
-
-import pyttsx3
-import threading
-import time
-import json
-import tempfile
 import os
 import logging
+import json
+import tempfile
+import time
 from datetime import datetime
 from pathlib import Path
+from typing import List
+
+import gradio as gr
+import speech_recognition as sr
+import pyttsx3
 import torch
 from transformers import pipeline
-import cv2
-import numpy as np
-import requests
-from typing import Dict, List, Optional, Tuple
+
+# Optional imports (may fail gracefully in some environments)
+try:
+    import cv2
+    import numpy as np
+except Exception:
+    cv2 = None
+    np = None
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
+
 class ProductionVoiceBridge:
     """
     Production-grade universal communication system for all disabilities
     """
-    
-    def __init__(self):
+
+    def __init__(self, allow_microphone: bool = False):
+        """
+        If allow_microphone is False (default) we will not force initialization
+        of system microphone — avoids failures in headless/HF Spaces.
+        """
+        self.allow_microphone = allow_microphone
         self.setup_directories()
         self.load_config()
-        self.initialize_engines()
         self.current_mode = "universal"
         self.user_preferences = {}
         self.conversation_history = []
         self.emergency_contacts = []
-        
+        # initialize engines in try so failures are caught
+        self._init_defaults()
+        self.initialize_engines()
+
+    def _init_defaults(self):
+        # placeholders so other methods can rely on attributes
+        self.tts_engine = None
+        self.recognizer = None
+        self.microphone = None
+        self.speech_to_text_model = None
+        self.image_caption_model = None
+        self.emergency_mode = False
+        self.last_emergency_check = time.time()
+
     def setup_directories(self):
         """Create necessary directories for production"""
+        Path("data").mkdir(parents=True, exist_ok=True)
         Path("data/conversations").mkdir(parents=True, exist_ok=True)
         Path("data/emergency").mkdir(parents=True, exist_ok=True)
         Path("data/user_profiles").mkdir(parents=True, exist_ok=True)
-        
+        Path("data/feedback").mkdir(parents=True, exist_ok=True)
+
     def load_config(self):
         """Load production configuration"""
         self.config = {
@@ -66,103 +86,142 @@ class ProductionVoiceBridge:
                 "error": [100, 50, 100, 50, 100]
             }
         }
-        
+
     def initialize_engines(self):
         """Initialize all AI engines and hardware interfaces"""
         try:
-            # Text-to-Speech Engine
-            self.tts_engine = pyttsx3.init()
-            voices = self.tts_engine.getProperty('voices')
-            self.tts_engine.setProperty('voice', voices[0].id)
-            self.tts_engine.setProperty('rate', 160)
-            self.tts_engine.setProperty('volume', 0.8)
-            
-            # Speech Recognition
-            self.recognizer = sr.Recognizer()
-            self.microphone = sr.Microphone()
-            import speech_recognition as sr
-
-            with self.microphone as source:
-                self.recognizer.adjust_for_ambient_noise(source, duration=1)
-            
-            # AI Models with error handling
+            # Text-to-Speech Engine (pyttsx3 is local and usually safe)
+            try:
+                self.tts_engine = pyttsx3.init()
+                voices = self.tts_engine.getProperty('voices') or []
+                if voices:
+                    self.tts_engine.setProperty('voice', voices[0].id)
+                self.tts_engine.setProperty('rate', 160)
+                self.tts_engine.setProperty('volume', 0.8)
+            except Exception as e:
+                logger.warning(f"TTS engine init failed: {e}")
+                self.tts_engine = None
+
+            # Speech Recognition (recognizer only; microphone optional)
+            try:
+                self.recognizer = sr.Recognizer()
+            except Exception as e:
+                logger.warning(f"SpeechRecognition init failed: {e}")
+                self.recognizer = None
+
+            # Only attempt to initialize Microphone if explicitly allowed
+            if self.allow_microphone:
+                try:
+                    self.microphone = sr.Microphone()
+                    # adjust_for_ambient_noise can fail in headless; guard it
+                    try:
+                        with self.microphone as source:
+                            self.recognizer.adjust_for_ambient_noise(source, duration=1)
+                    except Exception as e:
+                        logger.warning(f"Ambient noise adjust failed: {e}")
+                except Exception as e:
+                    logger.warning(f"Microphone not available: {e}")
+                    self.microphone = None
+            else:
+                # keep microphone None in headless mode to avoid exceptions
+                self.microphone = None
+
+            # AI Models with error handling (transformers pipelines)
             self.load_ai_models()
-            
+
             # Emergency system
             self.emergency_mode = False
             self.last_emergency_check = time.time()
-            
-            logger.info("All engines initialized successfully")
-            
+
+            logger.info("All engines initialized (best-effort)")
+
         except Exception as e:
+            # Log full traceback then re-raise to make failure obvious in dev mode
             logger.error(f"Engine initialization failed: {e}")
+            logger.debug("Traceback:", exc_info=True)
             raise
-    
+
     def load_ai_models(self):
-        """Load AI models with fallbacks"""
+        """Load AI models with fallbacks. These can be heavy; fail gracefully."""
+        # Whisper (ASR) - optional; if not available will fall back to sr.Recognizer
         try:
+            # device selection: if CUDA available, use it, else CPU
+            device = 0 if torch.cuda.is_available() else -1
             self.speech_to_text_model = pipeline(
                 "automatic-speech-recognition",
                 model="openai/whisper-base",
-                device=-1  # CPU for reliability
+                device=device
             )
+            logger.info("Whisper ASR model loaded")
         except Exception as e:
-            logger.warning(f"Whisper model failed, using fallback: {e}")
+            logger.warning(f"Whisper model failed to load: {e}")
             self.speech_to_text_model = None
-            
+
+        # Image captioning - optional
         try:
             self.image_caption_model = pipeline(
                 "image-to-text",
                 model="Salesforce/blip-image-captioning-base",
                 device=-1
             )
+            logger.info("Image caption model loaded")
         except Exception as e:
-            logger.warning(f"BLIP model failed, using fallback: {e}")
+            logger.warning(f"Image caption model failed to load: {e}")
             self.image_caption_model = None
-    
+
     # ==================== UNIVERSAL MODE ====================
-    
+
     def universal_communication(self, input_data: dict) -> dict:
         """
         Universal communication handler that adapts to any input type
         """
         try:
             input_type = input_data.get('type', 'voice')
-            
+
             if input_type == 'voice' and input_data.get('audio'):
                 return self.handle_voice_input(input_data['audio'])
-                
+
             elif input_type == 'text' and input_data.get('text'):
                 return self.handle_text_input(input_data['text'])
-                
+
             elif input_type == 'image' and input_data.get('image'):
                 return self.handle_image_input(input_data['image'])
-                
+
             elif input_type == 'command':
                 return self.handle_system_command(input_data.get('command', ''))
-                
+
             else:
                 return self.create_response(
                     "Please provide voice, text, or image input",
                     "error"
                 )
-                
+
         except Exception as e:
-            logger.error(f"Universal communication error: {e}")
+            logger.error(f"Universal communication error: {e}", exc_info=True)
             return self.create_response(
                 "System error. Please try again or use emergency mode.",
                 "error"
             )
-    
+
     def handle_voice_input(self, audio_path: str) -> dict:
         """Process voice input for deaf users and general transcription"""
         try:
-            # Convert speech to text
-            if self.speech_to_text_model:
-                transcript = self.speech_to_text_model(audio_path)["text"]
+            transcript = ""
+            # If Hugging Face/transformers ASR available and audio path exists, try it
+            if self.speech_to_text_model and audio_path:
+                try:
+                    # transformers pipelines accept file path
+                    out = self.speech_to_text_model(audio_path)
+                    transcript = out.get("text", "") if isinstance(out, dict) else str(out)
+                except Exception as e:
+                    logger.warning(f"HF ASR failed, falling back to sr: {e}")
+                    transcript = self.fallback_speech_to_text(audio_path)
             else:
                 transcript = self.fallback_speech_to_text(audio_path)
-            
+
+            if not transcript:
+                transcript = ""
+
             # Check for emergency keywords
             if self.detect_emergency_keywords(transcript):
                 emergency_result = self.trigger_emergency_mode("voice_triggered")
@@ -172,27 +231,27 @@ class ProductionVoiceBridge:
                     audio=emergency_result.get('audio'),
                     visual_alert="🔴 EMERGENCY ACTIVATED"
                 )
-            
+
             # Check for system commands
             if self.is_system_command(transcript):
                 return self.handle_system_command(transcript)
-            
+
             # Regular communication
             self.add_to_conversation("User", transcript)
-            
+
             return self.create_response(
                 transcript,
                 "transcription",
                 visual_alert=f"💬 New message: {transcript[:50]}..."
             )
-            
+
         except Exception as e:
-            logger.error(f"Voice input error: {e}")
+            logger.error(f"Voice input error: {e}", exc_info=True)
             return self.create_response(
                 "Could not process audio. Please try again.",
                 "error"
             )
-    
+
     def handle_text_input(self, text: str) -> dict:
         """Process text input for non-verbal users"""
         try:
@@ -205,54 +264,65 @@ class ProductionVoiceBridge:
                     audio=emergency_result.get('audio'),
                     visual_alert="🔴 EMERGENCY"
                 )
-            
+
             # Convert to speech
             audio_path = self.text_to_speech(text)
-            
+
             self.add_to_conversation("User", text, "spoken")
-            
+
             return self.create_response(
                 text,
                 "communication",
                 audio=audio_path,
                 visual_alert=f"🗣️ Speaking: {text[:30]}..."
             )
-            
+
         except Exception as e:
-            logger.error(f"Text input error: {e}")
+            logger.error(f"Text input error: {e}", exc_info=True)
             return self.create_response(
                 "Could not process text. Please try again.",
                 "error"
             )
-    
+
     def handle_image_input(self, image_path: str) -> dict:
         """Process image input for blind users"""
         try:
             if not self.image_caption_model:
                 description = "I see an image but cannot describe it in detail right now."
             else:
-                description = self.image_caption_model(image_path)[0]['generated_text']
-                # Enhance description
+                try:
+                    caption_out = self.image_caption_model(image_path)
+                    # pipeline returns list or dict depending on version
+                    if isinstance(caption_out, list) and caption_out:
+                        description = caption_out[0].get('generated_text', '')
+                    elif isinstance(caption_out, dict):
+                        description = caption_out.get('generated_text', '') or caption_out.get('text', '')
+                    else:
+                        description = str(caption_out)
+                except Exception as e:
+                    logger.warning(f"Image captioning failed: {e}")
+                    description = "I see an image but cannot describe it in detail right now."
+
                 description = self.enhance_scene_description(description)
-            
+
             # Convert description to speech
             audio_path = self.text_to_speech(description)
-            
+
             return self.create_response(
                 description,
                 "scene_description",
                 audio=audio_path
             )
-            
+
         except Exception as e:
-            logger.error(f"Image input error: {e}")
+            logger.error(f"Image input error: {e}", exc_info=True)
             return self.create_response(
                 "Could not process image. Please try again.",
                 "error"
             )
-    
+
     # ==================== DISABILITY-SPECIFIC MODES ====================
-    
+
     def blind_mode(self, command: str = None, image_path: str = None) -> dict:
         """Voice-first interface for blind users"""
         if not command and not image_path:
@@ -261,10 +331,10 @@ class ProductionVoiceBridge:
                 "'read text' for text recognition, or 'help' for options."
             )
             return self.create_response(welcome_msg, "system", audio=self.text_to_speech(welcome_msg))
-        
+
         if command:
             command = command.lower()
-            
+
             if 'describe' in command or 'scene' in command or image_path:
                 if image_path:
                     return self.handle_image_input(image_path)
@@ -273,13 +343,13 @@ class ProductionVoiceBridge:
                         "Please capture an image using the camera",
                         "instruction"
                     )
-                    
+
             elif 'read' in command or 'text' in command:
                 return self.create_response(
                     "Please capture an image containing text",
                     "instruction"
                 )
-                
+
             elif 'navigate' in command or 'direction' in command:
                 guidance = "Navigation assistance: Move forward carefully. Obstacle detection active."
                 return self.create_response(
@@ -287,41 +357,41 @@ class ProductionVoiceBridge:
                     "navigation",
                     audio=self.text_to_speech(guidance)
                 )
-                
+
             elif 'help' in command:
-                help_text = """
-                Blind Mode Commands:
-                • "Describe scene" - Describe surroundings using camera
-                • "Read text" - Read text from images
-                • "Navigate" - Get walking directions
-                • "Emergency" - Immediate assistance
-                • "Change mode" - Switch accessibility mode
-                """
+                help_text = (
+                    "Blind Mode Commands:\n"
+                    "• \"Describe scene\" - Describe surroundings using camera\n"
+                    "• \"Read text\" - Read text from images\n"
+                    "• \"Navigate\" - Get walking directions\n"
+                    "• \"Emergency\" - Immediate assistance\n"
+                    "• \"Change mode\" - Switch accessibility mode\n"
+                )
                 return self.create_response(help_text, "help", audio=self.text_to_speech(help_text))
-            
+
             else:
                 response = "Command not recognized. Say 'help' for options."
                 return self.create_response(response, "error", audio=self.text_to_speech(response))
-    
+
     def deaf_mode(self, audio_input: str = None, continuous: bool = False) -> dict:
         """Visual interface for deaf users with real-time transcription"""
         if audio_input:
             result = self.handle_voice_input(audio_input)
-            
+
             # Add visual enhancements for deaf users
-            if result['type'] == 'transcription':
-                result['visual_alert'] = f"👂 TRANSCRIPTION: {result['text'][:100]}..."
-                
+            if result.get('type') == 'transcription':
+                result['visual_alert'] = f"👂 TRANSCRIPTION: {result.get('text','')[:100]}..."
+
             # Check for important sounds
             if self.detect_important_sounds(audio_input):
                 result['visual_alert'] = "🔔 IMPORTANT SOUND DETECTED! " + result.get('visual_alert', '')
                 result['haptic_feedback'] = self.config['haptic_patterns']['notification']
-            
+
             return result
         else:
             status = "Deaf mode active. Real-time transcription ready. Visual alerts enabled."
             return self.create_response(status, "system", visual_alert="👂 Deaf Mode Active")
-    
+
     def non_verbal_mode(self, text: str = None, preset: str = None) -> dict:
         """Text-to-speech communication for non-verbal users"""
         if preset:
@@ -340,11 +410,11 @@ class ProductionVoiceBridge:
             text_to_speak = phrases.get(preset, preset)
         else:
             text_to_speak = text or "I need help"
-        
+
         audio_path = self.text_to_speech(text_to_speak)
-        
+
         self.add_to_conversation("User", text_to_speak, "spoken")
-        
+
         return self.create_response(
             text_to_speak,
             "communication",
@@ -352,7 +422,7 @@ class ProductionVoiceBridge:
             visual_alert=f"🗣️ Speaking: {text_to_speak}",
             haptic_feedback=self.config['haptic_patterns']['confirmation']
         )
-    
+
     def deaf_blind_mode(self, input_text: str = None, output_format: str = "haptic") -> dict:
         """Tactile communication for deaf-blind users"""
         if input_text:
@@ -374,14 +444,14 @@ class ProductionVoiceBridge:
         else:
             status = "Deaf-blind mode active. Use text input with haptic or braille output."
             return self.create_response(status, "system")
-    
+
     # ==================== EMERGENCY SYSTEM ====================
-    
+
     def trigger_emergency_mode(self, trigger_source: str = "manual") -> dict:
         """Activate emergency response system"""
         self.emergency_mode = True
         timestamp = datetime.now().isoformat()
-        
+
         emergency_data = {
             "status": "EMERGENCY_ACTIVATED",
             "timestamp": timestamp,
@@ -390,7 +460,7 @@ class ProductionVoiceBridge:
             "actions_taken": [],
             "contacts_notified": []
         }
-        
+
         # Notify emergency contacts
         for contact in self.emergency_contacts:
             try:
@@ -398,65 +468,86 @@ class ProductionVoiceBridge:
                 emergency_data["contacts_notified"].append(contact)
             except Exception as e:
                 logger.error(f"Failed to notify {contact}: {e}")
-        
+
         # Create emergency audio message
         emergency_audio = self.text_to_speech(emergency_data["message"])
         emergency_data["audio"] = emergency_audio
-        
+
         # Log emergency
         self.log_emergency(emergency_data)
-        
+
         return emergency_data
-    
+
     def notify_emergency_contact(self, contact: str, emergency_data: dict):
         """Notify emergency contact (simplified - in production would use SMS/email)"""
         logger.info(f"EMERGENCY NOTIFICATION to {contact}: {emergency_data['message']}")
         # In production: send SMS, email, or push notification
-    
+
     # ==================== CORE ENGINE METHODS ====================
-    
+
     def text_to_speech(self, text: str) -> str:
-        """Convert text to speech and return audio file path"""
+        """Convert text to speech and return audio file path (best-effort)."""
+        if not text:
+            return None
+        # If no TTS engine, return None gracefully
+        if self.tts_engine is None:
+            logger.warning("TTS engine not available; returning None for audio path.")
+            return None
         try:
             with tempfile.NamedTemporaryFile(delete=False, suffix='.wav', dir='data/') as tmp_file:
-                self.tts_engine.save_to_file(text, tmp_file.name)
-                self.tts_engine.runAndWait()
-                return tmp_file.name
+                tmp_path = tmp_file.name
+            # pyttsx3 uses save_to_file then runAndWait
+            self.tts_engine.save_to_file(text, tmp_path)
+            self.tts_engine.runAndWait()
+            return tmp_path
         except Exception as e:
-            logger.error(f"TTS error: {e}")
+            logger.error(f"TTS error: {e}", exc_info=True)
             return None
-    
+
     def fallback_speech_to_text(self, audio_path: str) -> str:
         """Fallback speech recognition using speech_recognition library"""
+        if not audio_path:
+            return ""
+        if self.recognizer is None:
+            logger.warning("Recognizer not available; cannot transcribe audio.")
+            return ""
         try:
             with sr.AudioFile(audio_path) as source:
                 audio = self.recognizer.record(source)
-                return self.recognizer.recognize_google(audio)
+                # Use Google Web Speech API (requires internet)
+                text = self.recognizer.recognize_google(audio)
+                return text
+        except sr.UnknownValueError:
+            return ""
+        except sr.RequestError as e:
+            logger.error(f"Speech recognition RequestError: {e}")
+            return ""
         except Exception as e:
-            return f"Could not understand audio: {str(e)}"
-    
+            logger.error(f"Fallback STT error: {e}", exc_info=True)
+            return ""
+
     def detect_emergency_keywords(self, text: str) -> bool:
         """Detect emergency keywords in text"""
+        if not text:
+            return False
         emergency_words = [
-            'emergency', 'help', 'urgent', 'danger', 'dangerous', 
+            'emergency', 'help', 'urgent', 'danger', 'dangerous',
             'accident', 'injured', 'hurt', 'pain', 'bleeding',
             'fire', 'police', 'ambulance', 'hospital', '911',
             'save me', 'help me', 'i need help'
         ]
         text_lower = text.lower()
         return any(word in text_lower for word in emergency_words)
-    
+
     def detect_important_sounds(self, audio_path: str) -> bool:
-        """Detect important environmental sounds"""
-        # Simplified - in production would use audio analysis
-        # For now, use speech recognition to check for important words
+        """Detect important environmental sounds (simplified heuristic)"""
         try:
             transcript = self.fallback_speech_to_text(audio_path)
             important_words = ['help', 'emergency', 'fire', 'watch out', 'danger']
             return any(word in transcript.lower() for word in important_words)
-        except:
+        except Exception:
             return False
-    
+
     def text_to_vibration_pattern(self, text: str) -> List[int]:
         """Convert text to vibration pattern (simplified Morse code)"""
         morse_code = {
@@ -469,7 +560,7 @@ class ProductionVoiceBridge:
             '6': '-....', '7': '--...', '8': '---..', '9': '----.', '0': '-----',
             ' ': ' '
         }
-        
+
         pattern = []
         for char in text.upper():
             if char in morse_code:
@@ -481,9 +572,9 @@ class ProductionVoiceBridge:
                         pattern.extend([300])  # Long vibration
                     pattern.extend([50])  # Gap between symbols
                 pattern.extend([200])  # Gap between letters
-        
+
         return pattern
-    
+
     def text_to_braille(self, text: str) -> str:
         """Convert text to braille unicode characters"""
         braille_map = {
@@ -493,11 +584,13 @@ class ProductionVoiceBridge:
             '1': '⠁', '2': '⠃', '3': '⠉', '4': '⠙', '5': '⠑', '6': '⠋', '7': '⠛', '8': '⠓', '9': '⠊', '0': '⠚',
             ' ': ' ', '.': '⠲', ',': '⠂', '!': '⠖', '?': '⠦'
         }
-        
+
         return ''.join(braille_map.get(char.upper(), '?') for char in text)
-    
+
     def enhance_scene_description(self, description: str) -> str:
         """Enhance AI-generated scene descriptions"""
+        if not description:
+            return description
         enhancements = {
             "indoor": "This appears to be an indoor setting. ",
             "outdoor": "This appears to be an outdoor area. ",
@@ -505,44 +598,46 @@ class ProductionVoiceBridge:
             "text": "There is text that could be read. ",
             "obstacle": "Be careful of potential obstacles. ",
         }
-        
+
         enhanced = description
         desc_lower = description.lower()
-        
+
         if any(word in desc_lower for word in ['room', 'indoor', 'inside', 'wall']):
             enhanced = enhancements["indoor"] + enhanced
         elif any(word in desc_lower for word in ['outdoor', 'outside', 'sky', 'tree']):
             enhanced = enhancements["outdoor"] + enhanced
-            
+
         if any(word in desc_lower for word in ['person', 'people', 'man', 'woman']):
             enhanced = enhancements["people"] + enhanced
-            
+
         if any(word in desc_lower for word in ['sign', 'text', 'letter', 'word']):
             enhanced = enhancements["text"] + enhanced
-            
+
         return enhanced
-    
+
     def is_system_command(self, text: str) -> bool:
         """Check if text contains system commands"""
+        if not text:
+            return False
         commands = ['mode', 'help', 'emergency', 'stop', 'cancel', 'reset']
         return any(command in text.lower() for command in commands)
-    
+
     def handle_system_command(self, command: str) -> dict:
         """Handle system control commands"""
-        command = command.lower()
-        
+        command = (command or "").lower()
+
         if 'blind' in command:
             self.current_mode = "blind"
             response = "Blind mode activated. Voice navigation enabled."
+        elif 'deaf blind' in command:
+            self.current_mode = "deaf_blind"
+            response = "Deaf-blind mode activated. Haptic feedback enabled."
         elif 'deaf' in command:
             self.current_mode = "deaf"
             response = "Deaf mode activated. Visual alerts enabled."
         elif 'non verbal' in command or 'mute' in command:
             self.current_mode = "non_verbal"
             response = "Non-verbal mode activated. Text-to-speech ready."
-        elif 'deaf blind' in command:
-            self.current_mode = "deaf_blind"
-            response = "Deaf-blind mode activated. Haptic feedback enabled."
         elif 'universal' in command:
             self.current_mode = "universal"
             response = "Universal mode activated."
@@ -550,9 +645,9 @@ class ProductionVoiceBridge:
             return self.trigger_emergency_mode("voice_command")
         else:
             response = f"Current mode: {self.current_mode}. Say 'help' for options."
-        
+
         return self.create_response(response, "system", audio=self.text_to_speech(response))
-    
+
     def add_to_conversation(self, speaker: str, text: str, message_type: str = "text"):
         """Add message to conversation history"""
         self.conversation_history.append({
@@ -561,11 +656,11 @@ class ProductionVoiceBridge:
             "text": text,
             "type": message_type
         })
-        
+
         # Keep only last 100 messages
         if len(self.conversation_history) > 100:
             self.conversation_history = self.conversation_history[-100:]
-    
+
     def log_emergency(self, emergency_data: dict):
         """Log emergency event"""
         try:
@@ -574,7 +669,7 @@ class ProductionVoiceBridge:
                 json.dump(emergency_data, f, indent=2)
         except Exception as e:
             logger.error(f"Failed to log emergency: {e}")
-    
+
     def create_response(self, text: str, response_type: str, **kwargs) -> dict:
         """Create standardized response object"""
         return {
@@ -591,352 +686,131 @@ class ProductionVoiceBridge:
 
 # ==================== GRADIO INTERFACE ====================
 
-def create_production_interface():
+def create_production_interface(allow_microphone: bool = False):
     """Create production-ready Gradio interface"""
-    
-    # Initialize the system
-    voice_bridge = ProductionVoiceBridge()
-    
-    # Custom CSS for accessibility
+
+    # Initialize the system; allow microphone only if requested
+    voice_bridge = ProductionVoiceBridge(allow_microphone=allow_microphone)
+
+    # Minimal custom CSS for accessibility (kept from your original)
     custom_css = """
-    :root {
-        --primary-color: #2563eb;
-        --danger-color: #dc2626;
-        --success-color: #16a34a;
-        --warning-color: #d97706;
-    }
-    
-    .accessible-btn {
-        min-height: 48px !important;
-        min-width: 48px !important;
-        padding: 12px 24px !important;
-        font-size: 16px !important;
-        margin: 4px !important;
-        border: 2px solid !important;
-    }
-    
-    .emergency-btn {
-        background: linear-gradient(45deg, #dc2626, #ef4444) !important;
-        color: white !important;
-        font-weight: bold !important;
-        font-size: 20px !important;
-        animation: pulse 2s infinite !important;
-    }
-    
-    @keyframes pulse {
-        0% { transform: scale(1); opacity: 1; }
-        50% { transform: scale(1.05); opacity: 0.9; }
-        100% { transform: scale(1); opacity: 1; }
-    }
-    
-    .high-contrast {
-        filter: contrast(200%) !important;
-    }
-    
-    .large-text { font-size: 18px !important; }
-    .x-large-text { font-size: 22px !important; }
-    
-    .sr-only {
-        position: absolute !important;
-        width: 1px !important;
-        height: 1px !important;
-        padding: 0 !important;
-        margin: -1px !important;
-        overflow: hidden !important;
-        clip: rect(0, 0, 0, 0) !important;
-        white-space: nowrap !important;
-        border: 0 !important;
-    }
-    
-    @media (max-width: 768px) {
-        .container {
-            padding: 8px !important;
-        }
-        .accessible-btn {
-            min-height: 54px !important;
-            min-width: 54px !important;
-            font-size: 18px !important;
-        }
-    }
+    :root { --primary-color: #2563eb; --danger-color: #dc2626; }
+    .accessible-btn { min-height:48px !important; padding:12px 18px !important; font-size:16px !important; }
+    .emergency-btn { background: linear-gradient(45deg,#dc2626,#ef4444) !important; color:white !important; font-weight:bold !important; }
+    .large-text { font-size:18px !important; }
     """
-    
-    with gr.Blocks(
-        css=custom_css,
-        theme=gr.themes.Soft(primary_hue="blue"),
-        title="VoiceBridge AI - Universal Communication",
-        head='<meta name="description" content="Accessibility communication platform for blind, deaf, non-verbal, and deaf-blind users">'
-    ) as demo:
-        
-        # Screen reader announcement area
-        sr_announcement = gr.Textbox(
-            label="Screen Reader Announcements",
-            elem_id="sr-announcement",
-            visible=False
-        )
-        
-        gr.Markdown("""
-        # 🎯 VoiceBridge AI - Universal Communication Platform
-        **Production-Ready Accessibility Solution for All Disabilities**
-        
-        *Supporting: 👁️ Blind Users • 👂 Deaf Users • 🤐 Non-Verbal Users • 👁️👂 Deaf-Blind Users*
-        """)
-        
-        # System Status Bar
-        with gr.Row():
-            system_status = gr.Textbox(
-                label="System Status",
-                value="✅ System Ready - VoiceBridge AI Initialized",
-                interactive=False,
-                max_lines=1
-            )
-            current_mode_display = gr.Textbox(
-                label="Current Mode",
-                value="universal",
-                interactive=False,
-                max_lines=1
-            )
-        
-        # Emergency Section (Always Visible)
+
+    with gr.Blocks(css=custom_css, theme=gr.themes.Soft(primary_hue="blue"),
+                   title="VoiceBridge AI - Universal Communication") as demo:
+
+        gr.Markdown("# 🎯 VoiceBridge AI - Universal Communication Platform")
+
+        # Status row
         with gr.Row():
-            emergency_btn = gr.Button(
-                "🚨 ACTIVATE EMERGENCY MODE",
-                elem_classes=["accessible-btn", "emergency-btn", "x-large-text"],
-                scale=2
-            )
-            emergency_contact_input = gr.Textbox(
-                label="Emergency Contact (Email/Phone)",
-                placeholder="Enter emergency contact information...",
-                scale=1
-            )
-        
-        # Mode Selection
+            system_status = gr.Textbox(label="System Status",
+                                      value="✅ System Ready - VoiceBridge AI Initialized",
+                                      interactive=False)
+            current_mode_display = gr.Textbox(label="Current Mode", value=voice_bridge.current_mode, interactive=False)
+
+        # Emergency
         with gr.Row():
-            mode_selector = gr.Radio(
-                choices=[
-                    ("Universal", "universal"),
-                    ("Blind", "blind"), 
-                    ("Deaf", "deaf"),
-                    ("Non-Verbal", "non_verbal"),
-                    ("Deaf-Blind", "deaf_blind")
-                ],
-                label="Accessibility Mode",
-                value="universal",
-                elem_id="mode-selector"
-            )
-        
-        # Universal Communication Tab
-        with gr.Tab("🌐 Universal Communication", id="universal"):
+            emergency_btn = gr.Button("🚨 ACTIVATE EMERGENCY MODE", elem_classes=["accessible-btn", "emergency-btn"])
+            emergency_contact_input = gr.Textbox(label="Emergency Contact (Email/Phone)",
+                                                 placeholder="Enter emergency contact information...")
+
+        # Mode selector
+        mode_selector = gr.Radio(choices=[("Universal", "universal"), ("Blind", "blind"),
+                                         ("Deaf", "deaf"), ("Non-Verbal", "non_verbal"),
+                                         ("Deaf-Blind", "deaf_blind")],
+                                 label="Accessibility Mode", value=voice_bridge.current_mode)
+
+        # Universal Tab
+        with gr.Tab("🌐 Universal Communication"):
             with gr.Row():
-                with gr.Column(scale=1):
-                    universal_audio = gr.Audio(
-                        label="🎤 Speak (Voice Input)",
-                        type="filepath",
-                        sources=["microphone"]
-                    )
-                    universal_text = gr.Textbox(
-                        label="⌨️ Type to Speak",
-                        placeholder="Enter text to be spoken aloud...",
-                        lines=3
-                    )
-                    universal_image = gr.Image(
-                        label="📷 Capture Scene",
-                        type="filepath",
-                        sources=["webcam", "upload"]
-                    )
-                    
-                    process_universal = gr.Button(
-                        "Process Input",
-                        elem_classes="accessible-btn",
-                        size="lg"
-                    )
-                
-                with gr.Column(scale=1):
-                    universal_output = gr.Textbox(
-                        label="Output",
-                        lines=6,
-                        max_lines=10
-                    )
-                    universal_audio_output = gr.Audio(
-                        label="Audio Output",
-                        type="filepath",
-                        interactive=False
-                    )
-                    universal_alert = gr.Textbox(
-                        label="Visual Alerts",
-                        visible=False
-                    )
-        
-        # Blind Assistance Tab
-        with gr.Tab("👁️ Blind Assistance", id="blind"):
+                with gr.Column():
+                    universal_audio = gr.Audio(label="🎤 Speak (Voice Input)", type="filepath", sources=["microphone", "upload"])
+                    universal_text = gr.Textbox(label="⌨️ Type to Speak", lines=3)
+                    universal_image = gr.Image(label="📷 Capture Scene", type="filepath", sources=["webcam", "upload"])
+                    process_universal = gr.Button("Process Input", elem_classes="accessible-btn")
+                with gr.Column():
+                    universal_output = gr.Textbox(label="Output", lines=6)
+                    universal_audio_output = gr.Audio(label="Audio Output", type="filepath", interactive=False)
+                    universal_alert = gr.Textbox(label="Visual Alerts", visible=False)
+
+        # Blind Tab
+        with gr.Tab("👁️ Blind Assistance"):
             with gr.Row():
-                with gr.Column(scale=1):
-                    blind_audio = gr.Audio(
-                        label="Voice Commands",
-                        type="filepath", 
-                        sources=["microphone"]
-                    )
-                    blind_commands = gr.Radio(
-                        choices=[
-                            "describe scene",
-                            "read text", 
-                            "navigate",
-                            "help"
-                        ],
-                        label="Quick Commands",
-                        value="describe scene"
-                    )
-                    blind_image = gr.Image(
-                        label="Camera Feed",
-                        type="filepath",
-                        sources=["webcam", "upload"]
-                    )
-                    
-                    process_blind = gr.Button(
-                        "Execute Command",
-                        elem_classes="accessible-btn"
-                    )
-                
-                with gr.Column(scale=1):
-                    blind_output = gr.Textbox(
-                        label="Scene Description",
-                        lines=5
-                    )
-                    blind_audio_output = gr.Audio(
-                        label="Audio Description",
-                        type="filepath"
-                    )
-        
-        # Deaf Assistance Tab  
-        with gr.Tab("👂 Deaf Assistance", id="deaf"):
+                with gr.Column():
+                    blind_audio = gr.Audio(label="Voice Commands", type="filepath", sources=["microphone", "upload"])
+                    blind_commands = gr.Radio(choices=["describe scene", "read text", "navigate", "help"],
+                                              label="Quick Commands", value="describe scene")
+                    blind_image = gr.Image(label="Camera Feed", type="filepath", sources=["webcam", "upload"])
+                    process_blind = gr.Button("Execute Command", elem_classes="accessible-btn")
+                with gr.Column():
+                    blind_output = gr.Textbox(label="Scene Description", lines=5)
+                    blind_audio_output = gr.Audio(label="Audio Description", type="filepath")
+
+        # Deaf Tab
+        with gr.Tab("👂 Deaf Assistance"):
             with gr.Row():
-                with gr.Column(scale=1):
-                    deaf_audio = gr.Audio(
-                        label="Audio to Transcribe",
-                        type="filepath",
-                        sources=["microphone", "upload"]
-                    )
-                    continuous_listening = gr.Checkbox(
-                        label="Continuous Listening Mode",
-                        value=False
-                    )
-                    
-                    process_deaf = gr.Button(
-                        "Transcribe Audio",
-                        elem_classes="accessible-btn"
-                    )
-                
-                with gr.Column(scale=1):
-                    deaf_output = gr.Textbox(
-                        label="Transcription",
-                        lines=6
-                    )
-                    deaf_alerts = gr.Textbox(
-                        label="Sound Alerts",
-                        lines=2
-                    )
-        
-        # Non-Verbal Communication Tab
-        with gr.Tab("🤐 Non-Verbal Communication", id="non_verbal"):
+                with gr.Column():
+                    deaf_audio = gr.Audio(label="Audio to Transcribe", type="filepath", sources=["microphone", "upload"])
+                    continuous_listening = gr.Checkbox(label="Continuous Listening Mode", value=False)
+                    process_deaf = gr.Button("Transcribe Audio", elem_classes="accessible-btn")
+                with gr.Column():
+                    deaf_output = gr.Textbox(label="Transcription", lines=6)
+                    deaf_alerts = gr.Textbox(label="Sound Alerts", lines=2)
+
+        # Non-verbal Tab
+        with gr.Tab("🤐 Non-Verbal Communication"):
             with gr.Row():
-                with gr.Column(scale=1):
-                    preset_phrases = gr.Radio(
-                        choices=[
-                            "greeting", "help", "medical", "emergency", 
-                            "thanks", "yes", "no", "pain", "lost", "bathroom"
-                        ],
-                        label="Quick Phrases",
-                        value="greeting"
-                    )
-                    custom_phrase = gr.Textbox(
-                        label="Custom Message",
-                        placeholder="Or type your own message...",
-                        lines=2
-                    )
-                    
-                    speak_btn = gr.Button(
-                        "Speak Message",
-                        elem_classes="accessible-btn",
-                        size="lg"
-                    )
-                
-                with gr.Column(scale=1):
-                    spoken_text = gr.Textbox(
-                        label="Message",
-                        lines=3
-                    )
-                    message_audio = gr.Audio(
-                        label="Spoken Audio",
-                        type="filepath"
-                    )
-        
-        # Deaf-Blind Communication Tab
-        with gr.Tab("👁️👂 Deaf-Blind Communication", id="deaf_blind"):
+                with gr.Column():
+                    preset_phrases = gr.Radio(choices=["greeting", "help", "medical", "emergency", "thanks",
+                                                      "yes", "no", "pain", "lost", "bathroom"],
+                                              label="Quick Phrases", value="greeting")
+                    custom_phrase = gr.Textbox(label="Custom Message", lines=2)
+                    speak_btn = gr.Button("Speak Message", elem_classes="accessible-btn")
+                with gr.Column():
+                    spoken_text = gr.Textbox(label="Message", lines=3)
+                    message_audio = gr.Audio(label="Spoken Audio", type="filepath")
+
+        # Deaf-Blind Tab
+        with gr.Tab("👁️👂 Deaf-Blind Communication"):
             with gr.Row():
-                with gr.Column(scale=1):
-                    tactile_input = gr.Textbox(
-                        label="Message to Convert",
-                        placeholder="Enter text for tactile communication...",
-                        lines=3
-                    )
-                    output_format = gr.Radio(
-                        choices=["haptic", "braille"],
-                        label="Output Format",
-                        value="haptic"
-                    )
-                    
-                    convert_btn = gr.Button(
-                        "Convert to Tactile",
-                        elem_classes="accessible-btn"
-                    )
-                
-                with gr.Column(scale=1):
-                    braille_output = gr.Textbox(
-                        label="Braille Output",
-                        lines=3
-                    )
-                    vibration_pattern = gr.Textbox(
-                        label="Vibration Pattern",
-                        lines=2
-                    )
-        
-        # Feedback and Settings
-        with gr.Tab("⚙️ Settings & Feedback", id="settings"):
+                with gr.Column():
+                    tactile_input = gr.Textbox(label="Message to Convert", lines=3)
+                    output_format = gr.Radio(choices=["haptic", "braille"], label="Output Format", value="haptic")
+                    convert_btn = gr.Button("Convert to Tactile", elem_classes="accessible-btn")
+                with gr.Column():
+                    braille_output = gr.Textbox(label="Braille Output", lines=3)
+                    vibration_pattern = gr.Textbox(label="Vibration Pattern", lines=2)
+
+        # Settings & Feedback
+        with gr.Tab("⚙️ Settings & Feedback"):
             with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("### 🔧 Accessibility Settings")
+                with gr.Column():
                     high_contrast = gr.Checkbox(label="High Contrast Mode", value=False)
                     large_text = gr.Checkbox(label="Large Text Mode", value=False)
                     voice_navigation = gr.Checkbox(label="Voice Navigation", value=True)
-                    
-                    gr.Markdown("### 📧 Feedback")
                     feedback_email = gr.Textbox(label="Your Email (optional)")
-                    feedback_message = gr.Textbox(
-                        label="Feedback & Suggestions",
-                        placeholder="Help us improve VoiceBridge AI...",
-                        lines=4
-                    )
+                    feedback_message = gr.Textbox(label="Feedback & Suggestions", lines=4)
                     submit_feedback = gr.Button("Submit Feedback", elem_classes="accessible-btn")
                     feedback_status = gr.Textbox(label="Status", interactive=False)
-                
-                with gr.Column(scale=1):
-                    gr.Markdown("### 📊 System Information")
-                    conversation_history = gr.Textbox(
-                        label="Recent Conversation",
-                        lines=8,
-                        max_lines=10
-                    )
+                with gr.Column():
+                    conversation_history = gr.Textbox(label="Recent Conversation", lines=8, max_lines=10)
                     clear_history = gr.Button("Clear History", elem_classes="accessible-btn")
                     export_data = gr.Button("Export Data", elem_classes="accessible-btn")
-        
-        # ==================== EVENT HANDLERS ====================
-        
+
+        # ---------------- Event handlers (single definitions, no duplicates) ----------------
+
         def handle_mode_change(mode):
             voice_bridge.current_mode = mode
             status_msg = f"Mode changed to: {mode}"
             voice_bridge.add_to_conversation("System", status_msg)
-            return status_msg, status_msg  # For both status displays
-        
+            return status_msg, status_msg
+
         def handle_universal_input(audio, text, image, mode):
+            # prioritize audio > text > image
             if audio:
                 input_data = {'type': 'voice', 'audio': audio}
             elif text:
@@ -944,11 +818,10 @@ def create_production_interface():
             elif image:
                 input_data = {'type': 'image', 'image': image}
             else:
-                return "Please provide input", None, None
-            
+                return "Please provide input", None, ""
             result = voice_bridge.universal_communication(input_data)
-            return result['text'], result.get('audio'), result.get('visual_alert', '')
-        
+            return result.get('text', ''), result.get('audio', None), result.get('visual_alert', '')
+
         def handle_blind_assistance(audio, command, image):
             if audio:
                 transcript = voice_bridge.fallback_speech_to_text(audio)
@@ -957,124 +830,93 @@ def create_production_interface():
                 result = voice_bridge.blind_mode(command, image)
             else:
                 result = voice_bridge.blind_mode(command)
-            
-            return result['text'], result.get('audio')
-        
+            return result.get('text', ''), result.get('audio', None)
+
         def handle_deaf_assistance(audio, continuous):
             result = voice_bridge.deaf_mode(audio, continuous)
-            return result['text'], result.get('visual_alert', 'No important sounds detected')
-        
+            return result.get('text', ''), result.get('visual_alert', 'No important sounds detected')
+
         def handle_non_verbal(preset, custom):
-            text_to_speak = custom if custom else None
+            # preset radio contains phrase key
+            text_to_speak = custom if custom and custom.strip() else None
             result = voice_bridge.non_verbal_mode(text_to_speak, preset)
-            return result['text'], result.get('audio')
-        
-        def handle_deaf_blind(input_text, output_format):
-            result = voice_bridge.deaf_blind_mode(input_text, output_format)
-            braille = result.get('braille', '')
-            pattern = str(result.get('haptic_feedback', []))
-            return result['text'], braille, pattern
-        
-        def handle_emergency(contact):
-            if contact:
-                voice_bridge.emergency_contacts.append(contact)
-            result = voice_bridge.trigger_emergency_mode("manual")
-            return result['message'], result.get('audio')
-        
+            return result.get('text', ''), result.get('audio', None)
+
+        def handle_deaf_blind(input_text, out_format):
+            result = voice_bridge.deaf_blind_mode(input_text, out_format)
+            braille = result.get('braille', '') if result else ''
+            pattern = result.get('haptic_feedback', []) if result else []
+            # Return braille text and vibration pattern string
+            return braille, str(pattern)
+
         def handle_feedback(email, message):
-            if not message.strip():
-                return "Please enter feedback message"
-            
-            # In production, this would save to database/send email
-            feedback_data = {
-                'timestamp': datetime.now().isoformat(),
-                'email': email,
-                'message': message,
-                'mode': voice_bridge.current_mode
+            if not (message and message.strip()):
+                return "Please enter feedback before submitting."
+            fb = {
+                "timestamp": datetime.now().isoformat(),
+                "email": email,
+                "message": message
             }
-            
-            try:
-                # Save feedback locally
-                with open('data/feedback.json', 'a') as f:
-                    f.write(json.dumps(feedback_data) + '\n')
-                
-                return "✅ Thank you for your feedback! We'll review it soon. Contact: Naila.Rais@msftcommunity.com"
-            except Exception as e:
-                return f"❌ Could not save feedback: {str(e)}"
-        
-        # Connect event handlers
-        mode_selector.change(
-            handle_mode_change,
-            inputs=mode_selector,
-            outputs=[system_status, current_mode_display]
-        )
-        
-        process_universal.click(
-            handle_universal_input,
-            inputs=[universal_audio, universal_text, universal_image, mode_selector],
-            outputs=[universal_output, universal_audio_output, universal_alert]
-        )
-        
-        process_blind.click(
-            handle_blind_assistance,
-            inputs=[blind_audio, blind_commands, blind_image],
-            outputs=[blind_output, blind_audio_output]
-        )
-        
-        process_deaf.click(
-            handle_deaf_assistance,
-            inputs=[deaf_audio, continuous_listening],
-            outputs=[deaf_output, deaf_alerts]
-        )
-        
-        speak_btn.click(
-            handle_non_verbal,
-            inputs=[preset_phrases, custom_phrase],
-            outputs=[spoken_text, message_audio]
-        )
-        
-        convert_btn.click(
-            handle_deaf_blind,
-            inputs=[tactile_input, output_format],
-            outputs=[tactile_input, braille_output, vibration_pattern]
-        )
-        
-        emergency_btn.click(
-            handle_emergency,
-            inputs=emergency_contact_input,
-            outputs=[system_status, universal_audio_output]
-        )
-        
-        submit_feedback.click(
-            handle_feedback,
-            inputs=[feedback_email, feedback_message],
-            outputs=feedback_status
-        )
-        
-        # Initialize system
-        demo.load(
-            fn=lambda: ("System Ready - VoiceBridge AI Initialized", "universal"),
-            outputs=[system_status, current_mode_display]
-        )
-    
+            Path("data/feedback").mkdir(parents=True, exist_ok=True)
+            fname = f"data/feedback/feedback_{int(time.time())}.json"
+            with open(fname, "w") as f:
+                json.dump(fb, f, indent=2)
+            return "Thank you! Feedback submitted."
+
+        def handle_clear_history():
+            voice_bridge.conversation_history.clear()
+            return "History cleared."
+
+        def handle_export_data():
+            export_path = "data/export_conversation.json"
+            with open(export_path, "w") as f:
+                json.dump(voice_bridge.conversation_history, f, indent=2)
+            return f"Conversation exported to {export_path}"
+
+        def handle_emergency(contact=None):
+            if contact:
+                voice_bridge.emergency_contacts.append(contact)
+            result = voice_bridge.trigger_emergency_mode("manual_button")
+            # return message and (if available) audio path
+            return result.get("message", ""), result.get("audio", None)
+
+        # ---------------- Connect components ----------------
+
+        mode_selector.change(fn=handle_mode_change, inputs=mode_selector, outputs=[system_status, current_mode_display])
+
+        process_universal.click(fn=handle_universal_input, inputs=[universal_audio, universal_text, universal_image, mode_selector],
+                               outputs=[universal_output, universal_audio_output, universal_alert])
+
+        process_blind.click(fn=handle_blind_assistance, inputs=[blind_audio, blind_commands, blind_image],
+                            outputs=[blind_output, blind_audio_output])
+
+        process_deaf.click(fn=handle_deaf_assistance, inputs=[deaf_audio, continuous_listening],
+                           outputs=[deaf_output, deaf_alerts])
+
+        speak_btn.click(fn=handle_non_verbal, inputs=[preset_phrases, custom_phrase],
+                        outputs=[spoken_text, message_audio])
+
+        convert_btn.click(fn=handle_deaf_blind, inputs=[tactile_input, output_format], outputs=[braille_output, vibration_pattern])
+
+        submit_feedback.click(fn=handle_feedback, inputs=[feedback_email, feedback_message], outputs=feedback_status)
+
+        clear_history.click(fn=handle_clear_history, outputs=conversation_history)
+
+        export_data.click(fn=handle_export_data, outputs=feedback_status)
+
+        emergency_btn.click(fn=lambda: handle_emergency(emergency_contact_input.value), inputs=None, outputs=[system_status])
+
+        # initial load state
+        demo.load(fn=lambda: ("System Ready - VoiceBridge AI Initialized", voice_bridge.current_mode),
+                  outputs=[system_status, current_mode_display])
+
     return demo
 
-# Production deployment
+
+# ==================== LAUNCH ====================
+
 if __name__ == "__main__":
-    try:
-        print("🚀 Starting VoiceBridge AI Production Server...")
-        print("📧 Support & Feedback: Naila.Rais@msftcommunity.com")
-        print("🌐 Access the app at the URL provided below")
-        
-        demo = create_production_interface()
-        demo.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=True,
-            debug=False,
-            show_error=True,
-            auth=("NailaR", "voicebridge2025") if os.getenv('PRODUCTION') else None
-        )
-    except Exception as e:
-        logger.error(f"Failed to start production server: {e}")
-        print(f"❌ Startup failed: {e}")
+    # In most headless deployments (Hugging Face Spaces) you must NOT initialize the microphone.
+    # Set allow_microphone=True only if running on a device with a microphone and you want live mic support.
+    demo = create_production_interface(allow_microphone=False)
+    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)), share=False)