Create app.py

app.py

@@ -0,0 +1,300 @@
+# 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
+
+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"
+
+GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
+HUGGINGFACE_API_TOKEN = os.environ.get("HUGGINGFACE_API_TOKEN")
+
+if not GROQ_API_KEY or not HUGGINGFACE_API_TOKEN:
+    raise EnvironmentError(
+        "Environment variables GROQ_API_KEY and HUGGINGFACE_API_TOKEN must be set."
+    )
+
+# --------- Helper utilities ---------
+
+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
+
+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
+
+def transcribe_with_groq(audio_wav_path: str, api_key: str, language: str = None) -> dict:
+    """
+    Send audio file to Groq transcription endpoint.
+    language: 'ur' or 'en' or None/'auto'
+    Returns JSON response (expects at least 'text' or similar).
+    """
+    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()
+
+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)
+
+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)
+
+# --------- Core processing pipeline ---------
+
+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
+
+    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,
+    }
+
+# --------- Gradio UI callbacks ---------
+
+def transcribe_upload(file, language_choice):
+    """
+    file: path to uploaded/recorded file (gr.Audio returns a file path)
+    language_choice: 'auto', 'ur', 'en'
+    """
+    if not file:
+        return "", "", "براہِ مہربانی آڈیو/ویڈیو فائل اپلوڈ کریں۔"
+    try:
+        result = process_audio_file(file, force_language=language_choice)
+    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", "")
+
+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 ---------
+
+title_md = """
+# SmartTranscribe — اردو / English ٹرانسکرِپشن + خلاصہ  
+یہ ایپ آڈیو یا ویڈیو کو اسی زبان میں متن میں بدلتی ہے۔ اگر اردو ریکارڈنگ میں انگریزی الفاظ ہوں تو وہ اردو رسمِ حروف میں لکھے جائیں گے، پھر خلاصہ `openai/gpt-oss-120b` سے بنایا جائے گا۔
+"""
+
+with gr.Blocks(title="SmartTranscribe") as demo:
+    gr.Markdown(title_md)
+
+    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)
+
+        transcribe_btn.click(fn=transcribe_upload, inputs=[audio_input, language], outputs=[out_transcript, out_normalized, out_summary])
+
+    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")
+
+        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)
+
+        yt_btn.click(fn=transcribe_youtube, inputs=[yt_url, yt_lang], outputs=[yt_out_transcript, yt_out_normalized, yt_out_summary])
+
+    gr.Markdown("""
+---
+**ہدایات:** Space سیٹنگز میں `GROQ_API_KEY` اور `HUGGINGFACE_API_TOKEN` بطور Secrets شامل کریں۔  
+لمبی فائلز کے لیے ریئل-ٹائم کی جگہ چنکس بنائے جائیں گے — پروسیسنگ کا وقت ماڈیولز اور لمبائی پر منحصر ہوگا۔
+""")
+
+if __name__ == "__main__":
+    demo.launch()