Update app.py

app.py

@@ -1,146 +1,128 @@
 import os
 import gradio as gr
-import tempfile
 import yt_dlp
 import subprocess
-from pydub import AudioSegment
 from groq import Groq
+from huggingface_hub import InferenceClient
 
-# ✅ Environment Variable Check
-GROQ_API_KEY = os.getenv("GROQ_API_KEY")
-if not GROQ_API_KEY:
-    raise EnvironmentError("Please set GROQ_API_KEY.")
+# Initialize clients
+groq_client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+hf_client = InferenceClient("facebook/bart-large-cnn")
 
-groq_client = Groq(api_key=GROQ_API_KEY)
-
-# ✅ Convert audio to 16kHz mono WAV
-def convert_to_wav(input_path):
+# 🔹 Convert audio to WAV format for transcription
+def convert_to_wav(audio_path):
+    wav_path = audio_path.replace(".mp3", ".wav")
     try:
-        tmp_wav = tempfile.NamedTemporaryFile(suffix=".wav", delete=False, prefix="conv_")
-        out_wav = tmp_wav.name
-        result = subprocess.run(
-            ["ffmpeg", "-y", "-i", str(input_path), "-ar", "16000", "-ac", "1", out_wav],
+        subprocess.run(
+            ["ffmpeg", "-y", "-i", audio_path, "-ar", "16000", "-ac", "1", wav_path],
+            check=True,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE
         )
-        if result.returncode != 0:
-            audio = AudioSegment.from_file(input_path)
-            audio = audio.set_frame_rate(16000).set_channels(1)
-            audio.export(out_wav, format="wav")
-        return out_wav
+        return wav_path
     except Exception as e:
-        raise RuntimeError(f"❌ Error converting to WAV: {e}")
-
-# ✅ Split long audio into 5-min chunks
-def split_audio(file_path, max_duration_ms=5*60*1000):
-    audio = AudioSegment.from_file(file_path)
-    chunks = []
-    for i in range(0, len(audio), max_duration_ms):
-        chunk = audio[i:i + max_duration_ms]
-        temp_chunk = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
-        chunk.export(temp_chunk.name, format="wav")
-        chunks.append(temp_chunk.name)
-    return chunks
+        raise RuntimeError(f"❌ ffmpeg conversion failed: {e}")
 
-# ✅ Download YouTube Audio (with clear error messages)
+# 🔹 Download YouTube audio
 def download_youtube_audio(youtube_url):
     try:
-        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as tmp_file:
-            ydl_opts = {
-                "format": "bestaudio/best",
-                "outtmpl": tmp_file.name,
-                "quiet": True,
-                "postprocessors": [{
-                    "key": "FFmpegExtractAudio",
-                    "preferredcodec": "mp3",
-                    "preferredquality": "192",
-                }],
-            }
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                ydl.download([youtube_url])
-            return tmp_file.name
+        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
     except Exception as e:
         raise RuntimeError(f"❌ Error downloading YouTube audio: {e}")
 
-# ✅ Transcription using Groq Whisper
-def transcribe_audio(audio_path):
+# 🔹 Transcribe audio
+def transcribe_audio(audio_file=None, youtube_url=None):
     try:
-        chunks = split_audio(audio_path)
-        transcript = ""
-        for chunk in chunks:
-            with open(chunk, "rb") as f:
-                response = groq_client.audio.transcriptions.create(
-                    model="whisper-large-v3",
-                    file=f
-                )
-            transcript += response.text + "\n"
-        return transcript.strip()
+        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")
+            )
+        text = transcription.text
+        return text, "✅ Transcription complete."
     except Exception as e:
-        return f"❌ Error during transcription: {e}"
+        return "", f"❌ Error during transcription: {e}"
 
-# ✅ Summarization with “Detailed Mode”
-def summarize_text(text, lang):
+# 🔹 Summarize text
+def summarize_text(transcription, language):
     try:
-        prompt = (
-            f"Create a detailed, structured and comprehensive English summary of the following text. "
-            f"Cover key points, ideas, examples and conclusions clearly:\n\n{text}"
-            if lang == "English"
-            else f"مندرجہ ذیل عبار�� کا تفصیلی، منظم اور جامع اردو خلاصہ تحریر کریں۔ خلاصے میں اہم نکات، مثالیں اور نتائج کو واضح طور پر بیان کریں:\n\n{text}"
-        )
-        response = groq_client.chat.completions.create(
-            model="openai/gpt-oss-120b",
-            messages=[{"role": "user", "content": prompt}],
-            temperature=0.6,
-        )
-        return response.choices[0].message.content.strip()
+        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
     except Exception as e:
         return f"❌ Summarization failed: {e}"
 
-# ✅ Step 1: Transcription
-def process_transcription(youtube_url, audio_file):
+# 🔹 Craft tutorial
+def craft_tutorial(transcription, language):
     try:
-        if youtube_url:
-            try:
-                audio_path = download_youtube_audio(youtube_url)
-            except Exception as e:
-                return f"❌ Error downloading YouTube audio: {e}", ""
-        elif audio_file:
-            audio_path = audio_file
+        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:
-            return "❌ Please upload an audio or paste YouTube link.", ""
+            prompt = f"اس ٹرانسکرپشن کی بنیاد پر اردو میں ایک جامع، آسان، تعلیمی ٹیوٹوریل لکھیں جو بالکل ابتدائی افراد کے لیے ہو۔\n\n{transcription}"
 
-        wav_path = convert_to_wav(audio_path)
-        transcript = transcribe_audio(wav_path)
-        if transcript.startswith("❌"):
-            return transcript, ""
-        return "✅ Transcription Completed!", transcript
+        response = groq_client.chat.completions.create(
+            model="openai/gpt-oss-120b",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.6
+        )
+        return response.choices[0].message.content
     except Exception as e:
-        return f"❌ Error: {e}", ""
+        return f"❌ Error creating tutorial: {e}"
 
-# ✅ Step 2: Generate Detailed Summary
-def process_summary(transcript, lang):
-    if not transcript or transcript.startswith("❌"):
-        return "❌ Please transcribe audio first."
-    return summarize_text(transcript, lang)
-
-# ✅ Gradio Interface
-with gr.Blocks(title="🎧 Urdu & English Audio Transcriber + Summarizer") as app:
-    gr.Markdown("## 🎧 AI Audio & YouTube Transcriber — English & Urdu")
+# 🔹 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).")
 
     with gr.Row():
-        youtube_link = gr.Textbox(label="📺 YouTube Link (optional)")
-        lang_choice = gr.Dropdown(["English", "Urdu"], value="English", label="🌐 Summary Language")
+        audio_input = gr.Audio(label="🎧 Upload or Record Audio", type="filepath", sources=["microphone", "upload"])
+        youtube_url = gr.Textbox(label="🔗 YouTube Link (optional)")
 
-    audio_input = gr.Audio(type="filepath", label="🎙️ Upload Audio (optional)")
+    with gr.Row():
+        language = gr.Radio(["English", "Urdu"], label="🌍 Output Language", value="English")
 
-    transcribe_btn = gr.Button("📝 Step 1: Transcribe Audio / Video")
-    summarize_btn = gr.Button("🧩 Step 2: Generate Comprehensive Summary")
+    transcribe_btn = gr.Button("🚀 Transcribe Audio")
+    summary_btn = gr.Button("🧠 Generate Detailed Summary")
+    tutorial_btn = gr.Button("📘 Craft Tutorial")
 
-    status = gr.Textbox(label="Status")
-    transcript_box = gr.Textbox(label="📝 Transcription", lines=8)
-    summary_box = gr.Textbox(label="📘 Detailed Summary", lines=8)
+    transcription_output = gr.Textbox(label="📝 Transcription", lines=8)
+    summary_output = gr.Textbox(label="🧾 Summary", lines=6)
+    tutorial_output = gr.Textbox(label="📚 Tutorial", lines=10)
 
-    transcribe_btn.click(process_transcription, [youtube_link, audio_input], [status, transcript_box])
-    summarize_btn.click(process_summary, [transcript_box, lang_choice], [summary_box])
+    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)
 
 app.launch()