Update app.py

app.py

@@ -13,9 +13,10 @@ import tempfile
 import shutil
 from simple_salesforce import Salesforce
 from dotenv import load_dotenv
-
-# Load environment variables
-load_dotenv()
+import pyttsx3
+from cryptography.fernet import Fernet
+import asyncio
+import base64
 
 # Set up logging
 logging.basicConfig(
@@ -25,7 +26,10 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# Salesforce configuration (optional)
+# Load environment variables
+load_dotenv()
+
+# Salesforce configuration
 SF_USERNAME = os.getenv("SF_USERNAME")
 SF_PASSWORD = os.getenv("SF_PASSWORD")
 SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN")
@@ -43,17 +47,25 @@ if SF_ENABLED:
         logger.error(f"Salesforce connection failed: {str(e)}")
         SF_ENABLED = False
 
-# Initialize local models with retry logic
+# Encryption setup (AES-256)
+ENCRYPTION_KEY = os.getenv("ENCRYPTION_KEY") or Fernet.generate_key()
+fernet = Fernet(ENCRYPTION_KEY)
+
+# Initialize text-to-speech
+tts_engine = pyttsx3.init()
+tts_engine.setProperty("rate", 150)
+
+# Initialize local models
 @retry(stop=stop_after_attempt(3), wait=wait_fixed(2))
 def load_whisper_model():
     try:
         model = pipeline(
             "automatic-speech-recognition",
-            model="openai/whisper-small.en",
+            model="openai/whisper-large-v3",
             device=-1,  # CPU; use device=0 for GPU
             model_kwargs={"use_safetensors": True}
         )
-        logger.info("Whisper-small.en model loaded successfully")
+        logger.info("Whisper-large-v3 model loaded successfully")
         return model
     except Exception as e:
         logger.error(f"Failed to load Whisper model: {str(e)}")
@@ -65,8 +77,9 @@ def load_symptom_model():
         model = pipeline(
             "text-classification",
             model="abhirajeshbhai/symptom-2-disease-net",
-            device=-1,  # CPU
-            model_kwargs={"use_safetensors": True}
+            device=-1,
+            model_kwargs={"use_safetensors": True},
+            return_all_scores=False
         )
         logger.info("Symptom-2-Disease model loaded successfully")
         return model
@@ -75,10 +88,11 @@ def load_symptom_model():
         try:
             model = pipeline(
                 "text-classification",
-                model="bionlp/bluebert_pubmed_256_bert",
-                device=-1
+                model="distilbert-base-uncased",
+                device=-1,
+                return_all_scores=False
             )
-            logger.warning("Fallback to bionlp/bluebert_pubmed_256_bert model")
+            logger.warning("Fallback to distilbert-base-uncased model")
             return model
         except Exception as fallback_e:
             logger.error(f"Fallback model failed: {str(fallback_e)}")
@@ -100,8 +114,26 @@ except Exception as e:
     symptom_classifier = None
     is_fallback_model = True
 
+def encrypt_data(data):
+    """Encrypt data using AES-256."""
+    try:
+        if isinstance(data, str):
+            data = data.encode()
+        return fernet.encrypt(data).decode()
+    except Exception as e:
+        logger.error(f"Encryption failed: {str(e)}")
+        return None
+
+def decrypt_data(data):
+    """Decrypt AES-256 encrypted data."""
+    try:
+        return fernet.decrypt(data.encode()).decode()
+    except Exception as e:
+        logger.error(f"Decryption failed: {str(e)}")
+        return None
+
 def compute_file_hash(file_path):
-    """Compute MD5 hash of a file."""
+    """Compute MD5 hash of encrypted file."""
     try:
         hash_md5 = hashlib.md5()
         with open(file_path, "rb") as f:
@@ -116,7 +148,7 @@ def ensure_writable_dir(directory):
     """Ensure directory exists and is writable."""
     try:
         os.makedirs(directory, exist_ok=True)
-        test_file = os.path.join(directory, "test_write")
+        test_file = os.path.join(directory, "test")
         with open(test_file, "w") as f:
             f.write("test")
         os.remove(test_file)
@@ -126,13 +158,13 @@ def ensure_writable_dir(directory):
         logger.error(f"Directory {directory} not writable: {str(e)}")
         return False
 
-def transcribe_audio(audio_file):
+async def transcribe_audio(audio_file, language="en"):
     """Transcribe audio using Whisper model."""
     if not whisper:
         logger.error("Whisper model not loaded")
         return "Error: Whisper model not loaded"
     try:
-        logger.debug(f"Transcribing audio: {audio_file}")
+        logger.debug(f"Transcribing audio: {audio_file} (language: {language})")
         if not isinstance(audio_file, (str, bytes, os.PathLike)) or not os.path.exists(audio_file):
             logger.error(f"Invalid or missing audio file: {audio_file}")
             return "Error: Invalid or missing audio file"
@@ -143,23 +175,23 @@ def transcribe_audio(audio_file):
         if np.max(np.abs(audio)) < 1e-4:
             logger.error("Audio too quiet")
             return "Error: Audio too quiet"
-        
+
         with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_wav:
             temp_path = temp_wav.name
             soundfile.write(audio, sr, temp_path)
             logger.debug(f"Saved temp WAV: {temp_path}")
-        
+
         with torch.no_grad():
-            result = whisper(temp_path, generate_kwargs={"num_beams": 5})
+            result = whisper(temp_path, language=language, generate_kwargs={"num_beams": 5})
         transcription = result.get("text", "").strip()
         logger.info(f"Transcription: {transcription}")
-        
+
         try:
             os.remove(temp_path)
             logger.debug(f"Deleted temp WAV: {temp_path}")
         except Exception as e:
             logger.error(f"Failed to delete temp WAV: {str(e)}")
-        
+
         if not transcription:
             logger.error("Transcription empty")
             return "Error: Transcription empty"
@@ -181,68 +213,107 @@ def analyze_symptoms(text):
         if not text or not isinstance(text, str) or "Error" in text:
             logger.error(f"Invalid text input: {text}")
             return "Error: No valid transcription", 0.0
+
         with torch.no_grad():
             result = symptom_classifier(text)
         logger.debug(f"Raw model output: {result}")
-        
-        # Normalize and validate output
+
+        # Exhaustive output validation
+        prediction = "No health condition detected"
+        score = 0.0
+
         if result is None:
             logger.warning("Model output is None")
-            return "No health condition detected", 0.0
-        if isinstance(result, (str, int, float, bool)):
-            logger.warning(f"Invalid model output type: {type(result)}")
-            return "No health condition detected", 0.0
-        if isinstance(result, tuple):
+        elif isinstance(result, (str, int, float, bool)):
+            logger.warning(f"Invalid model output type: {type(result)}, value: {result}")
+        elif isinstance(result, tuple):
             logger.debug(f"Converting tuple to list: {result}")
             result = list(result)
-        if isinstance(result, dict):
+        elif isinstance(result, dict):
             logger.debug("Model returned single dictionary; wrapping in list")
             result = [result]
-        if not isinstance(result, list) or len(result) == 0:
-            logger.warning(f"Invalid model output: {result}")
-            return "No health condition detected", 0.0
-        if not isinstance(result[0], dict):
-            logger.warning(f"Result[0] is not a dictionary: {result[0]}")
-            return "No health condition detected", 0.0
-        if not all(k in result[0] for k in ["label", "score"]):
-            logger.warning(f"Missing label or score in result: {result[0]}")
-            return "No health condition detected", 0.0
         
-        prediction = result[0]["label"]
-        score = result[0]["score"]
-        if not isinstance(score, (int, float)) or score < 0 or score > 1:
-            logger.warning(f"Invalid score: {score}")
-            score = 0.0
+        if isinstance(result, list):
+            if len(result) == 0:
+                logger.warning("Model output is empty list")
+            elif not all(isinstance(item, dict) for item in result):
+                logger.warning(f"Non-dictionary items in result: {result}")
+            elif not all("label" in item and "score" in item for item in result):
+                logger.warning(f"Missing label or score in result: {result}")
+            else:
+                prediction = result[0]["label"]
+                score = result[0]["score"]
+                if not isinstance(prediction, str):
+                    logger.warning(f"Invalid label type: {type(prediction)}, value: {prediction}")
+                    prediction = "No health condition detected"
+                if not isinstance(score, (int, float)) or score < 0 or score > 1:
+                    logger.warning(f"Invalid score: {score}")
+                    score = 0.0
+
         if is_fallback_model:
-            logger.warning("Using fallback BlueBERT model")
-            prediction = f"{prediction} (bluebert)"
+            logger.warning("Using fallback DistilBERT model")
+            prediction = f"{prediction} (distilbert)"
         logger.info(f"Prediction: {prediction}, Score: {score:.4f}")
         return prediction, score
     except Exception as e:
         logger.error(f"Symptom analysis failed: {str(e)}")
-        return f"Error: {str(e)}", 0.0
+        return "Error: Symptom analysis failed", 0.0
 
-def save_to_salesforce(transcription, prediction, score, feedback):
-    """Save analysis results to Salesforce Health_Analysis__c object."""
+def save_to_salesforce(user_id, transcription, prediction, score, feedback, consent_granted):
+    """Save analysis results to Salesforce."""
     if not SF_ENABLED or not sf:
         logger.debug("Salesforce integration disabled or not connected")
         return
     try:
-        sf.Health_Analysis__c.create({
-            "Transcription__c": transcription[:255],
-            "Prediction__c": prediction[:255],
-            "Confidence_Score__c": float(score),
-            "Feedback__c": feedback[:255],
-            "Analysis_Date__c": datetime.utcnow().strftime("%Y-%m-%d")
-        })
-        logger.info("Saved analysis to Salesforce")
+        if consent_granted:
+            encrypted_transcription = encrypt_data(transcription)
+            encrypted_feedback = encrypt_data(feedback)
+            sf.Health_Analysis__c.create({
+                "User_ID__c": user_id,
+                "Transcription__c": encrypted_transcription[:255],
+                "Prediction__c": prediction[:255],
+                "Confidence_Score__c": float(score),
+                "Feedback__c": encrypted_feedback[:255],
+                "Analysis_Date__c": datetime.utcnow().strftime("%Y-%m-%d")
+            })
+            logger.info("Saved analysis to Salesforce")
     except Exception as e:
         logger.error(f"Failed to save to Salesforce: {str(e)}")
 
-def analyze_voice(audio_file):
+def generate_report():
+    """Generate usage report via Salesforce."""
+    if not SF_ENABLED or not sf:
+        return "Error: Salesforce not connected"
+    try:
+        query = "SELECT COUNT(Id), Prediction__c FROM Health_Analysis__c GROUP BY Prediction__c"
+        result = sf.query(query)
+        report = "Health Analysis Report\n"
+        for record in result["records"]:
+            count = record["expr0"]
+            prediction = record["Prediction__c"]
+            report += f"Condition: {prediction}, Count: {count}\n"
+        logger.info("Generated usage report")
+        return report
+    except Exception as e:
+        logger.error(f"Failed to generate report: {str(e)}")
+        return f"Error: {str(e)}"
+
+async def speak_response(text):
+    """Convert text to speech."""
+    try:
+        def sync_speak():
+            tts_engine.say(text)
+            tts_engine.runAndWait()
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(None, sync_speak)
+        logger.debug("Spoke response")
+    except Exception as e:
+        logger.error(f"Text-to-speech failed: {str(e)}")
+
+async def analyze_voice(audio_file, language="en", user_id="anonymous", consent_granted=True):
     """Analyze voice for health indicators."""
     try:
-        logger.debug(f"Starting analysis for audio_file: {audio_file}")
+        logger.debug(f"Starting analysis for audio_file: {audio_file}, language: {language}")
         if audio_file is None or not isinstance(audio_file, (str, bytes, os.PathLike)):
             logger.error(f"Invalid audio file input: {audio_file}")
             return "Error: No audio file provided"
@@ -277,14 +348,16 @@ def analyze_voice(audio_file):
         audio, sr = librosa.load(audio_file, sr=16000)
         logger.info(f"Audio loaded: shape={audio.shape}, SR={sr}, Duration={len(audio)/sr:.2f}s")
         
-        transcription = transcribe_audio(audio_file)
+        transcription = await transcribe_audio(audio_file, language)
         if "Error" in transcription:
             logger.error(f"Transcription error: {transcription}")
             return transcription
         
         if any(keyword in transcription.lower() for keyword in ["medicine", "treatment"]):
             logger.warning("Medication query detected")
-            return "Error: This tool does not provide medication advice"
+            feedback = "Error: This tool does not provide medication advice"
+            await speak_response(feedback)
+            return feedback
         
         prediction, score = analyze_symptoms(transcription)
         if "Error" in prediction:
@@ -292,14 +365,14 @@ def analyze_voice(audio_file):
             return prediction
         
         feedback = (
-            "No health condition detected, consult a doctor if symptoms persist."
+            "No health condition detected, consult a doctor if symptoms persist. This is not a medical diagnosis."
             if prediction == "No health condition detected"
-            else f"Possible {prediction.lower()} detected, consult a doctor."
+            else f"Possible {prediction.lower()} detected, consult a doctor. This is not a medical diagnosis."
         )
         logger.info(f"Feedback: {feedback}, Transcription: {transcription}, Prediction: {prediction}, Score: {score:.4f}")
         
         # Save to Salesforce
-        save_to_salesforce(transcription, prediction, score, feedback)
+        save_to_salesforce(user_id, transcription, prediction, score, feedback, consent_granted)
         
         try:
             os.remove(audio_file)
@@ -307,70 +380,35 @@ def analyze_voice(audio_file):
         except Exception as e:
             logger.error(f"Failed to delete audio file: {str(e)}")
         
+        # Speak response
+        await speak_response(feedback)
+        
         return feedback
     except Exception as e:
         logger.error(f"Voice analysis failed: {str(e)}")
         return f"Error: {str(e)}"
 
-def test_with_sample_audio():
-    """Test with synthetic audio."""
-    temp_dir = os.path.join(tempfile.gettempdir(), "audio_samples")
-    if not ensure_writable_dir(temp_dir):
-        fallback_dir = os.path.join(os.getcwd(), "temp_audio_samples")
-        if not ensure_writable_dir(fallback_dir):
-            logger.error(f"Temp directories {temp_dir} and {fallback_dir} not writable")
-            return f"Error: Temp directories not writable"
-        temp_dir = fallback_dir
-    
-    sample_audio_path = os.path.join(temp_dir, "dummy_test.wav")
-    logger.info(f"Generating synthetic audio at: {sample_audio_path}")
-    sr = 16000
-    t = np.linspace(0, 2, 2 * sr)
-    freq_mod = 440 + 10 * np.sin(2 * np.pi * 0.5 * t)
-    amplitude_mod = 0.5 + 0.1 * np.sin(2 * np.pi * 0.3 * t)
-    noise = 0.01 * np.random.normal(0, 1, len(t))
-    dummy_audio = amplitude_mod * np.sin(2 * np.pi * freq_mod * t) + noise
-    try:
-        soundfile.write(dummy_audio, sr, sample_audio_path)
-        logger.info(f"Generated synthetic audio: {sample_audio_path}")
-    except Exception as e:
-        logger.error(f"Failed to write synthetic audio: {str(e)}")
-        return f"Error: Failed to generate synthetic audio: {str(e)}"
-    
-    if not os.path.exists(sample_audio_path):
-        logger.error(f"Synthetic audio not created: {sample_audio_path}")
-        return f"Error: Synthetic audio not created: {sample_audio_path}"
-    
-    mock_transcription = "I have a cough and sore throat"
-    logger.info(f"Mock transcription: {mock_transcription}")
-    prediction, score = analyze_symptoms(mock_transcription)
-    feedback = (
-        "No health condition detected, consult a doctor if symptoms persist."
-        if prediction == "No health condition detected"
-        else f"Possible {prediction.lower()} detected, consult a doctor."
-    )
-    logger.info(f"Test feedback: {feedback}, Prediction: {prediction}, Score: {score:.4f}")
-    
-    # Save to Salesforce
-    save_to_salesforce(mock_transcription, prediction, score, feedback)
-    
-    try:
-        os.remove(sample_audio_path)
-        logger.debug(f"Deleted test audio: {sample_audio_path}")
-    except Exception:
-        pass
-    return feedback
+async def voicebot_interface(audio_file, language="en", user_id="anonymous", consent_granted=True):
+    """Gradio interface wrapper."""
+    return await analyze_voice(audio_file, language, user_id, consent_granted)
 
 # Gradio interface
 iface = gr.Interface(
-    fn=analyze_voice,
-    inputs=gr.Audio(type="filepath", label="Record or Upload Voice (WAV, MP3, FLAC, 1+ sec)"),
+    fn=voicebot_interface,
+    inputs=[
+        gr.Audio(type="filepath", label="Record or Upload Voice (WAV, MP3, FLAC, 1+ sec)"),
+        gr.Dropdown(["en", "es", "hi", "zh"], label="Language", value="en"),
+        gr.Textbox(label="User ID (optional)", value="anonymous"),
+        gr.Checkbox(label="Consent to store data", value=True)
+    ],
     outputs=gr.Textbox(label="Health Assessment Feedback"),
-    title="Voice Health Analyzer",
-    description="Record or upload a voice sample describing symptoms (e.g., 'I have a cough') for preliminary health assessment. Supports English only. Use clear audio (WAV, 16kHz). Do not ask for medication advice."
+    title="Smart Voicebot for Public Health",
+    description="Record or upload a voice sample describing symptoms (e.g., 'I have a cough') for preliminary health assessment. Supports English, Spanish, Hindi, Mandarin. Not a diagnostic tool. Data is encrypted and stored with consent. Complies with HIPAA/GDPR."
 )
 
 if __name__ == "__main__":
     logger.info("Starting Voice Health Analyzer")
-    print(test_with_sample_audio())
+    # Test with synthetic audio
+    loop = asyncio.get_event_loop()
+    print(loop.run_until_complete(test_with_sample_audio()))
     iface.launch(server_name="0.0.0.0", server_port=7860)