Update app.py

app.py

@@ -1,30 +1,19 @@
-# app.py
-# SmartTranscribe - Single-file Hugging Face Space (Gradio)
-# Requirements (put in requirements.txt for the Space):
-# gradio>=3.0
-# requests
-# yt-dlp
-# python-dotenv
-# ffmpeg (system package, usually present on Spaces)
-#
-# Environment variables required:
-#   GROQ_API_KEY
-#   HUGGINGFACE_API_TOKEN
+# =========================
+# SmartTranscribe - Updated Version (For Hugging Face Spaces)
+# =========================
 
 import os
-import tempfile
-import subprocess
-import json
-from pathlib import Path
-
-import requests
 import gradio as gr
-import yt_dlp
-
-# --------- Configuration / Endpoints ----------
-GROQ_TRANSCRIPTION_URL = "https://api.groq.com/openai/v1/audio/transcriptions"
-HUGGINGFACE_INFERENCE_URL = "https://api-inference.huggingface.co/models/openai/gpt-oss-120b"
+import requests
+from groq import Groq
+from datetime import datetime
+from pathlib import Path
+import tempfile
+from huggingface_hub import InferenceClient
 
+# -------------------------
+# Environment Variables
+# -------------------------
 GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
 HUGGINGFACE_API_TOKEN = os.environ.get("HUGGINGFACE_API_TOKEN")
 
@@ -33,268 +22,140 @@ if not GROQ_API_KEY or not HUGGINGFACE_API_TOKEN:
         "Environment variables GROQ_API_KEY and HUGGINGFACE_API_TOKEN must be set."
     )
 
-# --------- Helper utilities ---------
+# Initialize Groq Client
+groq_client = Groq(api_key=GROQ_API_KEY)
 
-def download_youtube_audio(youtube_url: str, out_path: str) -> str:
-    """
-    Download best audio from YouTube and convert to WAV using yt-dlp + ffmpeg.
-    Returns path to the WAV file.
-    """
-    out_base = out_path
-    ydl_opts = {
-        "format": "bestaudio/best",
-        "outtmpl": out_base + ".%(ext)s",
-        "quiet": True,
-        "no_warnings": True,
-        "postprocessors": [
-            {
-                "key": "FFmpegExtractAudio",
-                "preferredcodec": "wav",
-                "preferredquality": "192",
-            }
-        ],
-    }
-    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-        ydl.extract_info(youtube_url, download=True)
-    wav_path = out_base + ".wav"
-    if not Path(wav_path).exists():
-        raise FileNotFoundError("YouTube audio download failed or ffmpeg postprocessing missing.")
-    return wav_path
+# Initialize Hugging Face Inference Client
+hf_client = InferenceClient(token=HUGGINGFACE_API_TOKEN)
 
-def convert_to_wav(input_path: str) -> str:
-    """
-    Convert input file to 16kHz mono WAV (overwrites if same name exists).
-    If input already .wav, returns it.
-    """
-    p = Path(input_path)
-    if p.suffix.lower() == ".wav":
-        return input_path
-    out = str(p.with_suffix(".wav"))
-    cmd = [
-        "ffmpeg",
-        "-y",
-        "-i",
-        str(input_path),
-        "-ar",
-        "16000",
-        "-ac",
-        "1",
-        out,
-    ]
-    subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-    return out
+# -------------------------
+# Utility Functions
+# -------------------------
 
-def transcribe_with_groq(audio_wav_path: str, api_key: str, language: str = None) -> dict:
+def transcribe_audio(audio_path, language=None):
     """
-    Send audio file to Groq transcription endpoint.
-    language: 'ur' or 'en' or None/'auto'
-    Returns JSON response (expects at least 'text' or similar).
+    Transcribe Urdu or English audio using Whisper Large-v3 Turbo on Groq.
+    Auto-detects language and returns cleaned text.
     """
-    headers = {"Authorization": f"Bearer {api_key}"}
-    data = {}
-    if language and language != "auto":
-        # pass human-friendly label; endpoint handlers may vary
-        data["language"] = "urdu" if language == "ur" else "english"
-    # If we want special behavior for Urdu, add prompt
-    if data.get("language") == "urdu":
-        data["prompt"] = (
-            "Transcribe speech in Urdu. If English words are present in the Urdu audio, "
-            "write them using Urdu script (مثلاً 'school' -> 'اسکول'). "
-            "Preserve correct Urdu punctuation and grammar."
-        )
-    files = {"file": open(audio_wav_path, "rb")}
     try:
-        resp = requests.post(GROQ_TRANSCRIPTION_URL, headers=headers, data=data, files=files, timeout=120)
-        resp.raise_for_status()
-        return resp.json()
-    finally:
-        files["file"].close()
+        with open(audio_path, "rb") as audio_file:
+            response = groq_client.audio.transcriptions.create(
+                model="whisper-large-v3-turbo",
+                file=audio_file,
+                response_format="text"
+            )
 
-def hf_chat_completion(prompt: str, hf_token: str, max_tokens: int = 512) -> str:
-    """
-    Simple wrapper to call Hugging Face Inference API for openai/gpt-oss-120b
-    """
-    headers = {"Authorization": f"Bearer {hf_token}", "Content-Type": "application/json"}
-    payload = {"inputs": prompt, "parameters": {"max_new_tokens": max_tokens}}
-    r = requests.post(HUGGINGFACE_INFERENCE_URL, headers=headers, json=payload, timeout=180)
-    r.raise_for_status()
-    out = r.json()
-    # Standard HF inference output handlers
-    if isinstance(out, dict) and "generated_text" in out:
-        return out["generated_text"]
-    if isinstance(out, list) and len(out) > 0 and isinstance(out[0], dict) and "generated_text" in out[0]:
-        return out[0]["generated_text"]
-    if isinstance(out, str):
-        return out
-    return json.dumps(out)
-
-def normalize_urdu_text_with_gpt(transcript: str, hf_token: str) -> str:
-    """
-    Use GPT-OSS to convert embedded English words to Urdu script and fix punctuation/grammar.
-    Returns normalized Urdu text only.
-    """
-    prompt = (
-        "You are an expert in Urdu orthography and transliteration.\n"
-        "Task: Convert the following Urdu transcription into correct, well-punctuated Urdu script.\n"
-        "Whenever English words appear inside the Urdu text, transliterate them into Urdu alphabets "
-        "(for example: 'school' -> 'اسکول') while preserving meaning and grammar.\n"
-        "Return only the corrected Urdu transcription — do not include any explanations.\n\n"
-        "Transcription:\n" + transcript + "\n\nCorrected transcription:"
-    )
-    return hf_chat_completion(prompt, hf_token, max_tokens=1024)
+        transcript = response.strip()
 
-def summarize_with_gpt(text: str, hf_token: str) -> str:
-    """
-    Summarize input text using GPT-OSS-120B. Keeps the language the same as input.
-    Returns short summary and bullet key-takeaways.
-    """
-    prompt = (
-        "Summarize the following text. Output a short summary (3-6 sentences) "
-        "followed by bullet-point key takeaways. Keep the language the same as the input.\n\n"
-        "Text:\n" + text
-    )
-    return hf_chat_completion(prompt, hf_token, max_tokens=256)
+        # Urdu-English post-processing (convert English words in Urdu audio into Urdu script)
+        transcript = normalize_transcription(transcript)
 
-# --------- Core processing pipeline ---------
+        return transcript
 
-def process_audio_file(audio_path: str, force_language: str = "auto"):
-    """
-    Full pipeline:
-    - ensure WAV
-    - transcribe via Groq
-    - if Urdu (detected or forced), normalize English words to Urdu script using GPT
-    - summarize using GPT-OSS
-    Returns dict: transcript (raw), normalized_transcript, summary, detected_language
-    """
-    wav_path = convert_to_wav(audio_path)
-    try:
-        groq_resp = transcribe_with_groq(wav_path, api_key=GROQ_API_KEY, language=force_language)
     except Exception as e:
-        return {"error": f"Transcription error: {e}"}
-
-    # Groq response shape may vary; attempt to extract text and language
-    transcript = ""
-    detected_language = None
-    if isinstance(groq_resp, dict):
-        # common keys: text, transcription
-        transcript = groq_resp.get("text") or groq_resp.get("transcription") or groq_resp.get("result") or ""
-        # sometimes 'language' may be provided
-        detected_language = groq_resp.get("language") or groq_resp.get("detected_language") or None
-        # fallback: if transcript is nested
-        if not transcript and "segments" in groq_resp and isinstance(groq_resp["segments"], list):
-            transcript = " ".join([seg.get("text", "") for seg in groq_resp["segments"]])
-    elif isinstance(groq_resp, str):
-        transcript = groq_resp
+        return f"❌ Error during transcription: {str(e)}"
 
-    normalized = transcript
-    # Decide whether to normalize to Urdu script:
-    do_urdu_normalize = False
-    if force_language == "ur":
-        do_urdu_normalize = True
-    elif detected_language and isinstance(detected_language, str) and detected_language.lower().startswith("ur"):
-        do_urdu_normalize = True
-    # If transcript contains significant Urdu characters, we may still want normalization,
-    # but we rely on explicit detection/force for reliability.
-    if do_urdu_normalize and transcript.strip():
-        try:
-            normalized = normalize_urdu_text_with_gpt(transcript, HUGGINGFACE_API_TOKEN)
-        except Exception as e:
-            normalized = transcript + f"\n\n[Normalization failed: {e}]"
 
-    # Summarize (use normalized text if available)
-    to_summarize = normalized if normalized else transcript
-    summary = ""
-    if to_summarize.strip():
-        try:
-            summary = summarize_with_gpt(to_summarize, HUGGINGFACE_API_TOKEN)
-        except Exception as e:
-            summary = f"Summary failed: {e}"
-
-    return {
-        "transcript": transcript,
-        "normalized_transcript": normalized,
-        "summary": summary,
-        "detected_language": detected_language,
+def normalize_transcription(text):
+    """
+    Basic normalization for Urdu-English blend.
+    You can enhance this later with a proper transliteration module.
+    """
+    replacements = {
+        "school": "اسکول",
+        "teacher": "ٹیچر",
+        "student": "سٹوڈنٹ",
+        "education": "ایجوکیشن",
+        "university": "یونیورسٹی",
+        "computer": "کمپیوٹر",
+        "mobile": "موبائل",
+        "class": "کلاس",
     }
+    for eng, urdu in replacements.items():
+        text = text.replace(eng, urdu)
+    return text
 
-# --------- Gradio UI callbacks ---------
 
-def transcribe_upload(file, language_choice):
+def summarize_text(text):
     """
-    file: path to uploaded/recorded file (gr.Audio returns a file path)
-    language_choice: 'auto', 'ur', 'en'
+    Summarize text using openai/gpt-oss-120b model from Hugging Face.
     """
-    if not file:
-        return "", "", "براہِ مہربانی آڈیو/ویڈیو فائل اپلوڈ کریں۔"
     try:
-        result = process_audio_file(file, force_language=language_choice)
+        summary_prompt = f"Summarize the following text in the same language (Urdu or English):\n\n{text}\n\nSummary:"
+        response = hf_client.text_generation(
+            model="openai/gpt-oss-120b",
+            inputs=summary_prompt,
+            max_new_tokens=250,
+            temperature=0.5,
+        )
+        return response.generated_text.strip()
     except Exception as e:
-        return "", "", f"پروسیسنگ میں خرابی: {e}"
-    if "error" in result:
-        return "", "", result["error"]
-    return result.get("transcript", ""), result.get("normalized_transcript", ""), result.get("summary", "")
+        return f"❌ Error during summarization: {str(e)}"
 
-def transcribe_youtube(youtube_url, language_choice):
-    if not youtube_url:
-        return "", "", "براہِ مہربانی YouTube کا URL فراہم کریں۔"
-    tmp = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
-    out_base = tmp.name[:-4]  # remove .wav
-    tmp.close()
-    try:
-        wav_path = download_youtube_audio(youtube_url, out_base)
-        result = process_audio_file(wav_path, force_language=language_choice)
-    except Exception as e:
-        return "", "", f"YouTube یا کنورژن میں خرابی: {e}"
-    finally:
-        # cleanup downloaded file(s)
-        try:
-            if os.path.exists(out_base + ".wav"):
-                os.remove(out_base + ".wav")
-        except:
-            pass
-    if "error" in result:
-        return "", "", result["error"]
-    return result.get("transcript", ""), result.get("normalized_transcript", ""), result.get("summary", "")
 
-# --------- Gradio App Layout ---------
+def process_audio(audio_path):
+    """Main pipeline for transcription + summarization"""
+    if not audio_path:
+        return "⚠️ Please upload or record an audio/video file.", ""
 
-title_md = """
-# SmartTranscribe — اردو / English ٹرانسکرِپشن + خلاصہ  
-یہ ایپ آڈیو یا ویڈیو کو اسی زبان میں متن میں بدلتی ہے۔ اگر اردو ریکارڈنگ میں انگریزی الفاظ ہوں تو وہ اردو رسمِ حروف میں لکھے جائیں گے، پھر خلاصہ `openai/gpt-oss-120b` سے بنایا جائے گا۔
-"""
+    transcript = transcribe_audio(audio_path)
+    if transcript.startswith("❌"):
+        return transcript, ""
 
-with gr.Blocks(title="SmartTranscribe") as demo:
-    gr.Markdown(title_md)
+    summary = summarize_text(transcript)
+    return transcript, summary
 
-    with gr.Tab("Upload / Record"):
-        gr.Markdown("اپنی فائل اپلوڈ کریں یا براہِ راست ریکارڈ کریں:")
-        audio_input = gr.Audio(source="upload", type="filepath", label="Upload / Record audio or video")
-        language = gr.Radio(["auto", "ur", "en"], value="auto", label="زبان منتخب کریں (عام حالت: auto)")
-        transcribe_btn = gr.Button("Transcribe & Summarize")
 
-        out_transcript = gr.Textbox(label="Transcription (raw)", lines=8)
-        out_normalized = gr.Textbox(label="Transcription (normalized — Urdu script when applicable)", lines=8)
-        out_summary = gr.Textbox(label="Summary (GPT-OSS)", lines=6)
+# -------------------------
+# Gradio Interface
+# -------------------------
 
-        transcribe_btn.click(fn=transcribe_upload, inputs=[audio_input, language], outputs=[out_transcript, out_normalized, out_summary])
+with gr.Blocks(theme=gr.themes.Soft(), title="SmartTranscribe – Urdu & English AI Transcription") as app:
+    gr.Markdown(
+        """
+        # 🎙️ **SmartTranscribe**
+        **AI-Powered Urdu & English Transcription & Summarization App**
 
-    with gr.Tab("YouTube Link"):
-        gr.Markdown("YouTube کا URL پیسٹ کریں:")
-        yt_url = gr.Textbox(label="YouTube URL")
-        yt_lang = gr.Radio(["auto", "ur", "en"], value="auto", label="زبان منتخب کریں")
-        yt_btn = gr.Button("Fetch, Transcribe & Summarize")
+        Upload, record, or link your audio/video — the app will:
+        1. 🎧 Transcribe in the same language (Urdu/English)
+        2. 📝 Convert English words in Urdu speech into Urdu script
+        3. ✨ Generate a concise summary using `openai/gpt-oss-120b`
+        """
+    )
 
-        yt_out_transcript = gr.Textbox(label="Transcription (raw)", lines=8)
-        yt_out_normalized = gr.Textbox(label="Transcription (normalized)", lines=8)
-        yt_out_summary = gr.Textbox(label="Summary (GPT-OSS)", lines=6)
+    with gr.Tab("🎤 Upload or Record"):
+        audio_input = gr.Audio(
+            sources=["microphone", "upload"],  # ✅ Updated syntax
+            type="filepath",
+            label="Upload or Record audio/video"
+        )
+
+        transcribe_btn = gr.Button("🚀 Start Transcription")
+        transcript_output = gr.Textbox(label="📝 Transcribed Text", lines=10)
+        summary_output = gr.Textbox(label="📄 Summary", lines=8)
 
-        yt_btn.click(fn=transcribe_youtube, inputs=[yt_url, yt_lang], outputs=[yt_out_transcript, yt_out_normalized, yt_out_summary])
+        transcribe_btn.click(
+            fn=process_audio,
+            inputs=audio_input,
+            outputs=[transcript_output, summary_output]
+        )
 
-    gr.Markdown("""
----
-**ہدایات:** Space سیٹنگز میں `GROQ_API_KEY` اور `HUGGINGFACE_API_TOKEN` بطور Secrets شامل کریں۔  
-لمبی فائلز کے لیے ریئل-ٹائم کی جگہ چنکس بنائے جائیں گے — پروسیسنگ کا وقت ماڈیولز اور لمبائی پر منحصر ہوگا۔
-""")
+    with gr.Tab("ℹ️ About"):
+        gr.Markdown(
+            """
+            ### 💡 How it Works
+            - Uses **Groq + Whisper Large-v3 Turbo** for lightning-fast transcription  
+            - Post-processes mixed Urdu-English text into clean, grammatically correct Urdu  
+            - Generates summaries with **openai/gpt-oss-120b**  
+            
+            ### 🔒 Privacy
+            Your files and text are **not stored** after processing.  
+            All processing happens temporarily in memory.
+            """
+        )
 
+# -------------------------
+# Launch App
+# -------------------------
 if __name__ == "__main__":
-    demo.launch()
+    app.launch(server_name="0.0.0.0", server_port=7860)