Files upload

app.py

@@ -0,0 +1,637 @@
+"""
+📖 Audiobook Generator — English Source to Multi-Language Audio
+Powered by Qwen3.5-Omni-Plus via DashScope API
+
+Two modes:
+  1. Translation + TTS: Translate English text to target language, then generate speech
+  2. Direct TTS: Generate speech from English text directly
+
+Deploy as a Hugging Face Space:
+  1. Create a new Space (SDK: Gradio)
+  2. Upload app.py and requirements.txt
+  3. Add DASHSCOPE_API_KEY as a Space Secret
+"""
+
+import os
+import base64
+import math
+import shutil
+import struct
+import subprocess
+import tempfile
+import time
+import re
+
+import gradio as gr
+from openai import OpenAI
+
+# ──────────────────────────────────────────────
+# Configuration
+# ──────────────────────────────────────────────
+MODEL = "qwen3.5-omni-plus"
+BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+
+# Maximum characters per chunk sent to the API
+# The model has token limits, so we split long texts
+MAX_CHARS_PER_CHUNK = 1500
+
+# All 36 speech output languages supported by Qwen3.5-Omni
+# Core 10 languages have the best quality; extended languages are supported
+# but may vary in quality as they include dialects
+LANGUAGES = {
+    # ── Core 10 Languages (highest quality) ──
+    "English": {"code": "en", "native": "English", "tier": "core"},
+    "Chinese (Mandarin)": {"code": "zh", "native": "中文", "tier": "core"},
+    "Japanese": {"code": "ja", "native": "日本語", "tier": "core"},
+    "Korean": {"code": "ko", "native": "한국어", "tier": "core"},
+    "German": {"code": "de", "native": "Deutsch", "tier": "core"},
+    "French": {"code": "fr", "native": "Français", "tier": "core"},
+    "Russian": {"code": "ru", "native": "Русский", "tier": "core"},
+    "Portuguese": {"code": "pt", "native": "Português", "tier": "core"},
+    "Spanish": {"code": "es", "native": "Español", "tier": "core"},
+    "Italian": {"code": "it", "native": "Italiano", "tier": "core"},
+    # ── Extended Languages (Qwen3.5-Omni expanded to 36) ──
+    "Arabic": {"code": "ar", "native": "العربية", "tier": "extended"},
+    "Dutch": {"code": "nl", "native": "Nederlands", "tier": "extended"},
+    "Polish": {"code": "pl", "native": "Polski", "tier": "extended"},
+    "Turkish": {"code": "tr", "native": "Türkçe", "tier": "extended"},
+    "Vietnamese": {"code": "vi", "native": "Tiếng Việt", "tier": "extended"},
+    "Thai": {"code": "th", "native": "ภาษาไทย", "tier": "extended"},
+    "Indonesian": {"code": "id", "native": "Bahasa Indonesia", "tier": "extended"},
+    "Malay": {"code": "ms", "native": "Bahasa Melayu", "tier": "extended"},
+    "Hindi": {"code": "hi", "native": "हिन्दी", "tier": "extended"},
+    "Bengali": {"code": "bn", "native": "বাংলা", "tier": "extended"},
+    "Urdu": {"code": "ur", "native": "اردو", "tier": "extended"},
+    "Swedish": {"code": "sv", "native": "Svenska", "tier": "extended"},
+    "Czech": {"code": "cs", "native": "Čeština", "tier": "extended"},
+    "Romanian": {"code": "ro", "native": "Română", "tier": "extended"},
+    "Greek": {"code": "el", "native": "Ελληνικά", "tier": "extended"},
+    "Hungarian": {"code": "hu", "native": "Magyar", "tier": "extended"},
+    "Finnish": {"code": "fi", "native": "Suomi", "tier": "extended"},
+    "Danish": {"code": "da", "native": "Dansk", "tier": "extended"},
+    "Norwegian": {"code": "no", "native": "Norsk", "tier": "extended"},
+    "Ukrainian": {"code": "uk", "native": "Українська", "tier": "extended"},
+    "Hebrew": {"code": "he", "native": "עברית", "tier": "extended"},
+    "Persian": {"code": "fa", "native": "فارسی", "tier": "extended"},
+    "Cantonese": {"code": "yue", "native": "粵語", "tier": "extended"},
+    "Filipino": {"code": "fil", "native": "Filipino", "tier": "extended"},
+    "Swahili": {"code": "sw", "native": "Kiswahili", "tier": "extended"},
+    "Tamil": {"code": "ta", "native": "தமிழ்", "tier": "extended"},
+}
+
+VOICES = {
+    "Male Voices": [
+        "Ethan — Warm, energetic",
+        "Ryan — Dramatic, rhythmic",
+        "Kai — Soothing, calm",
+        "Neil — Precise, clear",
+        "Lenn — Rational, steady",
+        "Aiden — Young, lively",
+        "Eldric Sage — Authoritative narrator",
+        "Arthur — Classic, mature",
+        "Elias — Soft, thoughtful",
+        "Alek — Confident, modern",
+        "Andre — Deep, resonant",
+        "Emilien — Gentle, French-inspired",
+        "Vincent — Rich, theatrical",
+    ],
+    "Female Voices": [
+        "Cherry — Sunny, friendly",
+        "Serena — Gentle, soft",
+        "Jennifer — Cinematic narrator",
+        "Katerina — Mature, rich rhythm",
+        "Chelsie — Bright, expressive",
+        "Mia — Young, versatile",
+        "Bella — Elegant, warm",
+        "Vivian — Professional, clear",
+        "Moon — Dreamy, ethereal",
+        "Maia — Confident, articulate",
+        "Seren — Calm, measured",
+        "Dolce — Sweet, melodic",
+        "Bellona — Strong, commanding",
+        "Bunny — Playful, light",
+        "Momo — Cute, upbeat",
+        "Mochi — Soft, adorable",
+    ],
+}
+
+# Flatten voice list for the dropdown
+ALL_VOICES = []
+for category, voices in VOICES.items():
+    for v in voices:
+        ALL_VOICES.append(v)
+
+
+def get_voice_name(voice_label: str) -> str:
+    """Extract just the voice name from 'Name — Description' format."""
+    return voice_label.split("—")[0].strip()
+
+
+# ──────────────────────────────────────────────
+# Audio helpers
+# ──────────────────────────────────────────────
+def base64_to_wav(b64_data: str, output_path: str):
+    """Decode base64 PCM data and write a proper WAV file."""
+    audio_bytes = base64.b64decode(b64_data)
+    sample_rate = 24000
+    num_channels = 1
+    bits_per_sample = 16
+    byte_rate = sample_rate * num_channels * bits_per_sample // 8
+    block_align = num_channels * bits_per_sample // 8
+    data_size = len(audio_bytes)
+    with open(output_path, "wb") as f:
+        f.write(b"RIFF")
+        f.write(struct.pack("<I", 36 + data_size))
+        f.write(b"WAVE")
+        f.write(b"fmt ")
+        f.write(struct.pack("<I", 16))
+        f.write(struct.pack("<H", 1))
+        f.write(struct.pack("<H", num_channels))
+        f.write(struct.pack("<I", sample_rate))
+        f.write(struct.pack("<I", byte_rate))
+        f.write(struct.pack("<H", block_align))
+        f.write(struct.pack("<H", bits_per_sample))
+        f.write(b"data")
+        f.write(struct.pack("<I", data_size))
+        f.write(audio_bytes)
+
+
+def concatenate_wavs(wav_files: list, output_path: str):
+    """Concatenate multiple WAV files using ffmpeg."""
+    if not wav_files:
+        return
+    if len(wav_files) == 1:
+        shutil.copy2(wav_files[0], output_path)
+        return
+    list_file = output_path + ".txt"
+    with open(list_file, "w") as f:
+        for wav in wav_files:
+            f.write(f"file '{wav}'\n")
+    subprocess.run(
+        ["ffmpeg", "-y", "-f", "concat", "-safe", "0",
+         "-i", list_file, "-c", "copy", output_path],
+        capture_output=True, check=True,
+    )
+    os.remove(list_file)
+
+
+# ──────────────────────────────────────────────
+# Text splitting
+# ──────────────────────────────────────────────
+def split_text_into_chunks(text: str, max_chars: int = MAX_CHARS_PER_CHUNK) -> list:
+    """
+    Split text into chunks at sentence boundaries.
+    Tries to keep paragraphs together when possible.
+    """
+    # Normalize whitespace
+    text = text.strip()
+    if not text:
+        return []
+
+    # If short enough, return as-is
+    if len(text) <= max_chars:
+        return [text]
+
+    chunks = []
+    # First split by paragraphs
+    paragraphs = re.split(r"\n\s*\n", text)
+
+    current_chunk = ""
+    for para in paragraphs:
+        para = para.strip()
+        if not para:
+            continue
+
+        # If adding this paragraph keeps us under the limit
+        if len(current_chunk) + len(para) + 2 <= max_chars:
+            current_chunk = (current_chunk + "\n\n" + para).strip()
+        else:
+            # Save current chunk if it has content
+            if current_chunk:
+                chunks.append(current_chunk)
+                current_chunk = ""
+
+            # If the paragraph itself is too long, split by sentences
+            if len(para) > max_chars:
+                sentences = re.split(r"(?<=[.!?])\s+", para)
+                for sentence in sentences:
+                    if len(current_chunk) + len(sentence) + 1 <= max_chars:
+                        current_chunk = (current_chunk + " " + sentence).strip()
+                    else:
+                        if current_chunk:
+                            chunks.append(current_chunk)
+                        # If a single sentence is too long, force-split it
+                        if len(sentence) > max_chars:
+                            words = sentence.split()
+                            current_chunk = ""
+                            for word in words:
+                                if len(current_chunk) + len(word) + 1 <= max_chars:
+                                    current_chunk = (current_chunk + " " + word).strip()
+                                else:
+                                    if current_chunk:
+                                        chunks.append(current_chunk)
+                                    current_chunk = word
+                        else:
+                            current_chunk = sentence
+            else:
+                current_chunk = para
+
+    if current_chunk:
+        chunks.append(current_chunk)
+
+    return chunks
+
+
+# ──────────────────────────────────────────────
+# API: Generate speech for a text chunk
+# ──────────────────────────────────────────────
+def generate_speech_chunk(
+    client: OpenAI,
+    text: str,
+    voice: str,
+    language: str,
+    lang_config: dict,
+    translate: bool,
+    chunk_index: int,
+    output_dir: str,
+) -> tuple:
+    """
+    Send a text chunk to Qwen3.5-Omni-Plus and get back audio.
+    If translate=True, translates from English to target language and speaks.
+    If translate=False, speaks the text directly in English.
+    Returns (wav_path, transcript) or (None, error_msg).
+    """
+    output_wav = os.path.join(output_dir, f"chunk_{chunk_index:04d}.wav")
+
+    if translate and language != "English":
+        system_prompt = (
+            f"You are a professional audiobook narrator and translator.\n"
+            f"You will receive English text. Your task:\n"
+            f"1. Translate the text into natural, fluent {language} ({lang_config['native']}).\n"
+            f"2. Read the translated text aloud with clear, expressive narration.\n"
+            f"3. Use an engaging audiobook narration style — vary your tone for dialogue,\n"
+            f"   descriptions, and emotional moments.\n"
+            f"4. Respond ONLY with the spoken {language} narration — no English,\n"
+            f"   no meta-commentary, no chapter headers unless they're in the text.\n"
+            f"5. Maintain a natural reading pace suitable for an audiobook.\n"
+            f"6. Translate idioms and cultural references appropriately."
+        )
+        user_text = (
+            f"Translate the following English text into {language} and narrate it "
+            f"as an audiobook. Respond only with the spoken {language} narration:\n\n{text}"
+        )
+    else:
+        system_prompt = (
+            "You are a professional audiobook narrator.\n"
+            "You will receive text to read aloud. Your task:\n"
+            "1. Read the text with clear, expressive narration.\n"
+            "2. Use an engaging audiobook narration style — vary your tone for dialogue,\n"
+            "   descriptions, and emotional moments.\n"
+            "3. Respond ONLY with the spoken narration — no meta-commentary.\n"
+            "4. Maintain a natural reading pace suitable for an audiobook.\n"
+            "5. Pause appropriately between paragraphs and at punctuation."
+        )
+        user_text = f"Narrate the following text as an audiobook:\n\n{text}"
+
+    try:
+        completion = client.chat.completions.create(
+            model=MODEL,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_text},
+            ],
+            modalities=["text", "audio"],
+            audio={"voice": voice, "format": "wav"},
+            stream=True,
+            stream_options={"include_usage": True},
+        )
+
+        audio_chunks = []
+        transcript_parts = []
+
+        for event in completion:
+            if not event.choices:
+                continue
+            delta = event.choices[0].delta
+            if hasattr(delta, "content") and delta.content:
+                transcript_parts.append(delta.content)
+            if hasattr(delta, "audio") and delta.audio:
+                if isinstance(delta.audio, dict):
+                    if "data" in delta.audio:
+                        audio_chunks.append(delta.audio["data"])
+                elif hasattr(delta.audio, "data") and delta.audio.data:
+                    audio_chunks.append(delta.audio.data)
+
+        transcript = "".join(transcript_parts)
+
+        if audio_chunks:
+            full_audio_b64 = "".join(audio_chunks)
+            base64_to_wav(full_audio_b64, output_wav)
+            return output_wav, transcript
+        else:
+            return None, "No audio received from API"
+
+    except Exception as e:
+        return None, str(e)
+
+
+# ──────────────────────────────────────────────
+# Generate silence between chapters/sections
+# ──────────────────────────────────────────────
+def generate_silence(duration_sec: float, output_path: str):
+    """Generate a silent WAV file."""
+    subprocess.run(
+        ["ffmpeg", "-y", "-f", "lavfi",
+         "-i", f"anullsrc=r=24000:cl=mono",
+         "-t", str(duration_sec), "-acodec", "pcm_s16le", output_path],
+        capture_output=True, check=True,
+    )
+
+
+# ──────────────────────────────────────────��───
+# Main pipeline
+# ──────────────────────────────────────────────
+def generate_audiobook(
+    text_input: str,
+    file_input,
+    target_language: str,
+    voice_label: str,
+    add_pauses: bool,
+    progress=gr.Progress(),
+):
+    """Main audiobook generation pipeline."""
+
+    # ── Resolve text source ──
+    if file_input is not None:
+        try:
+            with open(file_input, "r", encoding="utf-8", errors="replace") as f:
+                text = f.read()
+        except Exception as e:
+            raise gr.Error(f"Failed to read file: {e}")
+    elif text_input and text_input.strip():
+        text = text_input.strip()
+    else:
+        raise gr.Error("Please provide text or upload a file.")
+
+    if len(text) < 10:
+        raise gr.Error("Text is too short. Please provide more content.")
+
+    # ── API key ──
+    api_key = os.environ.get("DASHSCOPE_API_KEY", "")
+    if not api_key:
+        raise gr.Error(
+            "DASHSCOPE_API_KEY not set. Add it as a Space Secret "
+            "(Settings → Secrets → New Secret)."
+        )
+
+    voice = get_voice_name(voice_label)
+    lang_config = LANGUAGES[target_language]
+    translate = target_language != "English"
+    client = OpenAI(api_key=api_key, base_url=BASE_URL)
+    tmp_dir = tempfile.mkdtemp(prefix="audiobook_")
+
+    try:
+        # ── Split text ──
+        progress(0.05, desc="Splitting text into chunks...")
+        chunks = split_text_into_chunks(text)
+        total_chunks = len(chunks)
+        total_chars = sum(len(c) for c in chunks)
+
+        progress(0.08, desc=f"Processing {total_chunks} chunks ({total_chars:,} characters)...")
+
+        # ── Generate speech for each chunk ──
+        audio_files = []
+        all_transcripts = []
+        silence_path = os.path.join(tmp_dir, "silence.wav")
+        if add_pauses:
+            generate_silence(1.5, silence_path)
+
+        for i, chunk in enumerate(chunks):
+            frac = 0.1 + 0.8 * (i / total_chunks)
+            progress(frac, desc=f"Narrating chunk {i+1}/{total_chunks}...")
+
+            wav_path, transcript = generate_speech_chunk(
+                client, chunk, voice, target_language,
+                lang_config, translate, i, tmp_dir,
+            )
+
+            if wav_path:
+                audio_files.append(wav_path)
+                # Add pause between chunks
+                if add_pauses and i < total_chunks - 1:
+                    audio_files.append(silence_path)
+            else:
+                all_transcripts.append(f"⚠️ Chunk {i+1} failed: {transcript}")
+                # Insert silence placeholder for failed chunk
+                fail_silence = os.path.join(tmp_dir, f"fail_silence_{i:04d}.wav")
+                generate_silence(2.0, fail_silence)
+                audio_files.append(fail_silence)
+
+            if transcript and not transcript.startswith("⚠️"):
+                all_transcripts.append(transcript)
+
+        if not audio_files:
+            raise gr.Error("No audio was generated. Check your API key and try again.")
+
+        # ── Concatenate all audio ──
+        progress(0.92, desc="Assembling audiobook...")
+        final_audio = os.path.join(tmp_dir, "audiobook.wav")
+        concatenate_wavs(audio_files, final_audio)
+
+        # ── Convert to MP3 for smaller file size ──
+        progress(0.96, desc="Converting to MP3...")
+        final_mp3 = os.path.join(tmp_dir, "audiobook.mp3")
+        subprocess.run(
+            ["ffmpeg", "-y", "-i", final_audio,
+             "-codec:a", "libmp3lame", "-b:a", "128k",
+             "-ar", "24000", "-ac", "1", final_mp3],
+            capture_output=True, check=True,
+        )
+
+        progress(1.0, desc="Done!")
+
+        # Build transcript display
+        transcript_text = "\n\n---\n\n".join(all_transcripts) if all_transcripts else ""
+
+        # Stats
+        audio_size = os.path.getsize(final_mp3) / (1024 * 1024)
+        stats = (
+            f"**Audiobook Generated!**\n\n"
+            f"- **Source:** {total_chars:,} characters in {total_chunks} chunks\n"
+            f"- **Language:** {target_language} ({lang_config['native']})\n"
+            f"- **Voice:** {voice_label}\n"
+            f"- **File size:** {audio_size:.1f} MB\n"
+            f"- **Quality tier:** {lang_config['tier'].title()}\n"
+        )
+        if lang_config["tier"] == "extended":
+            stats += "\n> ⚠️ This is an extended language. Voice quality may vary compared to the core 10 languages."
+
+        return final_mp3, stats, transcript_text
+
+    except gr.Error:
+        raise
+    except Exception as e:
+        raise gr.Error(f"Pipeline error: {str(e)}")
+    finally:
+        # Don't clean up tmp_dir yet — Gradio needs the files
+        pass
+
+
+# ──────────────────────────────────────────────
+# Build language choices with tier labels
+# ──────────────────────────────────────────────
+def get_language_choices():
+    core = [f"⭐ {name}" for name, cfg in LANGUAGES.items() if cfg["tier"] == "core"]
+    extended = [f"  {name}" for name, cfg in LANGUAGES.items() if cfg["tier"] == "extended"]
+    return core + extended
+
+
+def clean_language_name(choice: str) -> str:
+    """Remove the tier prefix from the dropdown choice."""
+    return choice.replace("⭐ ", "").replace("  ", "").strip()
+
+
+def generate_wrapper(text_input, file_input, language_choice, voice, add_pauses, progress=gr.Progress()):
+    language = clean_language_name(language_choice)
+    return generate_audiobook(text_input, file_input, language, voice, add_pauses, progress)
+
+
+# ──────────────────────────────────────────────
+# Sample text
+# ──────────────────────────────────────────────
+SAMPLE_TEXT = """Chapter 1: The Beginning
+
+The old lighthouse stood at the edge of the world, or so it seemed to the girl who had lived in its shadow all her life. Each morning, she would climb the winding iron staircase to the lamp room, counting exactly one hundred and forty-seven steps, and watch the sun rise from the sea like a great golden coin tossed by the gods.
+
+"One day," she whispered to the seagulls that perched on the railing, "I'll follow that sun to wherever it goes."
+
+The gulls, as always, said nothing. They merely tilted their heads and regarded her with ancient, knowing eyes before launching themselves into the wind.
+
+Her name was Elena, and she was seventeen years old. She had hair the color of dark honey and eyes that changed with the weather — grey in storms, green in sunlight, and something altogether different in the strange purple twilight that sometimes settled over the coast in autumn.
+
+The lighthouse keeper, her grandfather, was a man of few words but many stories. He kept them locked away like treasures in a chest, only bringing them out on winter nights when the storms howled outside and the old building trembled like a living thing.
+
+"Tell me about the ships," Elena would say, curling up in the worn armchair by the fire.
+
+And he would smile — that slow, careful smile that seemed to cost him something each time — and begin."""
+
+
+# ──────────────────────────────────────────────
+# Gradio UI
+# ──────────────────────────────────────────────
+DESCRIPTION = """
+# 📖 Audiobook Generator
+### English Text → Multi-Language Audiobook
+**Powered by Qwen3.5-Omni-Plus**
+
+Paste or upload English text and get a professionally narrated audiobook in any of **36 languages**.
+The AI translates and narrates with expressive, audiobook-quality speech.
+
+⭐ = Core language (best quality) · Others = Extended support
+"""
+
+# Language dropdown choices
+lang_choices = []
+lang_choices.append("── Core Languages (Best Quality) ──")
+for name, cfg in LANGUAGES.items():
+    if cfg["tier"] == "core":
+        lang_choices.append(f"⭐ {name}")
+lang_choices.append("── Extended Languages ──")
+for name, cfg in LANGUAGES.items():
+    if cfg["tier"] == "extended":
+        lang_choices.append(name)
+
+with gr.Blocks(
+    title="Audiobook Generator — Qwen3.5-Omni",
+    theme=gr.themes.Soft(
+        primary_hue="indigo",
+        secondary_hue="purple",
+        neutral_hue="slate",
+    ),
+) as demo:
+
+    gr.Markdown(DESCRIPTION)
+
+    with gr.Row():
+        # ── Left column: Input ──
+        with gr.Column(scale=1):
+            text_input = gr.Textbox(
+                label="English Text",
+                placeholder="Paste your English text here...",
+                lines=12,
+                max_lines=30,
+            )
+
+            file_input = gr.File(
+                label="Or Upload a Text File (.txt, .md)",
+                file_types=[".txt", ".md", ".text"],
+                type="filepath",
+            )
+
+            sample_btn = gr.Button("📄 Load Sample Text", variant="secondary", size="sm")
+
+            with gr.Row():
+                target_lang = gr.Dropdown(
+                    choices=[c for c in lang_choices if not c.startswith("──")],
+                    value="⭐ English",
+                    label="Target Language",
+                    info="⭐ = Core (best quality). Choose English for no translation.",
+                )
+
+                voice_select = gr.Dropdown(
+                    choices=ALL_VOICES,
+                    value="Jennifer — Cinematic narrator",
+                    label="Narrator Voice",
+                )
+
+            add_pauses = gr.Checkbox(
+                value=True,
+                label="Add pauses between sections",
+                info="Adds 1.5s silence between text chunks for natural pacing",
+            )
+
+            generate_btn = gr.Button(
+                "🎙️ Generate Audiobook",
+                variant="primary",
+                size="lg",
+            )
+
+        # ── Right column: Output ──
+        with gr.Column(scale=1):
+            audio_output = gr.Audio(
+                label="Generated Audiobook",
+                type="filepath",
+            )
+
+            stats_output = gr.Markdown(label="Generation Stats")
+
+            with gr.Accordion("Translation / Narration Transcript", open=False):
+                transcript_output = gr.Markdown()
+
+    # ── Event handlers ──
+    sample_btn.click(
+        fn=lambda: SAMPLE_TEXT,
+        outputs=text_input,
+    )
+
+    generate_btn.click(
+        fn=generate_wrapper,
+        inputs=[text_input, file_input, target_lang, voice_select, add_pauses],
+        outputs=[audio_output, stats_output, transcript_output],
+    )
+
+    # ── Footer ──
+    gr.Markdown(
+        "---\n"
+        "**How it works:** Your text is split into chunks, each sent to Qwen3.5-Omni-Plus "
+        "for translation (if needed) + speech synthesis, then assembled into a single MP3 audiobook.\n\n"
+        "**Supported languages (36):** Arabic, Bengali, Cantonese, Chinese, Czech, Danish, Dutch, "
+        "English, Filipino, Finnish, French, German, Greek, Hebrew, Hindi, Hungarian, Indonesian, "
+        "Italian, Japanese, Korean, Malay, Norwegian, Persian, Polish, Portuguese, Romanian, Russian, "
+        "Spanish, Swahili, Swedish, Tamil, Thai, Turkish, Ukrainian, Urdu, Vietnamese\n\n"
+        "Built with [Gradio](https://gradio.app) · Model by [Alibaba Qwen](https://qwen.ai) · "
+        "API via [DashScope](https://www.alibabacloud.com/help/en/model-studio/)"
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,2 @@
+openai>=1.52.0
+gradio>=5.0.0