Update main.py

main.py

@@ -27,6 +27,11 @@ from youtube_transcript_api import YouTubeTranscriptApi
 import arxiv # For ArXiv
 from elevenlabs import play, stream, save
 import math
+import pydub 
+import logging
+import traceback
+import uuid
+from io import BytesIO  # To handle in-memory bytes
 
 # --- Environment Variables ---
 # Load environment variables if using a .env file (optional, good practice)
@@ -891,18 +896,47 @@ def submit_quiz_attempt(quiz_id):
 
 
 # Modified speak_notes endpoint with ElevenLabs Studio API and chunking
+
+try:
+    from pydub import AudioSegment
+    PYDUB_AVAILABLE = True
+except ImportError:
+    PYDUB_AVAILABLE = False
+    logging.warning("pydub library not found or ffmpeg might be missing. Audio chunk concatenation will fail. Please install pydub and ensure ffmpeg is in your system's PATH.")
+    # Define a dummy AudioSegment class if pydub is not installed to avoid NameError later
+    class AudioSegment:
+        @staticmethod
+        def from_file(*args, **kwargs):
+            raise ImportError("pydub/ffmpeg not installed or accessible")
+        def __add__(self, other):
+             raise ImportError("pydub/ffmpeg not installed or accessible")
+        def export(self, *args, **kwargs):
+             raise ImportError("pydub/ffmpeg not installed or accessible")
+
+
 @app.route('/api/tutor/notes/<uuid:notes_id>/speak', methods=['POST'])
 def speak_notes(notes_id):
-    """Generate TTS audio for notes and store in Supabase Storage"""
+    """
+    Generate TTS audio for notes using ElevenLabs (non-streaming),
+    combine chunks using pydub, and store the final MP3 in Supabase Storage.
+    Updates the note record with the audio URL and deducts credits.
+    """
+    if not PYDUB_AVAILABLE:
+         logging.error("Audio processing library (pydub/ffmpeg) check failed.")
+         return jsonify({'error': 'Server configuration error: Audio processing library not available.'}), 500
+
+    # 0. Authenticate User
     user, error = verify_token(request.headers.get('Authorization'))
     if error:
         return jsonify({'error': error['error']}), error['status']
 
     if not supabase or not elevenlabs_client:
+        logging.error("Backend service (Supabase or ElevenLabs client) not initialized.")
         return jsonify({'error': 'Backend service unavailable'}), 503
 
     try:
         # 1. Verify note ownership and get content
+        logging.info(f"Processing speak request for note {notes_id} by user {user.id}")
         note_res = supabase.table('notes') \
             .select('user_id, content, tts_audio_url') \
             .eq('id', str(notes_id)) \
@@ -911,6 +945,7 @@ def speak_notes(notes_id):
             .execute()
 
         if not note_res.data:
+            logging.warning(f"Note {notes_id} not found or unauthorized for user {user.id}.")
             return jsonify({'error': 'Note not found or unauthorized'}), 404
 
         # 2. Check user status and credits
@@ -920,98 +955,206 @@ def speak_notes(notes_id):
             .single() \
             .execute()
 
-        if profile_res.data['suspended']:
+        # Check for potential errors from profile fetch itself if needed
+        if not profile_res.data:
+             logging.error(f"Could not fetch profile for user {user.id}")
+             return jsonify({'error': 'Failed to retrieve user profile'}), 500
+
+        if profile_res.data.get('suspended'):
+            logging.warning(f"User {user.id} account is suspended.")
             return jsonify({'error': 'Account suspended'}), 403
-        if profile_res.data['credits'] < 5:
-            return jsonify({'error': 'Insufficient credits (Need 5)'}), 402
 
-        # 3. Return existing audio if available
-        if note_res.data.get('tts_audio_url'):
+        current_credits = profile_res.data.get('credits', 0)
+        CREDIT_COST = 5
+        if current_credits < CREDIT_COST:
+            logging.warning(f"User {user.id} has insufficient credits ({current_credits}/{CREDIT_COST}).")
+            return jsonify({'error': f'Insufficient credits (Need {CREDIT_COST})'}), 402
+
+        # 3. Return existing audio if available (and skip generation/deduction)
+        existing_audio_url = note_res.data.get('tts_audio_url')
+        if existing_audio_url:
+            logging.info(f"Using existing audio URL for note {notes_id}: {existing_audio_url}")
             return jsonify({
                 'success': True,
-                'audio_url': note_res.data['tts_audio_url'],
-                'message': 'Using existing audio file'
+                'audio_url': existing_audio_url,
+                'message': 'Using existing audio file',
+                'remaining_credits': current_credits # Return current credits as none were deducted
             })
 
-        notes_content = note_res.data['content']
-        if not notes_content:
+        notes_content = note_res.data.get('content')
+        if not notes_content or not notes_content.strip():
+            logging.warning(f"Note {notes_id} content is empty.")
             return jsonify({'error': 'Notes content is empty'}), 400
 
-        # 4. Generate TTS Audio with chunking
-        CHUNK_SIZE = 2000
-        chunks = [notes_content[i:i+CHUNK_SIZE] for i in range(0, len(notes_content), CHUNK_SIZE)]
-        
-        audio_bytes = b""
-        for chunk in chunks:
+        # 4. Generate TTS Audio with chunking (Non-Streaming) and combine with pydub
+        # ElevenLabs v2 non-streaming limit is often around 2500 chars, but check docs.
+        CHUNK_SIZE = 2500
+        text_chunks = [notes_content[i:i+CHUNK_SIZE] for i in range(0, len(notes_content), CHUNK_SIZE)]
+
+        combined_audio_segment = None
+        logging.info(f"Generating audio for note {notes_id} in {len(text_chunks)} chunks.")
+
+        for i, chunk in enumerate(text_chunks):
             try:
-                chunk_audio = elevenlabs_client.generate(
-                    text=chunk,
-                    voice="Rachel",
-                    model="eleven_multilingual_v2",
-                    stream=True
+                logging.debug(f"Generating audio for chunk {i+1}/{len(text_chunks)}...")
+                # Use stream=False (default) for non-streaming generation
+                chunk_audio_bytes = elevenlabs_client.generate(
+                    text=chunk.strip(), # Ensure no leading/trailing whitespace in chunk
+                    voice="Rachel",       # Or your desired voice ID
+                    model="eleven_multilingual_v2" # Or your desired model ID
                 )
-                audio_bytes += b"".join(chunk_audio)
+
+                if not chunk_audio_bytes:
+                     logging.warning(f"ElevenLabs returned empty audio for chunk {i+1} of note {notes_id}")
+                     continue # Skip this chunk, maybe log or handle differently if needed
+
+                # Load chunk audio bytes into pydub AudioSegment using BytesIO
+                segment = AudioSegment.from_file(BytesIO(chunk_audio_bytes), format="mp3")
+
+                # Combine segments
+                if combined_audio_segment is None:
+                    combined_audio_segment = segment
+                else:
+                    combined_audio_segment += segment # Append segment
+                logging.debug(f"Successfully processed chunk {i+1}/{len(text_chunks)}")
+
+            except ImportError as e:
+                 logging.error(f"pydub/ffmpeg error during chunk processing: {e}")
+                 raise e # Re-raise to be caught by the outer ImportError handler
             except Exception as e:
-                logging.error(f"Error generating chunk: {str(e)}")
-                raise RuntimeError(f"Audio generation failed: {str(e)}")
+                logging.error(f"Error generating/processing audio chunk {i+1} for note {notes_id}: {str(e)}")
+                # Stop the process if a chunk fails
+                raise RuntimeError(f"Audio generation/processing failed for chunk {i+1}: {str(e)}")
 
-        if not audio_bytes:
-            raise RuntimeError("Generated empty audio file")
+        if combined_audio_segment is None:
+            # This could happen if all chunks failed or the content was only whitespace
+            logging.error(f"Failed to generate any audio content for note {notes_id}.")
+            raise RuntimeError("Failed to generate any audio content.")
+
+        # Export combined audio to final bytes
+        output_bytes_io = BytesIO()
+        combined_audio_segment.export(output_bytes_io, format="mp3")
+        final_audio_bytes = output_bytes_io.getvalue() # Get the raw 'bytes' data
+
+        if not final_audio_bytes:
+            logging.error(f"Generated empty final audio file after combining chunks for note {notes_id}.")
+            raise RuntimeError("Generated empty final audio file after combining chunks.")
+
+        logging.info(f"Audio generation complete for note {notes_id}. Total size: {len(final_audio_bytes)} bytes.")
 
         # 5. Save to Supabase Storage
-        bucket_name = 'notes-audio'
+        bucket_name = 'notes-audio' # Ensure this bucket exists and has correct policies
+        # Use user ID and note ID for a unique, organized path
         file_path = f'{user.id}/{str(notes_id)}.mp3'
-        
+        audio_url = None # Initialize audio_url
+
         try:
-            # Upload audio file - pass bytes directly
-            upload_res = supabase.storage.from_(bucket_name).upload(
+            logging.info(f"Uploading audio to Supabase Storage: {bucket_name}/{file_path}")
+            # Upload the final combined audio bytes. Use upsert=true to overwrite if regenerating.
+            supabase.storage.from_(bucket_name).upload(
                 path=file_path,
-                file=audio_bytes,
-                file_options={"content-type": "audio/mpeg"}
+                file=final_audio_bytes, # Pass the raw 'bytes' object
+                file_options={"content-type": "audio/mpeg", "upsert": "true"}
             )
-            
-            # Get public URL
-            audio_url = supabase.storage.from_(bucket_name).get_public_url(file_path)
-
-            # 6. Update database records
-            update_res = supabase.table('notes') \
-                .update({'tts_audio_url': audio_url}) \
-                .eq('id', str(notes_id)) \
-                .eq('user_id', user.id) \
-                .execute()
-                
-            if update_res.error:
-                raise ConnectionError(update_res.error.message)
-
-            # 7. Deduct credits
-            new_credits = profile_res.data['credits'] - 5
-            credit_res = supabase.table('profiles') \
-                .update({'credits': new_credits}) \
-                .eq('id', user.id) \
-                .execute()
-                
-            if credit_res.error:
-                raise ConnectionError(credit_res.error.message)
+            # Note: supabase-py v1 might raise StorageException on failure.
+            # v2 might return a response object to check. Adapt error checking if needed.
 
-            return jsonify({
-                'success': True,
-                'audio_url': audio_url,
-                'remaining_credits': new_credits
-            })
+            # Get public URL (make sure RLS policies allow public reads or generate signed URL)
+            public_url_data = supabase.storage.from_(bucket_name).get_public_url(file_path)
+            # Assuming the URL is directly in the response data
+            audio_url = public_url_data
 
-        except Exception as upload_error:
-            # Clean up failed upload
-            try:
-                supabase.storage.from_(bucket_name).remove([file_path])
-            except Exception as cleanup_error:
-                logging.error(f"Cleanup failed: {cleanup_error}")
-            
-            logging.error(f"Upload failed: {str(upload_error)}")
-            raise upload_error
+            if not audio_url:
+                 # This case indicates an issue with getting the URL after a successful upload
+                 logging.error(f"Upload to {file_path} seemed successful, but failed to get public URL.")
+                 raise ConnectionError("Failed to retrieve audio URL after upload.")
 
+            logging.info(f"Audio uploaded successfully for note {notes_id}. URL: {audio_url}")
+
+            # --- Database Updates and Credit Deduction ---
+            # Wrap these in a try/except block for potential rollback on failure
+            try:
+                # 6. Update notes table with the audio URL
+                logging.debug(f"Updating notes table for note {notes_id} with URL.")
+                update_res = supabase.table('notes') \
+                    .update({'tts_audio_url': audio_url}) \
+                    .eq('id', str(notes_id)) \
+                    .eq('user_id', user.id) \
+                    .execute()
+
+                # Basic check if response indicates data was modified (adapt based on client version)
+                if not update_res.data:
+                     logging.warning(f"Note update query executed for {notes_id} but no data returned (might be ok, or indicate issue).")
+                     # Consider stronger checks based on specific client behavior on error/no-update
+
+                # 7. Deduct credits
+                new_credits = current_credits - CREDIT_COST
+                logging.debug(f"Deducting {CREDIT_COST} credits for user {user.id}. New balance: {new_credits}")
+                credit_res = supabase.table('profiles') \
+                    .update({'credits': new_credits}) \
+                    .eq('id', user.id) \
+                    .execute()
+
+                # Basic check for credit update
+                if not credit_res.data:
+                     # CRITICAL: Failed to deduct credits after upload/URL update.
+                     logging.error(f"CRITICAL: Failed to deduct credits for user {user.id} after audio generation for note {notes_id}.")
+                     # Decide handling: Log and proceed? Attempt rollback?
+                     # For now, log error and return success as audio is generated, but flag the inconsistency.
+                     # Ideally, implement transactional logic or robust cleanup.
+
+                logging.info(f"Successfully updated database and deducted credits for note {notes_id}")
+
+                return jsonify({
+                    'success': True,
+                    'audio_url': audio_url,
+                    'remaining_credits': new_credits
+                })
+
+            except Exception as db_error:
+                # Error occurred during DB update/credit deduction AFTER successful upload
+                logging.error(f"Database update/credit deduction failed for note {notes_id} AFTER upload: {str(db_error)}. URL was {audio_url}")
+                logging.info(f"Attempting to clean up uploaded file: {file_path}")
+                # Attempt to clean up the uploaded file since DB update failed
+                try:
+                     supabase.storage.from_(bucket_name).remove([file_path])
+                     logging.info(f"Successfully cleaned up orphaned file: {file_path}")
+                except Exception as cleanup_error:
+                     logging.error(f"Failed to clean up orphaned file {file_path} after DB error: {cleanup_error}")
+                # Re-raise the database error to signal the overall operation failed
+                raise db_error
+
+
+        except Exception as upload_db_error:
+            # This catches errors during upload OR the subsequent DB operations block if re-raised
+            logging.error(f"Error during upload or DB update phase for note {notes_id}: {str(upload_db_error)}")
+            # Attempt cleanup if file might have been uploaded and URL obtained before the error
+            if audio_url: # Check if upload likely succeeded before the error
+                 try:
+                    logging.info(f"Attempting cleanup for failed operation: {file_path}")
+                    supabase.storage.from_(bucket_name).remove([file_path])
+                    logging.info(f"Cleanup successful for {file_path}")
+                 except Exception as cleanup_error:
+                    # Log if cleanup also fails, but report the original error
+                    logging.error(f"Upload/DB error occurred, AND cleanup failed for {file_path}: {cleanup_error}")
+
+            # Re-raise the original error that caused the failure
+            raise upload_db_error
+
+    except ImportError as e:
+         # Catch the specific ImportError from the pydub check/usage
+         logging.error(f"Missing dependency error: {e}")
+         return jsonify({'error': 'Server configuration error: Audio library (pydub/ffmpeg) missing or failed.'}), 500
+    except (RuntimeError, ConnectionError) as e:
+         # Catch specific errors we raised for generation/upload/db issues
+         logging.error(f"Operation failed for note {notes_id}: {str(e)}")
+         return jsonify({'error': str(e)}), 500 # Return the specific error message
     except Exception as e:
-        logging.error(f"Speak endpoint error: {traceback.format_exc()}")
-        return jsonify({'error': str(e)}), 500
+        # Catch any other unexpected errors
+        logging.error(f"Unexpected speak endpoint error for note {notes_id}: {traceback.format_exc()}")
+        # Return a generic error message to the client for unknown errors
+        return jsonify({'error': 'An unexpected error occurred during audio generation.'}), 500
+
 
 # New endpoint to view existing audio URL
 @app.route('/api/tutor/notes/<uuid:notes_id>/audio', methods=['GET'])