Deploy minimal FastAPI app to test Hugging Face Spaces compatibility

app.py

@@ -1,202 +1,32 @@
-# app.py - Ultra lightweight version
-import os
-os.environ["HOME"] = "/root"
-os.environ["HF_HOME"] = "/tmp/hf_cache"
-
 import logging
-from fastapi import FastAPI, HTTPException, BackgroundTasks, UploadFile, File, Form
+from fastapi import FastAPI, HTTPException, Form
 from fastapi.responses import JSONResponse
-import threading
-import time
-import tempfile
-import json
-from typing import Dict, Any, Optional
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("talklas-api")
-
-app = FastAPI(title="Talklas API")
-
-# Global variables to track application state
-models_loaded = False
-loading_in_progress = False
-loading_thread = None
-model_status = {
-    "stt": "not_loaded",
-    "mt": "not_loaded",
-    "tts": "not_loaded"
-}
-error_message = None
-
-# A simple in-memory queue for translation requests
-translation_queue = []
-translation_results = {}
-
-# Define the valid languages
-LANGUAGE_MAPPING = {
-    "English": "eng",
-    "Tagalog": "tgl",
-    "Cebuano": "ceb",
-    "Ilocano": "ilo",
-    "Waray": "war",
-    "Pangasinan": "pag"
-}
+logger = logging.getLogger("minimal-api")
 
-# Function to load models in background
-def load_models_task():
-    global models_loaded, loading_in_progress, model_status, error_message
-    
-    try:
-        loading_in_progress = True
-        
-        # Import heavy libraries only when needed
-        logger.info("Starting to load STT model...")
-        import torch
-        import numpy as np
-        from transformers import (
-            WhisperProcessor, 
-            WhisperForConditionalGeneration
-        )
-        
-        # Load STT model
-        try:
-            logger.info("Loading Whisper model...")
-            model_status["stt"] = "loading"
-            # Just create the processor object but don't download weights yet
-            processor = WhisperProcessor.from_pretrained("openai/whisper-tiny", local_files_only=False)
-            logger.info("STT processor initialized")
-            model_status["stt"] = "loaded"
-        except Exception as e:
-            logger.error(f"Failed to load STT model: {str(e)}")
-            model_status["stt"] = "failed"
-            error_message = f"STT model loading failed: {str(e)}"
-            return
-            
-        # Similarly initialize MT model
-        try:
-            logger.info("Loading NLLB model...")
-            model_status["mt"] = "loading"
-            from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
-            # Just initialize tokenizer but don't download weights yet
-            tokenizer = AutoTokenizer.from_pretrained(
-                "facebook/nllb-200-distilled-600M", 
-                local_files_only=False
-            )
-            logger.info("MT tokenizer initialized")
-            model_status["mt"] = "loaded"
-        except Exception as e:
-            logger.error(f"Failed to load MT model: {str(e)}")
-            model_status["mt"] = "failed"
-            error_message = f"MT model loading failed: {str(e)}"
-            return
-            
-        # Similarly initialize TTS model
-        try:
-            logger.info("Loading TTS model...")
-            model_status["tts"] = "loading"
-            from transformers import VitsModel, AutoTokenizer
-            # Just initialize but don't download weights yet
-            tokenizer = AutoTokenizer.from_pretrained(
-                "facebook/mms-tts-eng",
-                local_files_only=False
-            )
-            logger.info("TTS tokenizer initialized")
-            model_status["tts"] = "loaded"
-        except Exception as e:
-            logger.error(f"Failed to load TTS model: {str(e)}")
-            model_status["tts"] = "failed"
-            error_message = f"TTS model loading failed: {str(e)}"
-            return
-            
-        models_loaded = True
-        logger.info("All models initialized successfully")
-        
-    except Exception as e:
-        error_message = str(e)
-        logger.error(f"Error in model loading task: {str(e)}")
-    finally:
-        loading_in_progress = False
-
-# Start loading models in background
-def start_model_loading():
-    global loading_thread, loading_in_progress
-    if not loading_in_progress and not models_loaded:
-        loading_in_progress = True
-        loading_thread = threading.Thread(target=load_models_task)
-        loading_thread.daemon = True
-        loading_thread.start()
-
-# Start the background process when the app starts
-@app.on_event("startup")
-async def startup_event():
-    logger.info("Application starting up...")
-    start_model_loading()
+app = FastAPI(title="Minimal API Test")
 
 @app.get("/health")
 async def health_check():
-    """Health check endpoint that always returns successfully"""
-    global models_loaded, loading_in_progress, model_status, error_message
-    
-    # Always return 200 to pass the Hugging Face health check
-    return {
-        "status": "healthy",
-        "models_loaded": models_loaded,
-        "loading_in_progress": loading_in_progress,
-        "model_status": model_status,
-        "error": error_message
-    }
-
-@app.post("/update-languages")
-async def update_languages(source_lang: str = Form(...), target_lang: str = Form(...)):
-    if source_lang not in LANGUAGE_MAPPING or target_lang not in LANGUAGE_MAPPING:
-        raise HTTPException(status_code=400, detail="Invalid language selected")
-    
-    return {"status": f"Languages updated to {source_lang} → {target_lang}"}
-
-@app.post("/translate-text")
-async def translate_text(text: str = Form(...), source_lang: str = Form(...), target_lang: str = Form(...)):
-    """Endpoint that creates a placeholder for text translation"""
+    """Health check endpoint to confirm the app is running"""
+    logger.info("Health check requested")
+    return {"status": "healthy"}
+
+@app.get("/ping")
+async def ping():
+    """Simple ping endpoint to test GET requests"""
+    logger.info("Ping requested")
+    return {"message": "pong"}
+
+@app.post("/echo")
+async def echo(text: str = Form(...)):
+    """Echo endpoint to test POST requests with form data"""
     if not text:
         raise HTTPException(status_code=400, detail="No text provided")
-    if source_lang not in LANGUAGE_MAPPING or target_lang not in LANGUAGE_MAPPING:
-        raise HTTPException(status_code=400, detail="Invalid language selected")
-    
-    # Create a request ID
-    import uuid
-    request_id = str(uuid.uuid4())
-    
-    # Instead of doing the translation now, just return a placeholder
-    return {
-        "request_id": request_id,
-        "status": "processing",
-        "message": "Your request is being processed. This is a placeholder response while models are loading.",
-        "source_text": text,
-        "translated_text": "Translation in progress...",
-        "output_audio": None
-    }
-
-@app.post("/translate-audio")
-async def translate_audio(audio: UploadFile = File(...), source_lang: str = Form(...), target_lang: str = Form(...)):
-    """Endpoint that creates a placeholder for audio translation"""
-    if not audio:
-        raise HTTPException(status_code=400, detail="No audio file provided")
-    if source_lang not in LANGUAGE_MAPPING or target_lang not in LANGUAGE_MAPPING:
-        raise HTTPException(status_code=400, detail="Invalid language selected")
-    
-    # Create a request ID
-    import uuid
-    request_id = str(uuid.uuid4())
-    
-    # Return a placeholder response
-    return {
-        "request_id": request_id,
-        "status": "processing",
-        "message": "Your audio is being processed. This is a placeholder response while models are loading.",
-        "source_text": "Transcription in progress...",
-        "translated_text": "Translation in progress...",
-        "output_audio": None
-    }
+    logger.info(f"Echo requested with text: {text}")
+    return {"received_text": text}
 
 if __name__ == "__main__":
     import uvicorn