Update app.py

app.py

@@ -1,27 +1,19 @@
 import os
-import json
 import uuid
+import json
+import time
+import threading
 from datetime import datetime
 from typing import Dict, List, Optional
-from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 import requests
-from supabase import create_client
-import threading
-import time
-
-# =============================================
-# CONFIGURATION
-# =============================================
-SUPABASE_URL = os.environ.get("SUPABASE_URL")
-SUPABASE_KEY = os.environ.get("SUPABASE_KEY")
-SUPABASE = create_client(SUPABASE_URL, SUPABASE_KEY) if SUPABASE_URL and SUPABASE_KEY else None
+import uvicorn
 
 print("=" * 60)
 print("🚀 STARTING STATUS TRACKER")
 print("=" * 60)
-print(f"Supabase connected: {SUPABASE is not None}")
 
 # =============================================
 # DATA MODELS
@@ -30,53 +22,44 @@ print(f"Supabase connected: {SUPABASE is not None}")
 class ServiceConfig(BaseModel):
     """Configuration for a service to track"""
     name: str
-    type: str  # 'tts', 'image', 'video', etc.
-    expected_count: int = 1  # How many items expected from this service
-    timeout_minutes: int = 10
-    webhook_url: Optional[str] = None
+    type: str
+    expected_count: int = 1
+    timeout_minutes: int = 30
+
+class RegisterRequest(BaseModel):
+    """Request to register a new project"""
+    project_id: Optional[str] = None
+    n8n_webhook: str
+    services: List[str]
 
 class StatusUpdate(BaseModel):
     """Status update from a service"""
     project_id: str
-    service_type: str  # 'tts', 'image', etc.
-    status: str  # 'started', 'processing', 'completed', 'failed'
+    service_type: str
+    status: str  # 'processing', 'completed', 'failed'
     file_urls: Optional[List[str]] = None
-    file_count: Optional[int] = 1
     error: Optional[str] = None
-    metadata: Optional[Dict] = None
-    timestamp: str = datetime.now().isoformat()
 
-class ProjectStatus(BaseModel):
-    """Track status of a complete project"""
-    project_id: str
-    created_at: str
-    services: Dict[str, ServiceStatus]
-    n8n_webhook: Optional[str]
-    all_completed: bool = False
-    completed_at: Optional[str] = None
-    final_data: Dict = {}
-
-class ServiceStatus(BaseModel):
-    """Status of a single service"""
-    type: str
-    status: str  # 'pending', 'processing', 'completed', 'failed'
-    file_urls: List[str] = []
-    file_count: int = 0
-    started_at: str
-    completed_at: Optional[str] = None
-    error: Optional[str] = None
-    metadata: Dict = {}
+class Project:
+    """Track a single project"""
+    def __init__(self, project_id, n8n_webhook, services):
+        self.project_id = project_id
+        self.n8n_webhook = n8n_webhook
+        self.services = {s: {"status": "pending", "file_urls": []} for s in services}
+        self.created_at = datetime.now()
+        self.completed_at = None
+        self.last_update = datetime.now()
 
 # =============================================
-# STORAGE (In-memory + Supabase)
+# STORAGE (In-memory only - no database needed)
 # =============================================
 
-projects = {}  # project_id -> ProjectStatus
-services_config = {}  # service_type -> ServiceConfig
+projects = {}  # project_id -> Project
+services_config = {}  # Load from environment
 
 # Load service configurations from environment
 def load_service_configs():
-    """Load service configurations from environment variables"""
+    """Load service configurations from environment variable"""
     config_str = os.environ.get("SERVICE_CONFIGS", "[]")
     try:
         configs = json.loads(config_str)
@@ -85,9 +68,9 @@ def load_service_configs():
         print(f"✅ Loaded {len(configs)} service configurations")
     except Exception as e:
         print(f"❌ Failed to load service configs: {e}")
-        # Default configs if none provided
-        services_config["tts"] = ServiceConfig(name="TTS Service", type="tts", expected_count=1)
-        services_config["image"] = ServiceConfig(name="Image Generator", type="image", expected_count=4)
+        # Default configs
+        services_config["tts"] = ServiceConfig(name="TTS", type="tts", timeout_minutes=30)
+        services_config["image"] = ServiceConfig(name="Image", type="image", timeout_minutes=30)
 
 load_service_configs()
 
@@ -109,137 +92,101 @@ app.add_middleware(
 # API ENDPOINTS
 # =============================================
 
-@app.post("/api/register-project")
-async def register_project(request: dict):
-    """Register a new project to track"""
+@app.post("/api/register")
+async def register_project(request: RegisterRequest):
+    """Register a new project with its own webhook URL"""
     try:
-        project_id = request.get("project_id") or str(uuid.uuid4())
-        n8n_webhook = request.get("n8n_webhook")
-        services = request.get("services", list(services_config.keys()))
+        project_id = request.project_id or str(uuid.uuid4())[:8]
         
-        print(f"📝 Registering project: {project_id}")
-        print(f"   Services to track: {services}")
+        print(f"\n📝 Registering new project:")
+        print(f"   Project ID: {project_id}")
+        print(f"   Webhook: {request.n8n_webhook}")
+        print(f"   Services: {request.services}")
         
-        # Create project status
-        project = ProjectStatus(
+        # Create new project
+        projects[project_id] = Project(
             project_id=project_id,
-            created_at=datetime.now().isoformat(),
-            services={},
-            n8n_webhook=n8n_webhook
+            n8n_webhook=request.n8n_webhook,
+            services=request.services
         )
         
-        # Initialize each service
-        for service_type in services:
-            config = services_config.get(service_type)
-            if config:
-                project.services[service_type] = ServiceStatus(
-                    type=service_type,
-                    status="pending",
-                    file_urls=[],
-                    file_count=0,
-                    started_at=datetime.now().isoformat()
-                )
-        
-        projects[project_id] = project
-        
-        # Also save to Supabase if available
-        if SUPABASE:
-            try:
-                SUPABASE.table("tracked_projects").insert({
-                    "project_id": project_id,
-                    "data": project.dict(),
-                    "created_at": datetime.now().isoformat()
-                }).execute()
-            except Exception as e:
-                print(f"⚠️ Failed to save to Supabase: {e}")
-        
         return {
             "status": "registered",
             "project_id": project_id,
-            "services": list(project.services.keys())
+            "webhook": request.n8n_webhook,
+            "services": request.services
         }
         
     except Exception as e:
         print(f"❌ Registration error: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.post("/api/update-status")
+@app.post("/api/update")
 async def update_status(update: StatusUpdate):
     """Receive status update from a service"""
     try:
         project_id = update.project_id
         service_type = update.service_type
         
-        print(f"📥 Status update for {project_id} - {service_type}: {update.status}")
+        print(f"\n📥 Status update:")
+        print(f"   Project: {project_id}")
+        print(f"   Service: {service_type}")
+        print(f"   Status: {update.status}")
         
+        # Check if project exists
         if project_id not in projects:
-            # Try to load from Supabase
-            if SUPABASE:
-                result = SUPABASE.table("tracked_projects").select("*").eq("project_id", project_id).execute()
-                if result.data:
-                    projects[project_id] = ProjectStatus(**result.data[0]["data"])
-                else:
-                    return {"error": "Project not found"}
-            else:
-                return {"error": "Project not found"}
+            print(f"❌ Project not found: {project_id}")
+            return {"error": "Project not found"}
         
         project = projects[project_id]
+        project.last_update = datetime.now()
         
         # Update service status
         if service_type in project.services:
-            service = project.services[service_type]
-            service.status = update.status
+            project.services[service_type]["status"] = update.status
             if update.file_urls:
-                service.file_urls.extend(update.file_urls)
-            if update.file_count:
-                service.file_count = update.file_count
+                project.services[service_type]["file_urls"] = update.file_urls
             if update.error:
-                service.error = update.error
-            if update.metadata:
-                service.metadata.update(update.metadata)
-            
-            if update.status == "completed":
-                service.completed_at = datetime.now().isoformat()
-        else:
-            # New service not in original registration
-            config = services_config.get(service_type)
-            if config:
-                project.services[service_type] = ServiceStatus(
-                    type=service_type,
-                    status=update.status,
-                    file_urls=update.file_urls or [],
-                    file_count=update.file_count or 0,
-                    started_at=datetime.now().isoformat(),
-                    completed_at=datetime.now().isoformat() if update.status == "completed" else None
-                )
+                project.services[service_type]["error"] = update.error
         
         # Check if all services are complete
         all_completed = all(
-            s.status == "completed" for s in project.services.values()
+            s["status"] == "completed" for s in project.services.values()
         )
         
-        if all_completed and not project.all_completed:
-            project.all_completed = True
-            project.completed_at = datetime.now().isoformat()
+        if all_completed and not project.completed_at:
+            project.completed_at = datetime.now()
+            print(f"🎉 Project {project_id} COMPLETED!")
             
             # Prepare final data
-            for service_type, service in project.services.items():
-                project.final_data[service_type] = {
-                    "file_urls": service.file_urls,
-                    "file_count": service.file_count,
-                    "metadata": service.metadata
+            final_data = {
+                "project_id": project_id,
+                "status": "completed",
+                "completed_at": project.completed_at.isoformat(),
+                "services": {}
+            }
+            
+            for s_type, s_data in project.services.items():
+                final_data["services"][s_type] = {
+                    "file_urls": s_data.get("file_urls", []),
+                    "file_count": len(s_data.get("file_urls", [])),
+                    "status": s_data["status"]
                 }
             
-            # Send webhook to n8n if configured
-            if project.n8n_webhook:
-                await send_n8n_webhook(project)
-        
-        # Update Supabase
-        if SUPABASE:
-            SUPABASE.table("tracked_projects").update({
-                "data": project.dict(),
-                "updated_at": datetime.now().isoformat()
-            }).eq("project_id", project_id).execute()
+            # Send webhook to n8n
+            try:
+                webhook_response = requests.post(
+                    project.n8n_webhook,
+                    json=final_data,
+                    timeout=10,
+                    headers={"Content-Type": "application/json"}
+                )
+                print(f"📤 Webhook sent to n8n: {webhook_response.status_code}")
+            except Exception as e:
+                print(f"❌ Failed to send webhook: {e}")
+            
+            # Clean up old project (optional)
+            # del projects[project_id]
         
         return {
             "status": "updated",
@@ -251,95 +198,76 @@ async def update_status(update: StatusUpdate):
         print(f"❌ Update error: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/api/project-status/{project_id}")
-async def get_project_status(project_id: str):
+@app.get("/api/status/{project_id}")
+async def get_status(project_id: str):
     """Get current status of a project"""
-    if project_id in projects:
-        return projects[project_id].dict()
+    if project_id not in projects:
+        raise HTTPException(status_code=404, detail="Project not found")
     
-    # Try Supabase
-    if SUPABASE:
-        result = SUPABASE.table("tracked_projects").select("*").eq("project_id", project_id).execute()
-        if result.data:
-            return result.data[0]["data"]
+    project = projects[project_id]
     
-    raise HTTPException(status_code=404, detail="Project not found")
+    return {
+        "project_id": project_id,
+        "created_at": project.created_at.isoformat(),
+        "completed_at": project.completed_at.isoformat() if project.completed_at else None,
+        "services": project.services,
+        "all_completed": all(s["status"] == "completed" for s in project.services.values())
+    }
 
 @app.get("/api/services")
 async def list_services():
     """List all configured services"""
     return {
         "services": [
-            {
-                "type": stype,
-                "config": config.dict()
-            }
+            {"type": stype, "config": config.dict()}
             for stype, config in services_config.items()
         ]
     }
 
-@app.post("/api/services/add")
-async def add_service(config: ServiceConfig):
-    """Add a new service to track"""
-    services_config[config.type] = config
-    return {"status": "added", "service": config.dict()}
-
 @app.get("/health")
 async def health():
+    """Health check endpoint"""
     return {
         "status": "healthy",
-        "projects_tracking": len(projects),
-        "services_configured": list(services_config.keys())
+        "active_projects": len(projects),
+        "services_configured": list(services_config.keys()),
+        "timestamp": datetime.now().isoformat()
     }
 
-# =============================================
-# HELPER FUNCTIONS
-# =============================================
-
-async def send_n8n_webhook(project: ProjectStatus):
-    """Send completion webhook to n8n"""
-    try:
-        webhook_data = {
-            "project_id": project.project_id,
-            "status": "completed",
-            "completed_at": project.completed_at,
-            "services": {}
-        }
-        
-        for service_type, service in project.services.items():
-            webhook_data["services"][service_type] = {
-                "file_urls": service.file_urls,
-                "file_count": service.file_count,
-                "metadata": service.metadata,
-                "completed_at": service.completed_at
-            }
-        
-        response = requests.post(
-            project.n8n_webhook,
-            json=webhook_data,
-            timeout=10,
-            headers={"Content-Type": "application/json"}
-        )
-        
-        print(f"📤 Webhook sent to n8n: {response.status_code}")
-        
-    except Exception as e:
-        print(f"❌ Failed to send webhook: {e}")
+@app.get("/")
+async def root():
+    """Root endpoint"""
+    return {
+        "name": "Status Tracker API",
+        "version": "1.0.0",
+        "endpoints": {
+            "register": "POST /api/register",
+            "update": "POST /api/update",
+            "status": "GET /api/status/{project_id}",
+            "services": "GET /api/services",
+            "health": "GET /health"
+        },
+        "active_projects": len(projects),
+        "services": list(services_config.keys())
+    }
 
 # =============================================
-# BACKGROUND CLEANUP TASK
+# BACKGROUND CLEANUP TASK (Optional)
 # =============================================
 
 def cleanup_old_projects():
-    """Remove projects older than 24 hours"""
+    """Remove projects older than 1 hour"""
     while True:
-        time.sleep(3600)  # Check every hour
+        time.sleep(300)  # Check every 5 minutes
         now = datetime.now()
         to_delete = []
         
         for pid, project in projects.items():
-            created = datetime.fromisoformat(project.created_at)
-            if (now - created).total_seconds() > 86400:  # 24 hours
+            # Remove projects completed more than 1 hour ago
+            if project.completed_at and (now - project.completed_at).total_seconds() > 3600:
+                to_delete.append(pid)
+            # Remove projects older than 2 hours (stuck)
+            elif (now - project.created_at).total_seconds() > 7200:
                 to_delete.append(pid)
         
         for pid in to_delete:
@@ -354,10 +282,10 @@ cleanup_thread.start()
 # RUN
 # =============================================
 if __name__ == "__main__":
-    import uvicorn
     print("\n" + "=" * 60)
     print("🌐 Status Tracker running on port 7860")
-    print(f"📊 Tracking {len(projects)} projects")
-    print(f"🔧 Configured services: {list(services_config.keys())}")
+    print(f"📊 Active projects: {len(projects)}")
+    print(f"🔧 Services: {list(services_config.keys())}")
     print("=" * 60)
+    
     uvicorn.run(app, host="0.0.0.0", port=7860)