Update app.py

app.py

@@ -9,7 +9,6 @@ from dash import Dash, dcc, html, Input, Output, State, callback, callback_conte
 import dash_bootstrap_components as dbc
 from pydub import AudioSegment
 import requests
-import yt_dlp
 import mimetypes
 import urllib.parse
 
@@ -65,8 +64,8 @@ app.layout = dbc.Container([
                 multiple=False
             ),
             html.Div(id='output-media-upload'),
-            dbc.Input(id="url-input", type="text", placeholder="Enter audio/video URL (including YouTube)", className="mb-3"),
-            dbc.Button("Process URL", id="process-url-button", color="primary", className="mb-3"),
+            dbc.Input(id="url-input", type="text", placeholder="Enter audio/video URL", className="mb-3"),
+            dbc.Button("Process Media", id="process-url-button", color="primary", className="mb-3"),
             dbc.Spinner(html.Div(id='transcription-status'), color="primary", type="grow"),
             html.H4("Diarized Transcription Preview", className="mt-4"),
             html.Div(id='transcription-preview', style={'whiteSpace': 'pre-wrap'}),
@@ -77,6 +76,12 @@ app.layout = dbc.Container([
     ])
 ], fluid=True)
 
+def chunk_audio(audio_segment, chunk_length_ms=60000):
+    chunks = []
+    for i in range(0, len(audio_segment), chunk_length_ms):
+        chunks.append(audio_segment[i:i+chunk_length_ms])
+    return chunks
+
 def process_media(file_path, is_url=False):
     global generated_file, transcription_text
     temp_file = None
@@ -84,68 +89,64 @@ def process_media(file_path, is_url=False):
     try:
         if is_url:
             logger.info(f"Processing URL: {file_path}")
-            try:
-                ydl_opts = {
-                    'format': 'bestaudio/best',
-                    'postprocessors': [{
-                        'key': 'FFmpegExtractAudio',
-                        'preferredcodec': 'wav',
-                    }],
-                    'outtmpl': '%(id)s.%(ext)s',
-                }
-                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                    info = ydl.extract_info(file_path, download=True)
-                    wav_path = f"{info['id']}.wav"
-                logger.info(f"Audio downloaded: {wav_path}")
-            except Exception as e:
-                logger.error(f"Error downloading audio from URL: {str(e)}")
-                return f"Error downloading audio from URL: {str(e)}", False
+            response = requests.get(file_path)
+            content_type = response.headers.get('content-type', '')
+            if 'audio' in content_type:
+                suffix = '.mp3'
+            elif 'video' in content_type:
+                suffix = '.mp4'
+            else:
+                suffix = ''
+            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
+            temp_file.write(response.content)
+            temp_file.close()
         else:
             logger.info("Processing uploaded file")
             temp_file = tempfile.NamedTemporaryFile(delete=False)
             temp_file.write(file_path)
             temp_file.close()
-            logger.info(f"Uploaded file saved: {temp_file.name}")
 
-            file_extension = os.path.splitext(temp_file.name)[1].lower()
-            logger.info(f"Detected file extension: {file_extension}")
-            
-            if file_extension in VIDEO_FORMATS:
-                logger.info("Processing video file")
-                video = VideoFileClip(temp_file.name)
-                audio = video.audio
-                wav_path = temp_file.name + ".wav"
-                audio.write_audiofile(wav_path)
-                video.close()
-            elif file_extension in AUDIO_FORMATS:
-                logger.info("Processing audio file")
-                audio = AudioSegment.from_file(temp_file.name, format=file_extension[1:])
-                wav_path = temp_file.name + ".wav"
-                audio.export(wav_path, format="wav")
-            else:
-                logger.error(f"Unsupported file format: {file_extension}")
-                return f"Unsupported file format: {file_extension}. Please upload a supported audio or video file.", False
+        file_extension = os.path.splitext(temp_file.name)[1].lower()
+        logger.info(f"Detected file extension: {file_extension}")
+        
+        if file_extension in VIDEO_FORMATS:
+            logger.info("Processing video file")
+            video = VideoFileClip(temp_file.name)
+            audio = video.audio
+            wav_path = temp_file.name + ".wav"
+            audio.write_audiofile(wav_path)
+            video.close()
+        elif file_extension in AUDIO_FORMATS:
+            logger.info("Processing audio file")
+            audio = AudioSegment.from_file(temp_file.name, format=file_extension[1:])
+            wav_path = temp_file.name + ".wav"
+            audio.export(wav_path, format="wav")
+        else:
+            logger.error(f"Unsupported file format: {file_extension}")
+            return f"Unsupported file format: {file_extension}. Please upload a supported audio or video file.", False
 
         logger.info(f"Audio extracted to WAV: {wav_path}")
 
-        with open(wav_path, "rb") as audio_file:
-            transcript = openai.Audio.transcribe("whisper-1", audio_file)
-            audio_file.seek(0)
-            diarized_transcript = openai.Audio.transcribe("whisper-1", audio_file, response_format="verbose_json")
-        
-        formatted_transcript = ""
-        if 'segments' in diarized_transcript:
-            for segment in diarized_transcript["segments"]:
-                speaker = segment.get('speaker', 'Unknown')
-                text = segment.get('text', '')
-                formatted_transcript += f"Speaker {speaker}: {text}\n\n"
-        else:
-            formatted_transcript = transcript.get('text', 'No transcription available.')
+        audio = AudioSegment.from_wav(wav_path)
+        chunks = chunk_audio(audio)
         
+        full_transcript = ""
+        for i, chunk in enumerate(chunks):
+            logger.info(f"Processing chunk {i+1}/{len(chunks)}")
+            chunk_file = tempfile.NamedTemporaryFile(delete=False, suffix='.wav')
+            chunk.export(chunk_file.name, format="wav")
+            
+            with open(chunk_file.name, "rb") as audio_file:
+                transcript = openai.Audio.transcribe("whisper-1", audio_file)
+                full_transcript += transcript.get('text', '') + " "
+            
+            os.unlink(chunk_file.name)
+
+        formatted_transcript = full_transcript.strip()
         transcription_text = formatted_transcript
         generated_file = io.BytesIO(transcription_text.encode())
-        logger.info("Transcription and diarization completed successfully")
-        return "Transcription and diarization completed successfully!", True
+        logger.info("Transcription completed successfully")
+        return "Transcription completed successfully!", True
     except Exception as e:
         logger.error(f"Error during processing: {str(e)}")
         return f"An error occurred: {str(e)}", False
@@ -154,7 +155,7 @@ def process_media(file_path, is_url=False):
             os.unlink(temp_file.name)
         if wav_path and os.path.exists(wav_path):
             os.unlink(wav_path)
-            
+
 @app.callback(
     [Output('output-media-upload', 'children'),
      Output('transcription-status', 'children'),
@@ -196,7 +197,7 @@ def update_output(contents, n_clicks, filename, url):
 def download_transcription(n_clicks):
     if n_clicks is None:
         return None
-    return dcc.send_bytes(generated_file.getvalue(), "diarized_transcription.txt")
+    return dcc.send_bytes(generated_file.getvalue(), "transcription.txt")
 
 if __name__ == '__main__':
     print("Starting the Dash application...")