Spaces:

ttfdev
/

factory-tts

Runtime error

App Files Files Community

Calvin commited on Aug 11, 2025

Commit

f1a1694

1 Parent(s): 5b37c3f

add space.yml

Browse files

Files changed (2) hide show

app.py +53 -99
space.yml +2 -0

app.py CHANGED Viewed

@@ -1,105 +1,59 @@
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import StreamingResponse, HTMLResponse, JSONResponse
-from pydantic import BaseModel
 from gtts import gTTS
-import tempfile
-import os
 import aiofiles
-import asyncio
-app = FastAPI(title="Simple Indonesian TTS Space (gTTS)")
-# Pydantic model for request body
-class TTSRequest(BaseModel):
-    text: str
-    lang: str = "id"
-    slow: bool = False
-@app.get("/", response_class=HTMLResponse)
-async def homepage():
-    html = """
-    <html>
-      <head><title>Simple TTS Space</title></head>
-      <body>
-        <h2>Simple Indonesian TTS (gTTS)</h2>
-        <p>POST JSON to <code>/api/tts</code> with <code>{ "text": "...", "lang":"id", "slow": false }</code></p>
-        <form id="form">
-          <textarea id="txt" rows="6" cols="80" placeholder="Masukkan teks bahasa Indonesia..."></textarea><br/>
-          <button type="button" onclick="doTTS()">Generate</button>
-        </form>
-        <audio id="player" controls></audio>
-        <script>
-          async function doTTS(){
-            const text = document.getElementById('txt').value;
-            if(!text) return alert('Teks kosong');
-            const res = await fetch('/api/tts', {
-              method: 'POST',
-              headers: { 'Content-Type': 'application/json' },
-              body: JSON.stringify({ text, lang: 'id', slow: false })
-            });
-            if(!res.ok){ alert('Error: ' + res.status); return; }
-            const blob = await res.blob();
-            const url = URL.createObjectURL(blob);
-            document.getElementById('player').src = url;
-          }
-        </script>
-      </body>
-    </html>
-    """
-    return HTMLResponse(content=html, status_code=200)
-@app.post("/api/tts")
-async def api_tts(req: TTSRequest):
-    text = req.text.strip()
-    if not text:
-        raise HTTPException(status_code=400, detail="text is required")
-    # Limit length to prevent abuse (change as needed)
-    if len(text) > 20000:
-        raise HTTPException(status_code=400, detail="text too long (max 20000 chars)")
-    # Use a temporary file to save mp3 and stream it back
-    try:
-        tmp = tempfile.NamedTemporaryFile(suffix=".mp3", delete=False)
-        tmp_name = tmp.name
-        tmp.close()
-        # gTTS synthesize (synchronous) - small text ok
-        tts = gTTS(text=text, lang=req.lang, slow=req.slow)
-        tts.save(tmp_name)
-        # Stream file back as response
-        async def iterfile(path):
-            # read in chunks
-            async with aiofiles.open(path, 'rb') as f:
-                chunk = await f.read(8192)
-                while chunk:
-                    yield chunk
-                    chunk = await f.read(8192)
-            # cleanup file after streaming
-            try:
-                os.remove(path)
-            except Exception:
-                pass
-        return StreamingResponse(iterfile(tmp_name), media_type="audio/mpeg")
-    except Exception as e:
-        # ensure cleanup on error
-        try:
-            if 'tmp_name' in locals() and os.path.exists(tmp_name):
-                os.remove(tmp_name)
-        except Exception:
-            pass
-        raise HTTPException(status_code=500, detail=str(e))
-@app.post("/api/tts/url")
-async def api_tts_url(req: TTSRequest):
     """
-    Alternate endpoint: returns a small JSON with a temporary url (if you prefer).
-    This implementation still returns inline audio bytes to keep it simple.
     """
-    res = await api_tts(req)
-    # We can't easily return a hosted URL without external storage.
-    # So return error telling user to use /api/tts which streams audio.
-    return JSONResponse({"error": "This Space does not host persistent URLs. Use /api/tts to stream audio."}, status_code=400)

+from fastapi import FastAPI
 from gtts import gTTS
 import aiofiles
+import uvicorn
+import os
+import time
+app = FastAPI()
+def generate_timestamps(script: str, wpm: int = 150):
     """
+    Generate naive timestamps per sentence based on words per minute (WPM).
     """
+    sentences = [s.strip() for s in script.replace("\n", " ").split(".") if s.strip()]
+    timestamps = []
+    current_time = 0.0
+    seconds_per_word = 60.0 / wpm
+    for sentence in sentences:
+        word_count = len(sentence.split())
+        duration = round(word_count * seconds_per_word, 2)
+        start_time = round(current_time, 2)
+        end_time = round(current_time + duration, 2)
+        timestamps.append({
+            "sentence": sentence,
+            "start": start_time,
+            "end": end_time
+        })
+        current_time += duration
+    return timestamps
+@app.get("/")
+async def root():
+    return {"message": "API is running!"}
+@app.post("/tts")
+async def text_to_speech(text: str):
+    # Save TTS audio
+    tts = gTTS(text)
+    file_path = "output.mp3"
+    tts.save(file_path)
+    # Read audio file
+    async with aiofiles.open(file_path, mode="rb") as f:
+        audio_data = await f.read()
+    # Generate timestamps
+    timestamps = generate_timestamps(text)
+    return {
+        "script": text,
+        "timestamps": timestamps,
+        "file": file_path,
+        "size": len(audio_data)
+    }
+if __name__ == "__main__":
+    uvicorn.run("app:app", host="0.0.0.0", port=7860)

space.yml ADDED Viewed

	@@ -0,0 +1,2 @@


1	+ app_file: app.py
2	+ port: 7860