Update main.py

main.py

@@ -25,6 +25,8 @@ from PyPDF2 import PdfReader
 import wikipedia
 from youtube_transcript_api import YouTubeTranscriptApi
 import arxiv # For ArXiv
+from elevenlabs import play, stream, save
+import math
 
 # --- Environment Variables ---
 # Load environment variables if using a .env file (optional, good practice)
@@ -883,7 +885,9 @@ def submit_quiz_attempt(quiz_id):
         return jsonify({'error': f'An unexpected error occurred: {e}'}), 500
 
 
-@app.route('/api/tutor/notes/<uuid:notes_id>/speak', methods=['GET'])
+
+# Modified speak_notes endpoint with ElevenLabs Studio API and chunking
+@app.route('/api/tutor/notes/<uuid:notes_id>/speak', methods=['POST'])  # Changed to POST since it creates resources
 def speak_notes(notes_id):
     user, error = verify_token(request.headers.get('Authorization'))
     if error:
@@ -893,63 +897,122 @@ def speak_notes(notes_id):
         return jsonify({'error': 'Backend service unavailable'}), 503
 
     try:
+        # Check user status and credits
         profile_res = supabase.table('profiles').select('credits', 'suspended').eq('id', user.id).single().execute()
-
         if profile_res.data['suspended']:
             return jsonify({'error': 'Account suspended'}), 403
         if profile_res.data['credits'] < 5:
             return jsonify({'error': 'Insufficient credits (Need 5)'}), 402
 
         # Fetch notes content
-        notes_res = supabase.table('notes').select('content').eq('id', notes_id).single().execute()
-        if not notes_res.data or 'content' not in notes_res.data:
-            return jsonify({'error': 'Notes not found or missing content'}), 404
+        notes_res = supabase.table('notes').select('content, tts_audio_url').eq('id', notes_id).single().execute()
+        if not notes_res.data:
+            return jsonify({'error': 'Notes not found'}), 404
+            
+        # Return existing audio if available
+        if notes_res.data.get('tts_audio_url'):
+            return jsonify({
+                'success': True,
+                'audio_url': notes_res.data['tts_audio_url'],
+                'message': 'Using existing audio file'
+            })
 
         notes_content = notes_res.data['content']
         if not notes_content:
-            return jsonify({'error': 'Notes content is empty, cannot generate audio.'}), 400
+            return jsonify({'error': 'Notes content is empty'}), 400
 
-        # --- Generate TTS Audio ---
+        # --- Generate TTS Audio with chunking ---
         start_time = time.time()
         logging.info(f"Generating TTS for user {user.id}, notes: {notes_id}")
-        audio_bytes = generate_tts_audio(notes_content)  # Add voice selection if needed
+        
+        # Chunk text if too long (ElevenLabs limit is ~2500 chars for best quality)
+        CHUNK_SIZE = 2000  # Conservative chunk size
+        chunks = [notes_content[i:i+CHUNK_SIZE] for i in range(0, len(notes_content), CHUNK_SIZE)]
+        
+        audio_bytes = b""
+        for chunk in chunks:
+            try:
+                # Using ElevenLabs Studio API with streaming
+                chunk_audio = elevenlabs_client.generate(
+                    text=chunk,
+                    voice="Rachel",  # Default voice
+                    model="eleven_multilingual_v2",
+                    stream=True
+                )
+                audio_bytes += b"".join(chunk_audio)
+            except Exception as e:
+                logging.error(f"Error generating chunk: {str(e)}")
+                raise RuntimeError(f"Failed to generate audio chunk: {str(e)}")
+
+        if not audio_bytes:
+            raise RuntimeError("Generated empty audio file")
+
         logging.info(f"TTS generation took {time.time() - start_time:.2f}s")
 
-        # --- Save Audio to Supabase Storage ---
-        bucket_name = 'notes-audio'  # Ensure this bucket exists in Supabase Storage
+        # --- Save to Supabase Storage ---
+        bucket_name = 'notes-audio'
         destination_path = f'users/{user.id}/{notes_id}.mp3'
-        content_type = 'audio/mpeg'
-
-        # Use a temporary file to upload
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_audio_file:
-            tmp_audio_file.write(audio_bytes)
-            tmp_file_path = tmp_audio_file.name
+        
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
+            tmp_file.write(audio_bytes)
+            tmp_path = tmp_file.name
 
         try:
-            audio_url = upload_to_supabase_storage(bucket_name, tmp_file_path, destination_path, content_type)
-            logging.info(f"Uploaded TTS audio to: {audio_url}")
+            # Upload with proper content type
+            audio_url = upload_to_supabase_storage(
+                bucket_name,
+                tmp_path,
+                destination_path,
+                "audio/mpeg"
+            )
 
-            # --- Update notes table with the URL ---
+            # Update database
             supabase.table('notes').update({'tts_audio_url': audio_url}).eq('id', notes_id).execute()
-
-            # Deduct 5 credits after successful generation
+            
+            # Deduct credits
             new_credits = profile_res.data['credits'] - 5
             supabase.table('profiles').update({'credits': new_credits}).eq('id', user.id).execute()
 
-            return jsonify({'success': True, 'audio_url': audio_url})
+            return jsonify({
+                'success': True,
+                'audio_url': audio_url,
+                'remaining_credits': new_credits
+            })
 
         finally:
-            os.remove(tmp_file_path)  # Clean up temporary file
+            os.remove(tmp_path)
 
-    except ConnectionError as e:
-        logging.error(f"Connection error during TTS generation: {e}")
-        return jsonify({'error': f'A backend service is unavailable: {e}'}), 503
-    except RuntimeError as e:  # AI generation errors
-        logging.error(f"RuntimeError during TTS generation for user {user.id}: {e}")
+    except Exception as e:
+        logging.error(f"Error in speak_notes: {traceback.format_exc()}")
         return jsonify({'error': str(e)}), 500
+
+# New endpoint to view existing audio URL
+@app.route('/api/tutor/notes/<uuid:notes_id>/audio', methods=['GET'])
+def get_note_audio(notes_id):
+    user, error = verify_token(request.headers.get('Authorization'))
+    if error:
+        return jsonify({'error': error['error']}), error['status']
+
+    try:
+        notes_res = supabase.table('notes').select('tts_audio_url, user_id').eq('id', notes_id).single().execute()
+        
+        if not notes_res.data:
+            return jsonify({'error': 'Notes not found'}), 404
+            
+        if notes_res.data['user_id'] != user.id:
+            return jsonify({'error': 'Unauthorized access'}), 403
+            
+        if not notes_res.data['tts_audio_url']:
+            return jsonify({'error': 'No audio available for these notes'}), 404
+            
+        return jsonify({
+            'success': True,
+            'audio_url': notes_res.data['tts_audio_url']
+        })
+        
     except Exception as e:
-        logging.error(f"Unexpected error generating TTS for user {user.id}, notes {notes_id}: {traceback.format_exc()}")
-        return jsonify({'error': f'An unexpected error occurred: {e}'}), 500
+        logging.error(f"Error getting audio URL: {str(e)}")
+        return jsonify({'error': str(e)}), 500
         
 # ---------- View Notes and Quizzes Endpoints ----------