Update app.py

app.py

@@ -1,128 +1,180 @@
 import os
 import gradio as gr
-import yt_dlp
 import subprocess
+import requests
+import tempfile
+import yt_dlp
 from groq import Groq
 from huggingface_hub import InferenceClient
 
-# Initialize clients
-groq_client = Groq(api_key=os.getenv("GROQ_API_KEY"))
-hf_client = InferenceClient("facebook/bart-large-cnn")
+# ========= CONFIG ==========
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+HUGGINGFACE_API_TOKEN = os.getenv("HUGGINGFACE_API_TOKEN")
+
+if not GROQ_API_KEY or not HUGGINGFACE_API_TOKEN:
+    raise EnvironmentError("Please set GROQ_API_KEY and HUGGINGFACE_API_TOKEN.")
+
+# Whisper and summarization models
+WHISPER_MODEL = "openai/whisper-large-v3-turbo"
+SUMMARIZER_MODEL = "facebook/bart-large-cnn"
+TUTORIAL_MODEL = "openai/gpt-oss-120b"
+
+# API Clients
+groq_client = Groq(api_key=GROQ_API_KEY)
+hf_client = InferenceClient(token=HUGGINGFACE_API_TOKEN)
+
+# ========= AUDIO HELPERS ==========
 
-# 🔹 Convert audio to WAV format for transcription
 def convert_to_wav(audio_path):
-    wav_path = audio_path.replace(".mp3", ".wav")
+    """Convert any audio/video to WAV 16kHz mono."""
     try:
+        if audio_path.endswith(".wav"):
+            return audio_path
+        base, _ = os.path.splitext(audio_path)
+        wav_path = base + "_converted.wav"
         subprocess.run(
             ["ffmpeg", "-y", "-i", audio_path, "-ar", "16000", "-ac", "1", wav_path],
             check=True,
             stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
+            stderr=subprocess.PIPE,
         )
         return wav_path
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"❌ ffmpeg conversion failed: {e.stderr.decode('utf-8')}")
     except Exception as e:
-        raise RuntimeError(f"❌ ffmpeg conversion failed: {e}")
+        raise RuntimeError(f"❌ Error converting to WAV: {e}")
 
-# 🔹 Download YouTube audio
-def download_youtube_audio(youtube_url):
+def download_youtube_audio(url):
+    """Download audio from YouTube using yt_dlp."""
     try:
-        output_path = "youtube_audio.wav"
-        ydl_opts = {
-            "format": "bestaudio/best",
-            "outtmpl": "youtube_audio.%(ext)s",
-            "quiet": True,
-            "postprocessors": [{
-                "key": "FFmpegExtractAudio",
-                "preferredcodec": "wav",
-                "preferredquality": "192",
-            }],
-        }
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            ydl.download([youtube_url])
-        return output_path
+        with tempfile.TemporaryDirectory() as tmpdir:
+            ydl_opts = {
+                "format": "bestaudio/best",
+                "outtmpl": os.path.join(tmpdir, "audio.%(ext)s"),
+                "quiet": True,
+                "postprocessors": [{"key": "FFmpegExtractAudio", "preferredcodec": "mp3"}],
+            }
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                ydl.download([url])
+            audio_file = os.path.join(tmpdir, "audio.mp3")
+            wav_file = convert_to_wav(audio_file)
+            return wav_file
     except Exception as e:
         raise RuntimeError(f"❌ Error downloading YouTube audio: {e}")
 
-# 🔹 Transcribe audio
-def transcribe_audio(audio_file=None, youtube_url=None):
+# ========= CORE FUNCTIONS ==========
+
+def transcribe_audio(audio_path=None, youtube_url=None):
+    """Transcribe uploaded, recorded, or YouTube audio."""
     try:
         if youtube_url:
-            audio_file = download_youtube_audio(youtube_url)
-        if not audio_file:
-            return "❌ Please upload or record audio or provide a YouTube link.", ""
-
-        wav_file = convert_to_wav(audio_file)
-        with open(wav_file, "rb") as f:
-            transcription = groq_client.audio.transcriptions.create(
-                model="whisper-large-v3",
-                file=(wav_file, f, "audio/wav")
+            wav_file = download_youtube_audio(youtube_url)
+        elif audio_path:
+            wav_file = convert_to_wav(audio_path)
+        else:
+            return "⚠️ Please upload or record an audio or provide YouTube link."
+
+        with open(wav_file, "rb") as audio_file:
+            response = hf_client.post(
+                f"https://api-inference.huggingface.co/models/{WHISPER_MODEL}",
+                headers={"Authorization": f"Bearer {HUGGINGFACE_API_TOKEN}"},
+                data=audio_file.read(),
             )
-        text = transcription.text
-        return text, "✅ Transcription complete."
+        if response.status_code != 200:
+            return f"❌ Transcription failed: {response.text}"
+        result = response.json()
+        text = result.get("text", "").strip()
+        if not text:
+            return "❌ No text generated from transcription."
+        return text
     except Exception as e:
-        return "", f"❌ Error during transcription: {e}"
+        return f"❌ Error during transcription: {e}"
 
-# 🔹 Summarize text
-def summarize_text(transcription, language):
+def summarize_text(text, language):
+    """Generate detailed summary in selected language."""
     try:
-        if not transcription.strip():
-            return "❌ Please transcribe audio first."
-        if language == "English":
-            summary = hf_client.summarization(transcription, max_length=250, min_length=100)
-            return summary[0]["summary_text"]
-        else:
-            # For Urdu, use Groq model
-            prompt = f"اس انگریزی متن کا خلاصہ تفصیلی اردو میں لکھیں:\n\n{transcription}"
-            response = groq_client.chat.completions.create(
-                model="openai/gpt-oss-120b",
-                messages=[{"role": "user", "content": prompt}],
-                temperature=0.5
-            )
-            return response.choices[0].message.content
+        if len(text.split()) < 20:
+            return "⚠️ Text too short to summarize."
+
+        prompt = (
+            f"Summarize the following text in detail in {language}. "
+            f"Ensure the summary is coherent and complete.\n\n{text}"
+        )
+        summary = groq_client.chat.completions.create(
+            model="llama-3.1-8b-instant",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.6,
+            max_tokens=1500,
+        )
+        return summary.choices[0].message.content.strip()
     except Exception as e:
         return f"❌ Summarization failed: {e}"
 
-# 🔹 Craft tutorial
-def craft_tutorial(transcription, language):
+def generate_tutorial(summary_text, language):
+    """Generate an easy tutorial in Urdu or English based on summary."""
     try:
-        if not transcription.strip():
-            return "❌ Please transcribe or summarize first."
-        if language == "English":
-            prompt = f"Create a comprehensive beginner-friendly tutorial based on this transcription:\n\n{transcription}"
-        else:
-            prompt = f"اس ٹرانسکرپشن کی بنیاد پر اردو میں ایک جامع، آسان، تعلیمی ٹیوٹوریل لکھیں جو بالکل ابتدائی افراد کے لیے ہو۔\n\n{transcription}"
-
-        response = groq_client.chat.completions.create(
-            model="openai/gpt-oss-120b",
+        prompt = (
+            f"Create a simple tutorial for absolute beginners based on this summary. "
+            f"Write it in {language} language, use simple and clear explanations, and keep it structured:\n\n{summary_text}"
+        )
+        tutorial = groq_client.chat.completions.create(
+            model="llama-3.1-8b-instant",
             messages=[{"role": "user", "content": prompt}],
-            temperature=0.6
+            temperature=0.7,
+            max_tokens=1800,
         )
-        return response.choices[0].message.content
+        return tutorial.choices[0].message.content.strip()
     except Exception as e:
-        return f"❌ Error creating tutorial: {e}"
+        return f"❌ Tutorial generation failed: {e}"
 
-# 🔹 Gradio Interface
-with gr.Blocks(title="🎧 AI Audio Transcriber & Educator") as app:
-    gr.Markdown("## 🎙️ AI Audio Transcriber + Summarizer + Tutorial Generator")
-    gr.Markdown("Transcribe, summarize, and learn from audio (English or Urdu).")
+# ========= GRADIO INTERFACE ==========
 
-    with gr.Row():
-        audio_input = gr.Audio(label="🎧 Upload or Record Audio", type="filepath", sources=["microphone", "upload"])
-        youtube_url = gr.Textbox(label="🔗 YouTube Link (optional)")
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal")) as app:
+    gr.Markdown(
+        """
+        # 🎙️ Smart Transcriber & Tutor
+        **Features:**  
+        - Upload / Record / YouTube Transcription  
+        - Summarize in English or Urdu  
+        - Generate Tutorial for Beginners  
+        """
+    )
 
     with gr.Row():
-        language = gr.Radio(["English", "Urdu"], label="🌍 Output Language", value="English")
+        audio_upload = gr.Audio(label="🎧 Upload Audio", type="filepath")
+        record_audio = gr.Audio(label="🎤 Record Audio", type="filepath", sources=["microphone"])
+        youtube_link = gr.Textbox(label="📺 YouTube Link (optional)")
+
+    language_dropdown = gr.Dropdown(["English", "Urdu"], label="Select Language", value="English")
+
+    transcribe_btn = gr.Button("📝 Transcribe Audio")
+    transcription_output = gr.Textbox(label="Transcription Result", lines=10)
+
+    summarize_btn = gr.Button("🧠 Generate Detailed Summary")
+    summary_output = gr.Textbox(label="Summary", lines=8)
+
+    tutorial_btn = gr.Button("📘 Create Beginner Tutorial")
+    tutorial_output = gr.Textbox(label="Tutorial", lines=10)
 
-    transcribe_btn = gr.Button("🚀 Transcribe Audio")
-    summary_btn = gr.Button("🧠 Generate Detailed Summary")
-    tutorial_btn = gr.Button("📘 Craft Tutorial")
+    # Button logic
+    transcribe_btn.click(
+        transcribe_audio,
+        inputs=[audio_upload, youtube_link],
+        outputs=transcription_output,
+    )
 
-    transcription_output = gr.Textbox(label="📝 Transcription", lines=8)
-    summary_output = gr.Textbox(label="🧾 Summary", lines=6)
-    tutorial_output = gr.Textbox(label="📚 Tutorial", lines=10)
+    summarize_btn.click(
+        summarize_text,
+        inputs=[transcription_output, language_dropdown],
+        outputs=summary_output,
+    )
 
-    transcribe_btn.click(transcribe_audio, inputs=[audio_input, youtube_url], outputs=[transcription_output, gr.Textbox()])
-    summary_btn.click(summarize_text, inputs=[transcription_output, language], outputs=summary_output)
-    tutorial_btn.click(craft_tutorial, inputs=[transcription_output, language], outputs=tutorial_output)
+    tutorial_btn.click(
+        generate_tutorial,
+        inputs=[summary_output, language_dropdown],
+        outputs=tutorial_output,
+    )
 
-app.launch()
+# ========= LAUNCH APP ==========
+if __name__ == "__main__":
+    app.launch()