Update app.py

app.py

@@ -1,129 +1,134 @@
-import io
-import logging
+import gradio as gr
+import os
+import uuid
 import time
-
-from fastapi import FastAPI, HTTPException, Body, Response
-from fastapi.responses import StreamingResponse
-from pydantic import BaseModel, Field # Field for adding validation/defaults
+import logging
 from gtts import gTTS, gTTSError
+from fastapi import FastAPI # Import FastAPI for mounting
 
 # --- Configuration ---
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# --- Pydantic Model for Request Body ---
-class TTSRequest(BaseModel):
-    text: str = Field(..., min_length=1, description="The text to be converted to speech.")
-    lang: str = Field("en", description="Language code for the speech (e.g., 'en', 'es', 'fr'). See gTTS documentation for supported languages.")
-    # Optional: Add tld if you need specific accents tied to Google domains
-    # tld: str = Field("com", description="Top-level domain for Google TTS endpoint (e.g., 'com', 'co.uk', 'com.au')")
-
-# --- Initialize FastAPI App ---
-app = FastAPI(
-    title="gTTS API Service",
-    description="A simple API service that uses gTTS (Google Text-to-Speech) to convert text into speech (MP3 audio).",
-    version="1.0.0",
-)
-
-# --- API Endpoint for Text-to-Speech ---
-@app.post(
-    "/api/tts",
-    tags=["TTS"],
-    summary="Generate Speech using gTTS",
-    description="""Send a JSON object with 'text' and optionally 'lang' fields.
-    Returns the generated speech as an MP3 audio stream.""",
-    responses={
-        200: {
-            "content": {"audio/mpeg": {}}, # MP3 content type
-            "description": "Successful response returning the MP3 audio stream.",
-        },
-        400: {"description": "Bad Request (e.g., empty text, invalid language)"},
-        500: {"description": "Internal Server Error (e.g., gTTS failed)"},
-    },
-)
-async def generate_speech_gtts_api(
-    tts_request: TTSRequest = Body(...)
-):
+# Define a temporary directory for audio files if needed
+# Gradio often handles temporary files well, but explicit control can be useful.
+TEMP_DIR = "temp_audio_gradio"
+os.makedirs(TEMP_DIR, exist_ok=True)
+
+# Supported languages for the dropdown (add more as needed)
+# You can find codes here: https://gtts.readthedocs.io/en/latest/module.html#languages-gtts-lang
+SUPPORTED_LANGUAGES = {
+    "English": "en",
+    "Spanish": "es",
+    "French": "fr",
+    "German": "de",
+    "Italian": "it",
+    "Portuguese": "pt",
+    "Dutch": "nl",
+    "Russian": "ru",
+    "Japanese": "ja",
+    "Korean": "ko",
+    "Chinese (Mandarin/Simplified)": "zh-cn",
+    "Chinese (Mandarin/Traditional)": "zh-tw",
+    "Hindi": "hi",
+    "Arabic": "ar",
+}
+LANGUAGE_NAMES = list(SUPPORTED_LANGUAGES.keys())
+
+# --- Core gTTS Function for Gradio ---
+def generate_gtts_audio(text_input: str, language_name: str):
     """
-    Receives text and language via POST request, uses gTTS to generate
-    speech, and returns the MP3 audio directly as a stream.
+    Takes text and language name, generates MP3 using gTTS, saves it temporarily,
+    and returns the filepath for the Gradio Audio component.
     """
-    text = tts_request.text
-    lang = tts_request.lang
-    # tld = tts_request.tld # Uncomment if using tld
+    if not text_input or not text_input.strip():
+        # Raise a Gradio-specific error to show in the UI
+        raise gr.Error("Please enter some text to synthesize.")
+
+    if not language_name or language_name not in SUPPORTED_LANGUAGES:
+         raise gr.Error(f"Invalid language selected: {language_name}")
 
-    if not text or not text.strip():
-        # The pydantic model validation (min_length=1) should catch this,
-        # but belt-and-suspenders approach is fine.
-        raise HTTPException(status_code=400, detail="Input text cannot be empty.")
+    lang_code = SUPPORTED_LANGUAGES[language_name]
 
-    logger.info(f"Received gTTS request: lang='{lang}', text='{text[:50]}...'")
+    logger.info(f"Gradio request: lang='{lang_code}', text='{text_input[:50]}...'")
     start_synth_time = time.time()
 
     try:
-        # --- Generate Audio using gTTS ---
         # Create gTTS object
-        tts = gTTS(text=text, lang=lang, slow=False) # Add tld=tld if using
+        tts = gTTS(text=text_input, lang=lang_code, slow=False)
 
-        # --- Prepare Audio for Streaming ---
-        # Use an in-memory buffer (avoids temporary files)
-        mp3_fp = io.BytesIO()
-        tts.write_to_fp(mp3_fp)
-        mp3_fp.seek(0) # Rewind the buffer to the beginning for reading
+        # Generate a unique filename for the temporary MP3 file
+        filename = f"gtts_speech_{uuid.uuid4()}.mp3"
+        filepath = os.path.join(TEMP_DIR, filename)
+
+        # Save the audio file
+        tts.save(filepath)
 
         synthesis_time = time.time() - start_synth_time
-        logger.info(f"gTTS audio generated in {synthesis_time:.2f} seconds.")
+        logger.info(f"gTTS audio saved to '{filepath}' in {synthesis_time:.2f} seconds.")
 
-        # --- Return Streaming Response ---
-        return StreamingResponse(
-            mp3_fp,
-            media_type="audio/mpeg", # Standard MIME type for MP3
-            headers={'Content-Disposition': 'attachment; filename="speech.mp3"'} # Suggest filename
-        )
+        # Return the path to the generated audio file
+        # Gradio's Audio component with type="filepath" will handle serving this file.
+        return filepath
 
     except gTTSError as e:
-        logger.error(f"gTTS Error: {e}", exc_info=True)
-        # Check for common errors like invalid language
-        if "Language not supported" in str(e):
-             raise HTTPException(status_code=400, detail=f"Language '{lang}' not supported by gTTS. Error: {e}")
-        else:
-             raise HTTPException(status_code=500, detail=f"gTTS failed to generate speech. Error: {e}")
+        logger.error(f"gTTS Error during generation: {e}", exc_info=True)
+        raise gr.Error(f"gTTS failed to generate speech. Error: {e}")
     except Exception as e:
-        logger.error(f"An unexpected error occurred during speech generation: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"An unexpected error occurred. Error: {str(e)}")
+        logger.error(f"An unexpected error occurred: {e}", exc_info=True)
+        raise gr.Error(f"An unexpected server error occurred. Error: {str(e)}")
+
+# --- Create Gradio Interface ---
+iface = gr.Interface(
+    fn=generate_gtts_audio,
+    inputs=[
+        gr.Textbox(
+            label="Text to Synthesize",
+            placeholder="Enter the text you want to convert to speech...",
+            lines=4
+        ),
+        gr.Dropdown(
+            label="Language",
+            choices=LANGUAGE_NAMES,
+            value="English", # Default language
+            info="Select the language for the speech."
+        )
+    ],
+    outputs=gr.Audio(
+        label="Generated Speech (MP3)",
+        type="filepath" # Gradio handles serving the file from the returned path
+    ),
+    title="Text-to-Speech with gTTS",
+    description="Enter text and select a language to generate an MP3 audio file using Google Text-to-Speech.",
+    examples=[
+        ["Hello, this is a demonstration of the gTTS library.", "English"],
+        ["Bonjour le monde, ceci est un test.", "French"],
+        ["Hola mundo, esto es un ejemplo en español.", "Spanish"],
+    ],
+    allow_flagging="never", # Disable the flagging feature if not needed
+    # You can add custom CSS or themes here if desired
+    # theme=gr.themes.Default()
+)
+
+# --- Setup FastAPI App (Optional, but standard for Spaces) ---
+# This allows Gradio to be served alongside other potential FastAPI endpoints.
+app = FastAPI()
 
+# --- Mount the Gradio Interface onto the FastAPI app ---
+# The Gradio UI will be available at the '/ ' route of your Space URL
+app = gr.mount_gradio_app(app, iface, path="/")
 
-# --- Health Check Endpoint (Good Practice) ---
-@app.get("/health", tags=["System"], summary="Check API Health")
+# --- Optional: Add a simple health check for FastAPI ---
+@app.get("/health", tags=["System"])
 async def health_check():
-    """
-    Simple health check endpoint. Returns status ok if the service is running.
-    """
-    # Can add a quick gTTS test here if needed, but might slow down health check
-    # try:
-    #     gTTS(text='test', lang='en').save('test.mp3') # Dummy generation
-    #     os.remove('test.mp3')
-    # except Exception as e:
-    #     return {"status": "unhealthy", "reason": f"gTTS basic test failed: {e}"}
-    return {"status": "ok"}
-
-# --- Root Endpoint (Optional Information) ---
-@app.get("/", tags=["System"], summary="API Information")
-async def read_root():
-    """
-    Provides basic information about the API.
-    """
-    return {
-        "message": "Welcome to the gTTS API Service!",
-        "tts_engine": "gTTS (Google Text-to-Speech)",
-        "tts_endpoint": "/api/tts",
-        "health_endpoint": "/health",
-        "expected_request_body": {"text": "string", "lang": "string (optional, default 'en')"},
-        "response_content_type": "audio/mpeg",
-        "documentation": "/docs" # Link to FastAPI auto-generated docs
-    }
+    return {"status": "ok", "message": "Gradio service running"}
+
 
 # --- How to Run Locally (for testing) ---
 # if __name__ == "__main__":
+#     # When running locally, Gradio's launch() is often simpler
+#     # iface.launch(server_name="127.0.0.1", server_port=7860)
+
+#     # Or, if you want to test the FastAPI mounting locally:
 #     import uvicorn
-#     uvicorn.run("app:app", host="127.0.0.1", port=8000, reload=True)
+#     uvicorn.run(app, host="127.0.0.1", port=8000)