Update app.py

app.py

@@ -1,4 +1,4 @@
-from fastapi import FastAPI, File, UploadFile, HTTPException, BackgroundTasks, Query, Form
+from fastapi import FastAPI, File, UploadFile, HTTPException, BackgroundTasks, Query
 from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 import whisper
@@ -13,10 +13,8 @@ import sqlite3
 from datetime import datetime, timedelta
 from typing import Optional, Dict, Any
 from contextlib import asynccontextmanager
-import re
 import asyncio
 from concurrent.futures import ThreadPoolExecutor
-import threading
 
 # Configure logging
 logging.basicConfig(
@@ -294,7 +292,7 @@ async def background_transcription(file_path: str, file_hash: str, filename: str
             
             await update_processing_status(file_hash, status='processing', progress=10)
             
-            # Transcribe audio in original language only
+            # Transcribe audio
             loop = asyncio.get_event_loop()
             result = await loop.run_in_executor(
                 executor,
@@ -319,8 +317,6 @@ async def background_transcription(file_path: str, file_hash: str, filename: str
                 "from_cache": False
             }
             
-            await update_processing_status(file_hash, progress=100)
-            
             # Save to cache
             await save_to_cache(
                 file_hash, filename, file_size, 
@@ -358,12 +354,11 @@ async def root():
             processing_count = cursor.fetchone()[0] or 0
         
         return {
-            "message": "Whisper Transcription API is running", 
+            "message": "Whisper API is running", 
             "device": device,
             "cuda_available": torch.cuda.is_available(),
             "cached_files": cache_count,
-            "currently_processing": processing_count,
-            "whisper_loaded": whisper_model is not None
+            "currently_processing": processing_count
         }
     except Exception as e:
         logger.error(f"Error in root endpoint: {e}")
@@ -514,19 +509,13 @@ async def transcribe_audio(
                 except Exception as e:
                     logger.error(f"Error in immediate transcription: {e}")
                     raise HTTPException(status_code=500, detail=f"Transcription failed: {str(e)}")
-                
                 finally:
-                    # Clean up temporary file and GPU memory
-                    try:
-                        if tmp_file_path and os.path.exists(tmp_file_path):
-                            os.unlink(tmp_file_path)
-                        if torch.cuda.is_available():
-                            torch.cuda.empty_cache()
-                    except Exception as e:
-                        logger.error(f"Error in cleanup: {e}")
+                    # Clean up GPU memory
+                    if torch.cuda.is_available():
+                        torch.cuda.empty_cache()
         
         else:
-            # Process larger files in background
+            # Large file - process in background
             await add_processing_status(file_hash, file.filename, file_size, estimated_time)
             
             background_tasks.add_task(
@@ -535,163 +524,79 @@ async def transcribe_audio(
             )
             
             return JSONResponse({
-                "status": "processing",
+                "status": "processing_started",
                 "estimated_time": estimated_time,
                 "file_hash": file_hash,
-                "message": f"File is being processed. Estimated time: {estimated_time} minutes"
+                "message": f"Processing started. Estimated time: {estimated_time} minutes.",
+                "server_load": f"Processing slots: {5 - available_slots}/5"
             })
     
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Unexpected error in transcribe endpoint: {e}")
-        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+        logger.error(f"Error in transcription endpoint: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Processing error: {str(e)}")
     
     finally:
-        # Ensure temporary file is cleaned up in case of errors
-        if tmp_file_path and os.path.exists(tmp_file_path):
+        # Clean up temporary file for small immediate processing
+        if tmp_file_path and os.path.exists(tmp_file_path) and file_size_mb < 5:
             try:
                 os.unlink(tmp_file_path)
             except Exception as e:
-                logger.error(f"Error cleaning up temp file: {e}")
+                logger.error(f"Error deleting temp file: {e}")
 
 @app.get("/status/{file_hash}")
-async def get_transcription_status(file_hash: str):
-    """Get status of a transcription job"""
-    try:
-        # Check cache first
-        cached_result = await get_from_cache(file_hash)
-        if cached_result:
-            return JSONResponse({
-                "status": "completed",
-                "result": cached_result
-            })
-        
-        # Check processing status
-        processing_status = await get_processing_status(file_hash)
-        if processing_status:
-            return JSONResponse(processing_status)
-        
+async def check_status(file_hash: str):
+    """Check processing status for a file"""
+    # Check cache first
+    cached_result = await get_from_cache(file_hash)
+    if cached_result:
+        await remove_processing_status(file_hash)
+        cached_result.update({
+            "status": "completed",
+            "from_cache": True,
+            "message": "Processing completed and result is ready"
+        })
+        return JSONResponse(cached_result)
+    
+    # Check processing status
+    processing_status = await get_processing_status(file_hash)
+    if processing_status:
+        remaining_time = max(0, processing_status['estimated_time'] - processing_status['elapsed_minutes'])
         return JSONResponse({
-            "status": "not_found",
-            "message": "No job found with this hash"
+            "status": processing_status['status'],
+            "progress": processing_status['progress'],
+            "elapsed_minutes": processing_status['elapsed_minutes'],
+            "estimated_time": processing_status['estimated_time'],
+            "remaining_time": remaining_time,
+            "message": f"Processing... about {remaining_time} minutes remaining"
         })
-    except Exception as e:
-        logger.error(f"Error in status endpoint: {e}")
-        raise HTTPException(status_code=500, detail="Internal server error")
-
-@app.delete("/cache/{file_hash}")
-async def delete_cached_transcription(file_hash: str):
-    """Delete cached transcription"""
-    try:
-        with db_manager.get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                'DELETE FROM cache WHERE file_hash = ?',
-                (file_hash,)
-            )
-            deleted = cursor.rowcount
-            conn.commit()
-        
-        return {"deleted": deleted > 0}
-    except Exception as e:
-        logger.error(f"Error deleting cache: {e}")
-        raise HTTPException(status_code=500, detail="Internal server error")
-
-@app.get("/cache/stats")
-async def get_cache_stats():
-    """Get cache statistics"""
-    try:
-        with db_manager.get_connection() as conn:
-            cursor = conn.cursor()
-            
-            cursor.execute('SELECT COUNT(*) FROM cache')
-            total = cursor.fetchone()[0] or 0
-            
-            cursor.execute('SELECT SUM(file_size) FROM cache')
-            total_size = cursor.fetchone()[0] or 0
-            
-            cursor.execute('''
-                SELECT COUNT(*) FROM cache 
-                WHERE last_accessed > datetime('now', '-7 days')
-            ''')
-            recent_access = cursor.fetchone()[0] or 0
-            
-            cursor.execute('''
-                SELECT COUNT(*) FROM cache 
-                WHERE created_at > datetime('now', '-1 day')
-            ''')
-            today_added = cursor.fetchone()[0] or 0
-        
-        return {
-            "total_files": total,
-            "total_size_mb": total_size / (1024 * 1024),
-            "files_accessed_last_7_days": recent_access,
-            "files_added_today": today_added
-        }
-    except Exception as e:
-        logger.error(f"Error getting cache stats: {e}")
-        raise HTTPException(status_code=500, detail="Internal server error")
+    
+    return JSONResponse({
+        "status": "not_found",
+        "message": "File not found in cache or processing queue"
+    }, status_code=404)
 
-@app.get("/system/health")
+@app.get("/health")
 async def health_check():
     """Health check endpoint"""
-    try:
-        status = {
-            "status": "healthy",
-            "whisper_loaded": whisper_model is not None,
-            "device": device,
-            "cuda_available": torch.cuda.is_available(),
-            "timestamp": datetime.now().isoformat()
-        }
-        
-        # Check database connection
-        try:
-            with db_manager.get_connection() as conn:
-                cursor = conn.cursor()
-                cursor.execute('SELECT 1')
-            status["database"] = "connected"
-        except:
-            status["database"] = "disconnected"
-            status["status"] = "degraded"
-        
-        return status
-    except Exception as e:
-        logger.error(f"Health check failed: {e}")
-        return {"status": "unhealthy", "error": str(e)}
-
-@app.get("/system/memory")
-async def memory_usage():
-    """Get memory usage information"""
-    try:
-        if torch.cuda.is_available():
-            gpu_memory = torch.cuda.memory_allocated() / (1024 ** 3)  # GB
-            gpu_max = torch.cuda.max_memory_allocated() / (1024 ** 3)
-            gpu_reserved = torch.cuda.memory_reserved() / (1024 ** 3)
-        else:
-            gpu_memory = gpu_max = gpu_reserved = 0
-        
-        import psutil
-        process = psutil.Process()
-        memory_info = process.memory_info()
-        
-        return {
-            "gpu_memory_gb": round(gpu_memory, 2),
-            "gpu_max_memory_gb": round(gpu_max, 2),
-            "gpu_reserved_memory_gb": round(gpu_reserved, 2),
-            "ram_used_mb": round(memory_info.rss / (1024 ** 2), 2),
-            "ram_available_gb": round(psutil.virtual_memory().available / (1024 ** 3), 2)
-        }
-    except Exception as e:
-        logger.error(f"Memory check failed: {e}")
-        return {"error": "Memory information unavailable"}
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "device": device,
+        "cuda_available": torch.cuda.is_available(),
+        "whisper_loaded": whisper_model is not None
+    }
 
 if __name__ == "__main__":
+    # Production-ready uvicorn configuration
     uvicorn.run(
         app, 
         host="0.0.0.0", 
-        port=8000,
-        timeout_keep_alive=30,
-        limit_concurrency=50,
-        limit_max_requests=1000
+        port=7860, 
+        timeout_keep_alive=300,
+        limit_concurrency=100,
+        limit_max_requests=1000,
+        log_config=None,
+        access_log=False
     )