Update app.py

app.py

@@ -1,171 +1,121 @@
-import os
 import gradio as gr
-import subprocess
-import requests
+import os
 import tempfile
 import yt_dlp
-from groq import Groq
+import subprocess
 from huggingface_hub import InferenceClient
 
-# ========= CONFIG ==========
-GROQ_API_KEY = os.getenv("GROQ_API_KEY")
-HUGGINGFACE_API_TOKEN = os.getenv("HUGGINGFACE_API_TOKEN")
+# ✅ Initialize Hugging Face client
+client = InferenceClient("openai/whisper-large-v3")
 
-if not GROQ_API_KEY or not HUGGINGFACE_API_TOKEN:
-    raise EnvironmentError("Please set GROQ_API_KEY and HUGGINGFACE_API_TOKEN.")
+# Summarization and tutorial generation models
+english_summarizer = InferenceClient("facebook/bart-large-cnn")
+urdu_summarizer = InferenceClient("openai/gpt-oss-120b")
 
-# Models
-WHISPER_MODEL = "openai/whisper-large-v3-turbo"
-TUTORIAL_MODEL = "openai/gpt-oss-120b"
-
-# API Clients
-groq_client = Groq(api_key=GROQ_API_KEY)
-hf_client = InferenceClient(model=WHISPER_MODEL, token=HUGGINGFACE_API_TOKEN)
-
-# ========= AUDIO HELPERS ==========
-
-def convert_to_wav(audio_path):
-    """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,
-        )
-        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"❌ Error converting to WAV: {e}")
+# --- Helper Functions ---
 
 def download_youtube_audio(url):
-    """Download audio from YouTube using yt_dlp."""
+    """Download audio from YouTube video"""
     try:
-        with tempfile.TemporaryDirectory() as tmpdir:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
             ydl_opts = {
                 "format": "bestaudio/best",
-                "outtmpl": os.path.join(tmpdir, "audio.%(ext)s"),
+                "outtmpl": tmp.name,
                 "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
+            return tmp.name
     except Exception as e:
-        raise RuntimeError(f"❌ Error downloading YouTube audio: {e}")
+        raise RuntimeError(f"❌ Error downloading YouTube audio: {str(e)}")
 
-# ========= CORE FUNCTIONS ==========
+def convert_to_wav(audio_path):
+    """Ensure audio is in .wav format"""
+    wav_path = tempfile.mktemp(suffix=".wav")
+    try:
+        subprocess.run(["ffmpeg", "-y", "-i", audio_path, "-ar", "16000", "-ac", "1", wav_path],
+                       check=True, capture_output=True)
+        return wav_path
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"❌ ffmpeg conversion failed: {e}")
 
-def transcribe_audio(audio_path=None, youtube_url=None):
-    """Transcribe uploaded, recorded, or YouTube audio."""
+def transcribe_audio(audio_file=None, youtube_url=None):
+    """Transcribe uploaded or YouTube audio"""
     try:
         if youtube_url:
-            wav_file = download_youtube_audio(youtube_url)
-        elif audio_path:
-            wav_file = convert_to_wav(audio_path)
+            audio_path = download_youtube_audio(youtube_url)
         else:
-            return "⚠️ Please upload or record an audio or provide a YouTube link."
+            audio_path = audio_file
+
+        wav_path = convert_to_wav(audio_path)
 
-        with open(wav_file, "rb") as f:
-            transcription = hf_client.audio_to_text(f)
-        if not transcription:
-            return "❌ No text generated from transcription."
-        return transcription.strip()
+        with open(wav_path, "rb") as f:
+            text = client.text_generation(
+                prompt="Transcribe this English audio accurately:",
+                inputs=f.read(),
+                max_new_tokens=5000,
+            )
+        return text
     except Exception as e:
         return f"❌ Error during transcription: {e}"
 
-def summarize_text(text, language):
-    """Generate detailed summary in selected language."""
+def summarize_text(transcribed_text, language):
+    """Generate summary in English or Urdu"""
     try:
-        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, complete, and descriptive:\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=1800,
-        )
-        return summary.choices[0].message.content.strip()
+        if language == "English":
+            response = english_summarizer.text_generation(
+                prompt="Summarize this text comprehensively:\n" + transcribed_text,
+                max_new_tokens=1024,
+            )
+            return response
+        else:
+            response = urdu_summarizer.text_generation(
+                prompt="مندرجہ ذیل انگریزی متن کا جامع اردو خلاصہ تحریر کریں:\n" + transcribed_text,
+                max_new_tokens=2048,
+            )
+            return response
     except Exception as e:
         return f"❌ Summarization failed: {e}"
 
-def generate_tutorial(summary_text, language):
-    """Generate a clear tutorial based on summary."""
+def generate_tutorial(transcribed_text, summary, language):
+    """Craft a beginner-friendly tutorial in Urdu or English"""
     try:
+        model = urdu_summarizer if language == "Urdu" else english_summarizer
         prompt = (
-            f"Create a simple tutorial for absolute beginners based on this summary. "
-            f"Write in {language} language, use step-by-step explanations, examples, and clear structure:\n\n{summary_text}"
-        )
-        tutorial = groq_client.chat.completions.create(
-            model="llama-3.1-8b-instant",
-            messages=[{"role": "user", "content": prompt}],
-            temperature=0.7,
-            max_tokens=2000,
+            f"Write a simple, step-by-step tutorial in {language} for beginners based on this transcript:\n\n"
+            f"Transcript:\n{transcribed_text}\n\nSummary:\n{summary}\n"
         )
-        return tutorial.choices[0].message.content.strip()
+        response = model.text_generation(prompt=prompt, max_new_tokens=2500)
+        return response
     except Exception as e:
-        return f"❌ Tutorial generation failed: {e}"
-
-# ========= GRADIO INTERFACE ==========
-
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue")) as app:
-    gr.Markdown(
-        """
-        # 🎙️ Smart Transcriber & Tutor
-        **Capabilities:**  
-        - Upload / Record / YouTube Transcription  
-        - Generate Detailed Summaries (Urdu / English)  
-        - Create Step-by-Step Tutorials for Beginners  
-        """
-    )
-
-    with gr.Row():
-        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)
-
-    # Button logic
-    transcribe_btn.click(
-        transcribe_audio,
-        inputs=[audio_upload, youtube_link],
-        outputs=transcription_output,
-    )
-
-    summarize_btn.click(
-        summarize_text,
-        inputs=[transcription_output, language_dropdown],
-        outputs=summary_output,
-    )
-
-    tutorial_btn.click(
-        generate_tutorial,
-        inputs=[summary_output, language_dropdown],
-        outputs=tutorial_output,
-    )
-
-# ========= LAUNCH APP ==========
-if __name__ == "__main__":
-    app.launch()
+        return f"❌ Error generating tutorial: {e}"
+
+# --- Gradio UI ---
+
+with gr.Blocks(title="🎙️ AI Audio Transcriber & Tutorial Maker") as demo:
+    gr.Markdown("## 🎧 AI Audio Transcriber, Summarizer & Tutorial Creator")
+
+    with gr.Tab("🎤 Record / Upload Audio"):
+        with gr.Row():
+            audio_input = gr.Audio(sources=["microphone", "upload"], type="filepath", label="🎙️ Record or Upload Audio")
+            youtube_input = gr.Textbox(label="🎥 Or paste YouTube link")
+        transcribed_output = gr.Textbox(label="📝 Transcription", lines=8)
+        transcribe_btn = gr.Button("🚀 Transcribe Audio")
+
+    with gr.Tab("🧠 Summarize"):
+        language_choice = gr.Radio(["English", "Urdu"], label="Choose Summary Language", value="English")
+        summary_output = gr.Textbox(label="📋 Detailed Summary", lines=10)
+        summarize_btn = gr.Button("✨ Generate Summary")
+
+    with gr.Tab("📘 Tutorial Creator"):
+        tutorial_output = gr.Textbox(label="🎓 Beginner Tutorial", lines=12)
+        tutorial_btn = gr.Button("📚 Create Tutorial from Summary")
+
+    # --- Button Actions ---
+    transcribe_btn.click(fn=transcribe_audio, inputs=[audio_input, youtube_input], outputs=transcribed_output)
+    summarize_btn.click(fn=summarize_text, inputs=[transcribed_output, language_choice], outputs=summary_output)
+    tutorial_btn.click(fn=generate_tutorial, inputs=[transcribed_output, summary_output, language_choice], outputs=tutorial_output)
+
+# Launch
+demo.launch()