Update app.py

app.py

@@ -1,6 +1,5 @@
 """
-Main FastAPI Application for Text-to-3D Generator
-Completely Free - No Paid APIs
+Main FastAPI Application - Advanced Text-to-3D
 """
 
 from fastapi import FastAPI, HTTPException, Request
@@ -12,23 +11,21 @@ import uvicorn
 import base64
 import uuid
 import logging
+import time
 
 from nlp_processor import NLPProcessor
 from model_generator import ModelGenerator
 from context_memory import ContextMemory
 
-# Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Initialize FastAPI app
 app = FastAPI(
-    title="Free Text-to-3D API",
-    description="Convert natural language to 3D models - 100% Free",
-    version="1.0.0"
+    title="Advanced Text-to-3D API",
+    description="Professional AI-powered text to 3D model generation",
+    version="2.0.0"
 )
 
-# CORS middleware for frontend communication
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -37,13 +34,12 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Initialize modules
-nlp_processor = NLPProcessor()
-model_generator = ModelGenerator()
-context_memory = ContextMemory()
+# Initialize
+nlp = NLPProcessor()
+generator = ModelGenerator()
+memory = ContextMemory()
 
 
-# Request/Response Models
 class GenerateRequest(BaseModel):
     prompt: str
     session_id: Optional[str] = None
@@ -58,157 +54,118 @@ class GenerateResponse(BaseModel):
     model_obj: Optional[str] = None
     model_params: Optional[Dict[str, Any]] = None
     interpretation: Optional[str] = None
+    generation_time: Optional[float] = None
 
 
-class HealthResponse(BaseModel):
-    status: str
-    version: str
-
-
-@app.get("/", response_model=HealthResponse)
+@app.get("/")
 async def root():
-    """Health check endpoint"""
-    return HealthResponse(status="healthy", version="1.0.0")
+    return {"status": "healthy", "version": "2.0.0", "service": "Advanced Text-to-3D"}
 
 
-@app.get("/health", response_model=HealthResponse)
-async def health_check():
-    """Health check endpoint"""
-    return HealthResponse(status="healthy", version="1.0.0")
+@app.get("/health")
+async def health():
+    return {"status": "healthy", "version": "2.0.0"}
 
 
 @app.post("/generate", response_model=GenerateResponse)
-async def generate_model(request: GenerateRequest):
-    """
-    Generate or refine a 3D model from text prompt
-    """
+async def generate(request: GenerateRequest):
+    start_time = time.time()
+    
     try:
-        # Generate session ID if not provided
         session_id = request.session_id or str(uuid.uuid4())
         
-        logger.info(f"Processing request for session {session_id}: {request.prompt}")
+        logger.info(f"[{session_id[:8]}] Prompt: {request.prompt}")
         
-        # Get existing context if this is a refinement
-        existing_context = None
+        # Get context for refinements
+        context = None
         if request.is_refinement:
-            existing_context = context_memory.get_context(session_id)
+            context = memory.get_context(session_id)
         
-        # Process the prompt with NLP
-        nlp_result = nlp_processor.process_prompt(
-            prompt=request.prompt,
-            existing_context=existing_context
-        )
+        # Process with NLP
+        nlp_result = nlp.process_prompt(request.prompt, context)
         
-        if not nlp_result["success"]:
+        if not nlp_result.get("success"):
             return GenerateResponse(
                 success=False,
                 session_id=session_id,
-                message=nlp_result.get("error", "Failed to understand prompt"),
-                interpretation=nlp_result.get("interpretation", "")
+                message=nlp_result.get("error", "Failed to understand"),
+                interpretation=nlp_result.get("interpretation")
             )
         
-        # Generate the 3D model
+        # Generate 3D model
         model_params = nlp_result["model_params"]
-        model_result = model_generator.generate(model_params)
+        model_result = generator.generate(model_params)
         
-        if not model_result["success"]:
+        if not model_result.get("success"):
             return GenerateResponse(
                 success=False,
                 session_id=session_id,
-                message=model_result.get("error", "Failed to generate model"),
-                interpretation=nlp_result.get("interpretation", "")
+                message=model_result.get("error", "Generation failed"),
+                interpretation=nlp_result.get("interpretation")
             )
         
-        # Save context for future refinements
-        context_memory.save_context(session_id, {
-            "prompt_history": context_memory.get_context(session_id, {}).get("prompt_history", []) + [request.prompt],
+        # Save context
+        memory.save_context(session_id, {
+            "prompt_history": memory.get_context(session_id, {}).get("prompt_history", []) + [request.prompt],
             "model_params": model_params,
             "nlp_result": nlp_result
         })
         
-        # Encode models to base64
-        glb_base64 = base64.b64encode(model_result["glb_data"]).decode("utf-8")
-        obj_base64 = base64.b64encode(model_result["obj_data"]).decode("utf-8")
+        # Encode models
+        glb_b64 = base64.b64encode(model_result["glb_data"]).decode("utf-8")
+        obj_b64 = base64.b64encode(model_result["obj_data"]).decode("utf-8")
+        
+        gen_time = time.time() - start_time
+        
+        logger.info(f"[{session_id[:8]}] Generated in {gen_time:.2f}s")
         
         return GenerateResponse(
             success=True,
             session_id=session_id,
             message="Model generated successfully",
-            model_glb=glb_base64,
-            model_obj=obj_base64,
+            model_glb=glb_b64,
+            model_obj=obj_b64,
             model_params=model_params,
-            interpretation=nlp_result.get("interpretation", "")
+            interpretation=nlp_result.get("interpretation"),
+            generation_time=round(gen_time, 2)
         )
         
     except Exception as e:
-        logger.error(f"Error generating model: {str(e)}")
+        logger.error(f"Error: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
 @app.post("/refine", response_model=GenerateResponse)
-async def refine_model(request: GenerateRequest):
-    """
-    Refine an existing model based on new instructions
-    """
+async def refine(request: GenerateRequest):
     request.is_refinement = True
-    return await generate_model(request)
-
-
-@app.get("/session/{session_id}")
-async def get_session(session_id: str):
-    """Get session context"""
-    context = context_memory.get_context(session_id)
-    if context:
-        return {"success": True, "context": context}
-    return {"success": False, "message": "Session not found"}
-
-
-@app.delete("/session/{session_id}")
-async def clear_session(session_id: str):
-    """Clear session context"""
-    context_memory.clear_context(session_id)
-    return {"success": True, "message": "Session cleared"}
+    return await generate(request)
 
 
-@app.get("/supported-shapes")
-async def get_supported_shapes():
-    """Get list of supported shapes and operations"""
+@app.get("/capabilities")
+async def capabilities():
     return {
-        "shapes": [
-            "cube", "box", "sphere", "ball", 
-            "cylinder", "cone", "torus", "donut",
-            "pyramid", "plane", "capsule"
-        ],
-        "colors": [
-            "red", "green", "blue", "yellow", "orange",
-            "purple", "pink", "white", "black", "gray",
-            "brown", "cyan", "magenta", "gold", "silver"
-        ],
-        "sizes": ["tiny", "small", "medium", "large", "huge"],
-        "operations": [
-            "combine", "merge", "stack", "place on top",
-            "next to", "inside", "rotate", "scale"
-        ],
-        "modifiers": [
-            "smooth", "rough", "metallic", "glossy", "matte"
+        "shapes": ["cube", "sphere", "cylinder", "cone", "torus", "pyramid", "capsule", "plane"],
+        "arrangements": ["row", "column", "circle", "grid", "stack", "random", "increasing", "decreasing"],
+        "relations": ["on top of", "below", "next to", "left of", "right of", "in front of", "behind", "inside", "around"],
+        "materials": ["metallic", "matte", "glossy", "shiny", "rough", "smooth"],
+        "modifiers": ["bigger", "smaller", "taller", "shorter", "wider", "rotate", "flip"],
+        "examples": [
+            "3 red cubes",
+            "5 blue spheres arranged in a circle",
+            "A cone on top of a cylinder",
+            "Golden torus next to silver pyramid",
+            "6 cubes of increasing size",
+            "Stack a sphere on a cube on a cylinder",
+            "Grid of 9 colorful spheres"
         ]
     }
 
 
-# Error handlers
 @app.exception_handler(Exception)
-async def global_exception_handler(request: Request, exc: Exception):
-    logger.error(f"Global error: {str(exc)}")
-    return JSONResponse(
-        status_code=500,
-        content={"success": False, "message": str(exc)}
-    )
+async def exception_handler(request: Request, exc: Exception):
+    logger.error(f"Unhandled: {str(exc)}")
+    return JSONResponse(status_code=500, content={"success": False, "message": str(exc)})
 
 
 if __name__ == "__main__":
-    uvicorn.run(
-        "app:app",
-        host="0.0.0.0",
-        port=7860,
-        reload=True
-    )
+    uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=True)