Update app.py

app.py

@@ -1,21 +1,25 @@
-
 import os
 import sys
 import json
 import logging
 import re
 import hashlib
+import io
+import base64
 from datetime import datetime
 from typing import List, Dict, Optional, Tuple
 from enum import Enum
 
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import StreamingResponse
+from fastapi import FastAPI, HTTPException, UploadFile, File, Query
+from fastapi.responses import StreamingResponse, JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 import asyncio
-from fastapi import Query
 from bson import ObjectId
+import speech_recognition as sr
+from gtts import gTTS
+from pydub import AudioSegment
+from pydub.playback import play
 from txagent.txagent import TxAgent
 from db.mongo import get_mongo_client
 
@@ -24,7 +28,7 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(
 logger = logging.getLogger("TxAgentAPI")
 
 # App
-app = FastAPI(title="TxAgent API", version="2.2.1")  # Version for hash-based analysis
+app = FastAPI(title="TxAgent API", version="2.3.0")  # Updated version for voice support
 
 app.add_middleware(
     CORSMiddleware,
@@ -32,7 +36,7 @@ app.add_middleware(
     allow_methods=["*"], allow_headers=["*"]
 )
 
-# Pydantic
+# Pydantic Models
 class ChatRequest(BaseModel):
     message: str
     temperature: float = 0.7
@@ -40,6 +44,16 @@ class ChatRequest(BaseModel):
     history: Optional[List[Dict]] = None
     format: Optional[str] = "clean"
 
+class VoiceInputRequest(BaseModel):
+    audio_format: str = "wav"
+    language: str = "en-US"
+
+class VoiceOutputRequest(BaseModel):
+    text: str
+    language: str = "en"
+    slow: bool = False
+    return_format: str = "mp3"  # mp3 or base64
+
 # Enums
 class RiskLevel(str, Enum):
     NONE = "none"
@@ -243,6 +257,39 @@ async def analyze_all_patients():
         await analyze_patient(patient)
         await asyncio.sleep(0.1)
 
+def recognize_speech(audio_data: bytes, language: str = "en-US") -> str:
+    """Convert speech to text using Google's speech recognition"""
+    recognizer = sr.Recognizer()
+    
+    try:
+        # Convert bytes to AudioFile
+        with io.BytesIO(audio_data) as audio_file:
+            with sr.AudioFile(audio_file) as source:
+                audio = recognizer.record(source)
+                text = recognizer.recognize_google(audio, language=language)
+                return text
+    except sr.UnknownValueError:
+        logger.error("Google Speech Recognition could not understand audio")
+        raise HTTPException(status_code=400, detail="Could not understand audio")
+    except sr.RequestError as e:
+        logger.error(f"Could not request results from Google Speech Recognition service; {e}")
+        raise HTTPException(status_code=503, detail="Speech recognition service unavailable")
+    except Exception as e:
+        logger.error(f"Error in speech recognition: {e}")
+        raise HTTPException(status_code=500, detail="Error processing speech")
+
+def text_to_speech(text: str, language: str = "en", slow: bool = False) -> bytes:
+    """Convert text to speech using gTTS and return as MP3 bytes"""
+    try:
+        tts = gTTS(text=text, lang=language, slow=slow)
+        mp3_fp = io.BytesIO()
+        tts.write_to_fp(mp3_fp)
+        mp3_fp.seek(0)
+        return mp3_fp.read()
+    except Exception as e:
+        logger.error(f"Error in text-to-speech conversion: {e}")
+        raise HTTPException(status_code=500, detail="Error generating speech")
+
 @app.on_event("startup")
 async def startup_event():
     global agent, patients_collection, analysis_collection, alerts_collection
@@ -276,7 +323,8 @@ async def status():
     return {
         "status": "running",
         "timestamp": datetime.utcnow().isoformat(),
-        "version": "2.2.1"
+        "version": "2.3.0",
+        "features": ["chat", "voice-input", "voice-output", "patient-analysis"]
     }
 
 @app.get("/patients/analysis-results")
@@ -342,3 +390,89 @@ async def chat_stream_endpoint(request: ChatRequest):
             yield f"⚠️ Error: {e}"
 
     return StreamingResponse(token_stream(), media_type="text/plain")
+
+@app.post("/voice/transcribe")
+async def transcribe_voice(
+    audio: UploadFile = File(...),
+    language: str = Query("en-US", description="Language code for speech recognition")
+):
+    """Convert speech to text"""
+    try:
+        # Read audio file
+        audio_data = await audio.read()
+        
+        # Validate audio format
+        if not audio.filename.lower().endswith(('.wav', '.mp3', '.ogg', '.flac')):
+            raise HTTPException(status_code=400, detail="Unsupported audio format")
+        
+        # Convert speech to text
+        text = recognize_speech(audio_data, language)
+        
+        return {"text": text}
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in voice transcription: {e}")
+        raise HTTPException(status_code=500, detail="Error processing voice input")
+
+@app.post("/voice/synthesize")
+async def synthesize_voice(request: VoiceOutputRequest):
+    """Convert text to speech"""
+    try:
+        # Generate speech from text
+        audio_data = text_to_speech(request.text, request.language, request.slow)
+        
+        if request.return_format == "base64":
+            # Return as base64 encoded string
+            return {"audio": base64.b64encode(audio_data).decode('utf-8')}
+        else:
+            # Return as MP3 file
+            return StreamingResponse(
+                io.BytesIO(audio_data),
+                media_type="audio/mpeg",
+                headers={"Content-Disposition": "attachment; filename=speech.mp3"}
+            )
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in voice synthesis: {e}")
+        raise HTTPException(status_code=500, detail="Error generating voice output")
+
+@app.post("/voice/chat")
+async def voice_chat_endpoint(
+    audio: UploadFile = File(...),
+    language: str = Query("en-US", description="Language code for speech recognition"),
+    temperature: float = Query(0.7, ge=0.1, le=1.0),
+    max_new_tokens: int = Query(512, ge=50, le=1024)
+):
+    """Complete voice chat interaction (speech-to-text -> AI -> text-to-speech)"""
+    try:
+        # Step 1: Convert speech to text
+        audio_data = await audio.read()
+        user_message = recognize_speech(audio_data, language)
+        
+        # Step 2: Get AI response
+        chat_response = agent.chat(
+            message=user_message,
+            history=[],
+            temperature=temperature,
+            max_new_tokens=max_new_tokens
+        )
+        
+        # Step 3: Convert response to speech
+        audio_data = text_to_speech(chat_response, language.split('-')[0])
+        
+        # Return as MP3 file
+        return StreamingResponse(
+            io.BytesIO(audio_data),
+            media_type="audio/mpeg",
+            headers={"Content-Disposition": "attachment; filename=response.mp3"}
+        )
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in voice chat: {e}")
+        raise HTTPException(status_code=500, detail="Error processing voice chat")