Update app.py

app.py

@@ -62,6 +62,7 @@ client = OpenAI(
     api_key= os.environ.get("openAI_api_key"),  # This is the default and can be omitted
 )
 hf_api_key = os.environ.get("hf_token")
+ELEVENLABS_API_KEY = os.environ.get("elevenlabs_token")
 
 def silence(duration, fps=44100):
     """
@@ -274,6 +275,140 @@ def transcribe_video_with_speakers(video_path):
 
     return transcript_with_speakers, detected_language
 
+
+def transcribe_video_with_speakers_11labs(video_path, num_speakers=None):
+    """
+    Transcribes video/audio using the ElevenLabs Scribe API, including speaker diarization.
+
+    Args:
+        video_path (str): The path to the video or audio file to transcribe.
+        num_speakers (int, optional): The maximum amount of speakers talking in the uploaded file.
+                                      Can help with predicting who speaks when. Defaults to None.
+
+    Returns:
+        tuple: A tuple containing:
+            - transcript_with_speakers (list): A list of dictionaries, where each dictionary
+              represents a transcribed segment with 'start', 'end', 'text', and 'speaker'.
+            - detected_language (str): The language detected by the API (e.g., "en", "es").
+            - error_message (str, optional): An error message if transcription fails.
+    """
+    # --- Configuration for ElevenLabs Scribe API ---
+    # IMPORTANT: Replace with your actual ElevenLabs API Key
+    # Correct API endpoint as per documentation
+    ELEVENLABS_SCRIBE_API_URL = "https://api.elevenlabs.io/v1/speech-to-text"
+
+    transcript_with_speakers = []
+    detected_language = None
+    error_message = None
+    audio_path = "temp_audio_for_scribe.wav"
+
+    try:
+        # 1. Extract audio from video
+        logger.info(f"Extracting audio from video: {video_path}")
+        video = VideoFileClip(video_path)
+        # Use a common codec; pcm_s16le is typically 16-bit signed little-endian PCM
+        # The API's default 'other' file_format should handle this.
+        video.audio.write_audiofile(audio_path, codec='pcm_s16le')
+        video.close() # Close the video clip to release file resources
+        logger.info(f"Audio extracted to: {audio_path}")
+
+        # 2. Prepare for API call
+        headers = {
+            "xi-api-key": ELEVENLABS_API_KEY,
+        }
+
+        # Parameters sent as multipart form data
+        data = {
+            "model_id": "scribe_v1", # Required parameter as per documentation
+        }
+        # Query parameters
+        params = {
+            "diarize": "true", # Correct parameter name for diarization
+        }
+        if num_speakers is not None:
+            params["num_speakers"] = str(num_speakers) # Convert to string for API
+
+        files = {
+            "file": (os.path.basename(audio_path), open(audio_path, "rb"), "audio/wav") # Key changed to 'file'
+        }
+
+        logger.info(f"Sending audio to ElevenLabs Scribe API for transcription and diarization...")
+        response = requests.post(ELEVENLABS_SCRIBE_API_URL, headers=headers, files=files, data=data, params=params)
+        response.raise_for_status() # Raise an exception for HTTP errors (4xx or 5xx)
+
+        scribe_result = response.json()
+        logger.info("Transcription response received from ElevenLabs Scribe.")
+        # logger.debug(f"ElevenLabs Scribe API Response: {json.dumps(scribe_result, indent=2)}")
+
+        # 3. Parse the API response to match the desired output format
+        # The API returns a 'words' list, we need to group them into segments
+        if "words" in scribe_result and scribe_result["words"]:
+            current_segment = None
+            for word_data in scribe_result["words"]:
+                # Only process actual words, skip spacing or other types if necessary
+                if word_data.get("type") != "word":
+                    continue
+
+                word_text = word_data.get("text", "").strip()
+                word_start = float(word_data.get("start", 0))
+                word_end = float(word_data.get("end", 0))
+                speaker_id = word_data.get("speaker_id", "SPEAKER_UNKNOWN")
+
+                # If starting a new segment or speaker changed or significant gap
+                if (current_segment is None or
+                    speaker_id != current_segment["speaker"] or
+                    word_start - current_segment["end"] > 0.5): # Adjust gap threshold as needed
+                    
+                    if current_segment is not None:
+                        transcript_with_speakers.append(current_segment)
+                    
+                    current_segment = {
+                        "start": word_start,
+                        "end": word_end,
+                        "text": word_text,
+                        "speaker": speaker_id
+                    }
+                else:
+                    # Continue current segment
+                    current_segment["text"] += " " + word_text
+                    current_segment["end"] = word_end
+            
+            # Add the last segment after the loop
+            if current_segment is not None:
+                transcript_with_speakers.append(current_segment)
+
+            logger.info(f"Successfully parsed {len(transcript_with_speakers)} segments from words.")
+        else:
+            logger.warning("No 'words' found in ElevenLabs Scribe API response or response is empty.")
+            error_message = "ElevenLabs Scribe API response did not contain words for transcription."
+
+        # Attempt to get the detected language
+        detected_language = scribe_result.get("language_code", "unknown") # Use 'language_code' from docs
+        logger.info(f"Detected language: {detected_language}")
+
+    except requests.exceptions.HTTPError as http_err:
+        error_message = f"HTTP error occurred: {http_err} - {response.text}"
+        logger.error(error_message)
+    except requests.exceptions.ConnectionError as conn_err:
+        error_message = f"Connection error occurred: {conn_err}"
+        logger.error(error_message)
+    except requests.exceptions.Timeout as timeout_err:
+        error_message = f"Timeout error occurred: {timeout_err}"
+        logger.error(error_message)
+    except requests.exceptions.RequestException as req_err:
+        error_message = f"An unexpected request error occurred: {req_err}"
+        logger.error(error_message)
+    except Exception as e:
+        error_message = f"An error occurred during transcription: {e}"
+        logger.error(error_message)
+    finally:
+        # 4. Clean up temporary audio file
+        if os.path.exists(audio_path):
+            os.remove(audio_path)
+            logger.info(f"Cleaned up temporary audio file: {audio_path}")
+
+    return transcript_with_speakers, detected_language
+    
 # Function to get the appropriate translation model based on target language
 def get_translation_model(source_language, target_language):
     """
@@ -1153,7 +1288,7 @@ def upload_and_manage(file, target_language, process_mode):
 
         # Step 1: Transcribe audio from uploaded media file and get timestamps
         logger.info("Transcribing audio...")
-        transcription_json, source_language = transcribe_video_with_speakers(file.name)
+        transcription_json, source_language = transcribe_video_with_speakers_11labs(file.name)
         logger.info(f"Transcription completed. Detected source language: {source_language}")
 
         transcription_json_merged = post_edit_transcribed_segments(transcription_json, file.name, source_language)