Fix: use /tmp for audio generation to avoid permission errors

.gitignore

@@ -41,4 +41,7 @@ __pycache__/
 outputs/
 generated/
 *.pyc
-*.log
+*.log
+
+#adding tmp files 
+/tmp/hf_cache

app/api/v1/audio.py

@@ -1,9 +1,9 @@
-from fastapi import APIRouter, HTTPException, Body
-from fastapi.responses import Response  # ✅ add this
+# app/api/v1/audio.py
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
 from pydantic import BaseModel
-from gtts import gTTS
-import uuid
-import os
+from app.services.audio_service import generate_audio_file
+
 router = APIRouter()
 
 class AudioRequest(BaseModel):
@@ -12,23 +12,9 @@ class AudioRequest(BaseModel):
     language: str = "en"
 
 @router.post("/generate")
-def generate_audio_endpoint(payload: AudioRequest):
+def generate_audio(payload: AudioRequest):
     try:
-        # ✅ Save inside generated/audio for consistency
-        filename = f"audio_{uuid.uuid4().hex}.mp3"
-        folder = "generated/audio"
-        os.makedirs("generated_audio", exist_ok=True)
-        file_path = f"generated_audio/{filename}" # ✅ match your video & image folders        
-        
-        # ✅ Generate TTS audio
-        tts = gTTS(text=payload.text, lang=payload.language)
-        tts.save(file_path)
-        
-        # ✅ Return audio bytes for inline Streamlit playback
-        with open(file_path, "rb") as f:
-            audio_bytes = f.read()
-
-        return Response(content=audio_bytes, media_type="audio/mpeg")
-        
+        file_path = generate_audio_file(payload.text, payload.language)
+        return FileResponse(file_path, media_type="audio/mpeg", filename="output.mp3")
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))

app/services/audio_service.py

@@ -1,39 +1,18 @@
 # app/services/audio_service.py
 from gtts import gTTS
-import os
-from datetime import datetime
-from app.db import SessionLocal
-from app.models import MediaGeneration
-import logging
+import os, uuid, logging
+
 logger = logging.getLogger(__name__)
-import uuid
 
-def generate_audio_file(text: str, voice: str = "default", language: str = "en") -> str:
+def generate_audio_file(text: str, language: str = "en") -> str:
+    """Generate an MP3 file in Hugging Face writable /tmp directory."""
     try:
+        os.makedirs("/tmp", exist_ok=True)
+        file_path = os.path.join("/tmp", f"audio_{uuid.uuid4().hex}.mp3")
         tts = gTTS(text=text, lang=language, slow=False)
-        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
-        filename = f"audio_{timestamp}.mp3"
-        output_dir = "generated/audio"
-        os.makedirs(output_dir, exist_ok=True)
-        file_path = os.path.join(output_dir, filename)
         tts.save(file_path)
-        logger.info(f"Generated Audio: {filename}")
+        logger.info(f"Generated Audio: {file_path}")
         return file_path
-    except:
+    except Exception as e:
         logger.error(f"Audio Generation Failed: {str(e)}")
         raise
-
-
-from app.db import SessionLocal
-from app.models import MediaGeneration
-
-def save_metadata(media_type, prompt, file_path):
-    db = SessionLocal()
-    record = MediaGeneration(
-        media_type=media_type,
-        prompt=prompt,
-        file_path=file_path,
-    )
-    db.add(record)
-    db.commit()
-    db.close()

auto_test_endpoints.py

@@ -1,83 +1,103 @@
 import requests
 import json
 import os
+import time
+from datetime import datetime
 
 BASE_URL = "https://osnarayana-media-gen-api.hf.space"
-TOKEN = "my_secure_token_123"
-
-headers = {"Authorization": f"Bearer {TOKEN}"}
-
-
-def fetch_openapi_schema():
-    """Fetch Swagger/OpenAPI schema from FastAPI"""
-    url = f"{BASE_URL}/openapi.json"
-    resp = requests.get(url)
-    resp.raise_for_status()
-    return resp.json()
-
-
-def guess_payload(path):
-    """Generate dummy payloads based on endpoint path"""
-    path_lower = path.lower()
-    if "image" in path:
+TOKEN = "my_secure_token_123"  # must match your auth.py
+
+headers = {
+    "Authorization": f"Bearer {TOKEN}",
+    "Content-Type": "application/json"
+}
+
+# Directory for saving media files
+os.makedirs("outputs", exist_ok=True)
+
+def unique_filename(prefix, ext):
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+    return os.path.join("outputs", f"{prefix}_{ts}.{ext}")
+
+# Dummy payload generator
+def get_dummy_payload(path):
+    if "audio/generate" in path:
+        return {"text": "Hello from auto test!"}
+    elif "video/generate" in path:
+        return {
+            "prompt": "A futuristic city with flying cars",
+            "tone": "inspiring",
+            "domain": "sci-fi",
+            "environment": "day"
+        }
+    elif "image/generate" in path:
         return {"prompt": "A cute cat in watercolor style"}
-    if "audio" in path:
-        return {"text": "Hello from Hugging Face Space!"}
-    if "video" in path:
-        return {"prompt": "A futuristic city with flying cars"}
-    if "metrics" in path and "bleu" in path:
+    elif "ppt/generate" in path:
+        return {
+            "slides": [
+                {"title": "Welcome", "content": "This is auto-generated PPT"},
+                {"title": "Conclusion", "content": "Demo slide"}
+            ]
+        }
+    elif "metrics/evaluate/bleu" in path:
+        # metrics currently require query params
         return {"reference": "hello world", "candidate": "hello"}
-    if "metrics" in path and "clipscore" in path:
+    elif "metrics/evaluate/clipscore" in path:
         return {"reference": "a photo of a cat", "candidate": "an image of a cute cat"}
-    # fallback
     return {}
 
-
-def save_response_content(resp, path):
-    """Save binary content for media endpoints"""
-    content_type = resp.headers.get("content-type", "")
-    filename = None
-    if "image" in content_type:
-        filename = "output_image.png"
-    elif "audio" in content_type:
-        filename = "output_audio.mp3"
-    elif "video" in content_type:
-        filename = "output_video.mp4"
-
-    if filename:
-        with open(filename, "wb") as f:
-            f.write(resp.content)
-        print(f"✅ Saved file: {filename}")
-
-
-def test_all_endpoints():
-    schema = fetch_openapi_schema()
-    paths = schema.get("paths", {})
-
-    for path, methods in paths.items():
-        for method, details in methods.items():
-            # Only test POST endpoints for now
-            if method.lower() != "post":
-                continue
-
-            url = BASE_URL + path
-            payload = guess_payload(path)
-
-            print(f"\nTesting {method.upper()} {url} with payload: {payload}")
-            # Decide if we need JSON or query params (FastAPI default body)
-            resp = requests.post(url, headers=headers, json=payload)
-
-            print(f"Status: {resp.status_code}")
-            if resp.status_code == 200:
-                # Try to save file if it's media
-                save_response_content(resp, path)
-                try:
-                    print("Response JSON:", resp.json())
-                except Exception:
-                    print("Non-JSON response saved as file")
-            else:
-                print("Error Response:", resp.text)
-
-
-if __name__ == "__main__":
-    test_all_endpoints()
+# Detect if endpoint expects query params
+def use_query_params(path):
+    return "metrics/evaluate" in path  # currently only metrics use query
+
+# List of endpoints to test
+ENDPOINTS = [
+    "/api/v1/audio/generate",
+    "/api/v1/video/generate",
+    "/api/v1/image/generate",
+    "/api/v1/ppt/generate",
+    "/api/v1/metrics/evaluate/bleu",
+    "/api/v1/metrics/evaluate/clipscore"
+]
+
+for endpoint in ENDPOINTS:
+    url = f"{BASE_URL}{endpoint}"
+    payload = get_dummy_payload(endpoint)
+
+    print(f"\n=== Testing POST {url} ===")
+    print("Payload:", payload)
+
+    # Decide whether to use params or json
+    if use_query_params(endpoint):
+        response = requests.post(url, headers=headers, params=payload)
+    else:
+        response = requests.post(url, headers=headers, json=payload)
+
+    status = response.status_code
+    print("Status:", status)
+
+    if status == 200:
+        # Handle media files
+        content_type = response.headers.get("content-type", "")
+        if "application/json" in content_type:
+            print("JSON Response:", response.json())
+        else:
+            # Save binary file
+            ext = "bin"
+            if "image" in content_type:
+                ext = "png"
+            elif "audio" in content_type:
+                ext = "mp3"
+            elif "video" in content_type:
+                ext = "mp4"
+            elif "presentation" in content_type or "ppt" in endpoint:
+                ext = "pptx"
+
+            filename = unique_filename(endpoint.strip("/").replace("/", "_"), ext)
+            with open(filename, "wb") as f:
+                f.write(response.content)
+            print(f"✅ Saved media file: {filename}")
+    else:
+        print("Error Response:", response.text)
+
+    time.sleep(1)  # small delay to avoid spamming