Update app.py

app.py

@@ -1,11 +1,15 @@
-import sounddevice as sd
-import scipy.io.wavfile as wav
-import numpy as np
-from pydub import AudioSegment
+from flask import Flask, request, jsonify, render_template
+import os
+import uuid
+import base64
+import logging
+from dotenv import load_dotenv
 import io
 import tempfile
-import os
-
+from gtts import gTTS
+from groq import Groq
+import speech_recognition as sr
+from pydub import AudioSegment
 
 # Set up logging
 logging.basicConfig(level=logging.DEBUG)
@@ -18,39 +22,24 @@ class AudioProcessor:
         
     def process_audio(self, audio_file):
         """Process incoming audio file and convert to proper format"""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            # Save incoming audio
-            input_path = os.path.join(temp_dir, 'input.webm')
-            audio_file.save(input_path)
-            
-            # Convert to WAV using pydub
-            audio = AudioSegment.from_file(input_path)
-            audio = audio.set_channels(self.channels)
-            audio = audio.set_frame_rate(self.sample_rate)
-            
-            output_path = os.path.join(temp_dir, 'output.wav')
-            audio.export(output_path, format='wav')
-            
-            # Read the processed audio file
-            return output_path
-
-    def record_audio(self, duration=5):
-        """Record audio using sounddevice"""
-        recording = sd.rec(
-            int(duration * self.sample_rate),
-            samplerate=self.sample_rate,
-            channels=self.channels
-        )
-        sd.wait()
-        return recording
-
-
-
-
-try:
-    import pyaudio
-except ImportError:
-    print("Warning: PyAudio not available, speech functionality will be limited")
+        try:
+            with tempfile.TemporaryDirectory() as temp_dir:
+                # Save incoming audio
+                input_path = os.path.join(temp_dir, 'input.webm')
+                audio_file.save(input_path)
+                
+                # Convert to WAV using pydub
+                audio = AudioSegment.from_file(input_path)
+                audio = audio.set_channels(self.channels)
+                audio = audio.set_frame_rate(self.sample_rate)
+                
+                output_path = os.path.join(temp_dir, 'output.wav')
+                audio.export(output_path, format='wav')
+                
+                return output_path
+        except Exception as e:
+            logger.error(f"Error processing audio: {e}")
+            raise
 
 # Initialize Flask app
 app = Flask(__name__, static_folder='static')
@@ -66,15 +55,6 @@ MODEL = "llama3-70b-8192"
 # Initialize speech recognition
 recognizer = sr.Recognizer()
 
-def init_speech_recognition():
-    """Initialize speech recognition with fallback options"""
-    try:
-        recognizer = sr.Recognizer()
-        return recognizer
-    except Exception as e:
-        logger.error(f"Failed to initialize speech recognition: {e}")
-        return None
-        
 # Store conversation history
 conversations = {}
 
@@ -83,7 +63,7 @@ def load_base_prompt():
         with open("base_prompt.txt", "r") as file:
             return file.read().strip()
     except FileNotFoundError:
-        print("Error: base_prompt.txt file not found.")
+        logger.warning("base_prompt.txt not found, using default prompt")
         return "You are a helpful assistant for language learning."
 
 # Load the base prompt
@@ -117,7 +97,7 @@ def chat_with_groq(user_message, conversation_id=None):
         
         return assistant_message
     except Exception as e:
-        print(f"Error in chat_with_groq: {str(e)}")
+        logger.error(f"Error in chat_with_groq: {e}")
         return f"I apologize, but I'm having trouble responding right now. Error: {str(e)}"
 
 def text_to_speech(text):
@@ -128,17 +108,12 @@ def text_to_speech(text):
         audio_io.seek(0)
         return audio_io
     except Exception as e:
-        print(f"Error in text_to_speech: {str(e)}")
+        logger.error(f"Error in text_to_speech: {e}")
         return None
 
-def speech_to_text(audio_file):
+def speech_to_text(audio_path):
     try:
-        # Save the uploaded audio to a temporary file
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as temp_audio:
-            audio_file.save(temp_audio.name)
-            
-        # Use SpeechRecognition to convert speech to text
-        with sr.AudioFile(temp_audio.name) as source:
+        with sr.AudioFile(audio_path) as source:
             # Adjust recognition settings
             recognizer.dynamic_energy_threshold = True
             recognizer.energy_threshold = 4000
@@ -146,23 +121,18 @@ def speech_to_text(audio_file):
             # Record the entire audio file
             audio = recognizer.record(source)
             
-            # Perform recognition with increased timeout
+            # Perform recognition
             text = recognizer.recognize_google(audio, language='en-US')
             return text
             
     except sr.UnknownValueError:
         return "Could not understand audio"
     except sr.RequestError as e:
+        logger.error(f"Speech recognition request error: {e}")
         return f"Could not request results; {str(e)}"
     except Exception as e:
-        print(f"Error in speech_to_text: {str(e)}")
+        logger.error(f"Error in speech_to_text: {e}")
         return None
-    finally:
-        # Clean up temporary file
-        try:
-            os.unlink(temp_audio.name)
-        except:
-            pass
 
 @app.route('/')
 def index():
@@ -195,6 +165,7 @@ def chat():
         return jsonify(result)
     
     except Exception as e:
+        logger.error(f"Error in chat endpoint: {e}")
         return jsonify({'error': str(e)}), 500
 
 @app.route('/api/voice', methods=['POST'])
@@ -211,10 +182,7 @@ def handle_voice():
         wav_path = audio_processor.process_audio(audio_file)
         
         # Perform speech recognition
-        recognizer = sr.Recognizer()
-        with sr.AudioFile(wav_path) as source:
-            audio_data = recognizer.record(source)
-            text = recognizer.recognize_google(audio_data)
+        text = speech_to_text(wav_path)
         
         if not text:
             return jsonify({'error': 'Could not transcribe audio'}), 400
@@ -237,7 +205,8 @@ def handle_voice():
         return jsonify(result)
         
     except Exception as e:
-        print(f"Error in handle_voice: {str(e)}")
+        logger.error(f"Error in handle_voice: {e}")
         return jsonify({'error': str(e)}), 400
+
 if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860)
+    app.run(host='0.0.0.0', port=7860)