Update app.py

app.py

@@ -1,8 +1,6 @@
 import gradio as gr
-import logging
 from pydub import AudioSegment
 from google import genai  # Using the new Gemini API client
-from google.genai import types  # For inline file parts
 import json
 import uuid
 import io
@@ -12,12 +10,6 @@ import os
 import time
 import aiofiles
 
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-
-# Maximum file size allowed: 20 MB
-MAX_FILE_SIZE = 20 * 1024 * 1024
-
 class PodcastGenerator:
     def __init__(self):
         pass
@@ -58,16 +50,18 @@ Follow this example structure:
 """
         user_prompt = f"Please generate a podcast script based on the following user input:\n{prompt}"
 
-        # Initialize the Gemini API client with the provided API key.
+        # Initialize the client (it will pick up the provided API key)
         client = genai.Client(api_key=api_key)
         contents = []
         if file_data is not None:
             try:
-                # Use inline file data directly without uploading.
-                contents.append(types.Part.from_bytes(data=file_data, mime_type=file_mime_type))
+                uploaded_file = await client.aio.files.upload(
+                    path=io.BytesIO(file_data),
+                    config={"mime_type": file_mime_type}
+                )
             except Exception as e:
-                logging.error("Error preparing file part: %s", e)
-                raise gr.Error(f"Error processing file data: {e}")
+                raise gr.Error(f"File upload failed: {e}")
+            contents.append(uploaded_file)
         contents.append(user_prompt)
 
         config = {
@@ -84,7 +78,6 @@ Follow this example structure:
                 config=config
             )
         except Exception as e:
-            logging.error("API call failed: %s", e)
             if "API key not valid" in str(e):
                 raise gr.Error("Invalid API key. Please provide a valid Gemini API key.")
             elif "rate limit" in str(e).lower():
@@ -92,134 +85,90 @@ Follow this example structure:
             else:
                 raise gr.Error(f"Failed to generate podcast script: {e}")
 
-        try:
-            result = json.loads(response.text)
-        except json.JSONDecodeError as e:
-            logging.error("JSON parsing failed: %s", e)
-            raise gr.Error(f"Response is not valid JSON: {e}")
-
-        logging.info("Successfully generated script: %s", result)
-        return result
+        print(f"Generated podcast script:\n{response.text}")
+        return json.loads(response.text)
 
     async def tts_generate(self, text: str, speaker: int, speaker1: str, speaker2: str) -> str:
         voice = speaker1 if speaker == 1 else speaker2
-        try:
-            speech = edge_tts.Communicate(text, voice)
-        except Exception as e:
-            logging.error("TTS initialization failed: %s", e)
-            raise gr.Error(f"Text-to-Speech initialization error: {e}")
+        speech = edge_tts.Communicate(text, voice)
         
         temp_filename = f"temp_{uuid.uuid4()}.wav"
         try:
             await speech.save(temp_filename)
             return temp_filename
         except Exception as e:
-            logging.error("TTS generation failed: %s", e)
             if os.path.exists(temp_filename):
                 os.remove(temp_filename)
-            raise gr.Error(f"Failed to generate speech for text: {e}")
+            raise e
 
     async def combine_audio_files(self, audio_files: list) -> str:
-        try:
-            combined_audio = AudioSegment.empty()
-            for audio_file in audio_files:
-                try:
-                    combined_audio += AudioSegment.from_file(audio_file)
-                except Exception as inner_e:
-                    logging.error("Error processing audio file %s: %s", audio_file, inner_e)
-                    raise gr.Error(f"Error processing audio file: {inner_e}")
-                finally:
-                    if os.path.exists(audio_file):
-                        os.remove(audio_file)  # Clean up temporary file
-            output_filename = f"output_{uuid.uuid4()}.wav"
-            combined_audio.export(output_filename, format="wav")
-            return output_filename
-        except Exception as e:
-            logging.error("Failed to combine audio files: %s", e)
-            raise gr.Error(f"Failed to combine audio files: {e}")
+        combined_audio = AudioSegment.empty()
+        for audio_file in audio_files:
+            combined_audio += AudioSegment.from_file(audio_file)
+            os.remove(audio_file)  # Clean up temporary files
 
-    async def generate_podcast(self, input_text: str, language: str, speaker1: str, speaker2: str, api_key: str, file_data=None, file_mime_type=None) -> str:
-        try:
-            gr.Info("Generating podcast script...")
-            start_time = time.time()
-            podcast_json = await self.generate_script(input_text, language, api_key, file_data, file_mime_type)
-            end_time = time.time()
-            gr.Info(f"Successfully generated podcast script in {(end_time - start_time):.2f} seconds!")
-        except Exception as e:
-            logging.error("Script generation error: %s", e)
-            raise gr.Error(f"Error generating podcast script: {e}")
-
-        try:
-            gr.Info("Generating podcast audio files...")
-            start_time = time.time()
-            audio_files = await asyncio.gather(*[
-                self.tts_generate(item['line'], item['speaker'], speaker1, speaker2)
-                for item in podcast_json.get('podcast', [])
-            ])
-            end_time = time.time()
-            gr.Info(f"Successfully generated podcast audio files in {(end_time - start_time):.2f} seconds!")
-        except Exception as e:
-            logging.error("TTS generation error: %s", e)
-            raise gr.Error(f"Error generating audio files: {e}")
+        output_filename = f"output_{uuid.uuid4()}.wav"
+        combined_audio.export(output_filename, format="wav")
+        return output_filename
 
-        try:
-            combined_audio = await self.combine_audio_files(audio_files)
-            return combined_audio
-        except Exception as e:
-            logging.error("Audio combining error: %s", e)
-            raise gr.Error(f"Error combining audio files: {e}")
-
-async def process_input(input_text: str, input_file, language: str, speaker1: str, speaker2: str, api_key: str = "") -> str:
-    try:
-        gr.Info("Starting podcast generation...")
+    async def generate_podcast(self, input_text: str, language: str, speaker1: str, speaker2: str, api_key: str, file_data=None, file_mime_type=None) -> str:
+        gr.Info("Generating podcast script...")
         start_time = time.time()
+        podcast_json = await self.generate_script(input_text, language, api_key, file_data, file_mime_type)
+        end_time = time.time()
+        gr.Info(f"Successfully generated podcast script in {(end_time - start_time):.2f} seconds!")
 
-        voice_names = {
-            "Andrew - English (United States)": "en-US-AndrewMultilingualNeural",
-            "Ava - English (United States)": "en-US-AvaMultilingualNeural",
-            "Brian - English (United States)": "en-US-BrianMultilingualNeural",
-            "Emma - English (United States)": "en-US-EmmaMultilingualNeural",
-            "Florian - German (Germany)": "de-DE-FlorianMultilingualNeural",
-            "Seraphina - German (Germany)": "de-DE-SeraphinaMultilingualNeural",
-            "Remy - French (France)": "fr-FR-RemyMultilingualNeural",
-            "Vivienne - French (France)": "fr-FR-VivienneMultilingualNeural"
-        }
-
-        speaker1 = voice_names.get(speaker1, speaker1)
-        speaker2 = voice_names.get(speaker2, speaker2)
-
-        file_data = None
-        file_mime_type = None
-        if input_file:
-            ext = os.path.splitext(input_file.name)[1].lower()
-            if ext not in ['.pdf', '.txt']:
-                raise gr.Error("Unsupported file type. Only PDF and TXT files are allowed.")
-            try:
-                async with aiofiles.open(input_file.name, 'rb') as f:
-                    file_data = await f.read()
-            except Exception as e:
-                logging.error("Error reading file: %s", e)
-                raise gr.Error(f"Error reading file: {e}")
-            if len(file_data) > MAX_FILE_SIZE:
-                raise gr.Error("File size exceeds 20MB limit.")
-            file_mime_type = 'application/pdf' if ext == '.pdf' else 'text/plain'
-
-        if not api_key:
-            api_key = os.getenv("GENAI_API_KEY")
-            if not api_key:
-                raise gr.Error("No API key provided and none found in the environment.")
-
-        podcast_generator = PodcastGenerator()
-        podcast = await podcast_generator.generate_podcast(input_text, language, speaker1, speaker2, api_key, file_data, file_mime_type)
-
+        gr.Info("Generating podcast audio files...")
+        start_time = time.time()
+        audio_files = await asyncio.gather(*[
+            self.tts_generate(item['line'], item['speaker'], speaker1, speaker2)
+            for item in podcast_json['podcast']
+        ])
         end_time = time.time()
-        gr.Info(f"Successfully generated podcast in {(end_time - start_time):.2f} seconds!")
-        return podcast
-    except Exception as e:
-        logging.error("Process input error: %s", e)
-        raise gr.Error(f"Error in processing input: {e}")
+        gr.Info(f"Successfully generated podcast audio files in {(end_time - start_time):.2f} seconds!")
+
+        combined_audio = await self.combine_audio_files(audio_files)
+        return combined_audio
 
-# Disable API generation to avoid schema-related errors.
+async def process_input(input_text: str, input_file, language: str, speaker1: str, speaker2: str, api_key: str = "") -> str:
+    gr.Info("Starting podcast generation...")
+    start_time = time.time()
+
+    voice_names = {
+        "Andrew - English (United States)": "en-US-AndrewMultilingualNeural",
+        "Ava - English (United States)": "en-US-AvaMultilingualNeural",
+        "Brian - English (United States)": "en-US-BrianMultilingualNeural",
+        "Emma - English (United States)": "en-US-EmmaMultilingualNeural",
+        "Florian - German (Germany)": "de-DE-FlorianMultilingualNeural",
+        "Seraphina - German (Germany)": "de-DE-SeraphinaMultilingualNeural",
+        "Remy - French (France)": "fr-FR-RemyMultilingualNeural",
+        "Vivienne - French (France)": "fr-FR-VivienneMultilingualNeural"
+    }
+
+    speaker1 = voice_names[speaker1]
+    speaker2 = voice_names[speaker2]
+
+    file_data = None
+    file_mime_type = None
+    if input_file:
+        ext = os.path.splitext(input_file.name)[1].lower()
+        if ext not in ['.pdf', '.txt']:
+            raise gr.Error("Unsupported file type. Only PDF and TXT files are allowed.")
+        async with aiofiles.open(input_file.name, 'rb') as f:
+            file_data = await f.read()
+        file_mime_type = 'application/pdf' if ext == '.pdf' else 'text/plain'
+
+    if not api_key:
+        api_key = os.getenv("GENAI_API_KEY")
+
+    podcast_generator = PodcastGenerator()
+    podcast = await podcast_generator.generate_podcast(input_text, language, speaker1, speaker2, api_key, file_data, file_mime_type)
+
+    end_time = time.time()
+    gr.Info(f"Successfully generated podcast in {(end_time - start_time):.2f} seconds!")
+    return podcast
+
+# Define Gradio interface
 iface = gr.Interface(
     fn=process_input,
     inputs=[
@@ -280,8 +229,7 @@ iface = gr.Interface(
     ],
     title="PodcastGen 🎙️",
     description="Generate a 2-speaker podcast from text input or documents!",
-    allow_flagging="never",
-    allow_api=False  # Disables API endpoints to avoid schema errors
+    allow_flagging="never"
 )
 
 if __name__ == "__main__":