added logging - Clear start and end markers for the function call. Logging of input parameters.

app.py

@@ -17,6 +17,7 @@ from trellis.utils import render_utils, postprocessing_utils
 
 import traceback
 import sys
+import time
 
 
 # Add JSON encoder for NumPy arrays
@@ -270,8 +271,8 @@ def generate_and_extract_glb(
     slat_sampling_steps: int,
     mesh_simplify: float, # Added from extract_glb
     texture_size: int,    # Added from extract_glb
-    req: gr.Request,
-) -> str: # MODIFIED: Returns only the final GLB path string
+    req: gr.Request, # Keep req for potential session info if needed
+) -> Optional[str]: # MODIFIED: Explicitly show it can return None
     """
     Combines 3D model generation and GLB extraction into a single step 
     for API usage, avoiding the need to transfer the state object.
@@ -288,17 +289,30 @@ def generate_and_extract_glb(
         req (gr.Request): Gradio request object.
         
     Returns:
-        str: The absolute path to the generated GLB file within the Space's filesystem.
-             Returns None if any step fails.
+        Optional[str]: The absolute path to the generated GLB file within the Space's filesystem,
+                       or None if any step fails.
     """
-    user_dir = os.path.join(TMP_DIR, str(req.session_hash))
-    os.makedirs(user_dir, exist_ok=True)
+    session_hash = "API_CALL" # Use a generic identifier for API calls if req is None or lacks session
+    if req and hasattr(req, 'session_hash') and req.session_hash:
+        session_hash = req.session_hash
+        
+    user_dir = os.path.join(TMP_DIR, str(session_hash))
+    try:
+        os.makedirs(user_dir, exist_ok=True)
+    except Exception as e:
+        print(f"[{session_hash}] API: ERROR creating directory {user_dir}: {e}")
+        return None # Cannot proceed without directory
     
-    print(f"[{req.session_hash}] API: Starting combined generation and extraction for prompt: {prompt}")
+    print(f"[{session_hash}] API: ===== generate_and_extract_glb START ====")
+    print(f"[{session_hash}] API: Prompt: '{prompt}', Seed: {seed}, Simplify: {mesh_simplify}, Texture: {texture_size}")
+    
+    gs_output = None
+    mesh_output = None
     
     # --- Step 1: Generate 3D Model (adapted from text_to_3d) ---
     try:
-        print(f"[{req.session_hash}] API: Running generation pipeline...")
+        print(f"[{session_hash}] API: Step 1 - Running generation pipeline...")
+        t_start_gen = time.time() # Add timing
         outputs = pipeline.run(
             prompt,
             seed=seed,
@@ -312,34 +326,87 @@ def generate_and_extract_glb(
                 "cfg_strength": slat_guidance_strength,
             },
         )
-        # Keep handles to the direct outputs (no need to pack/unpack state)
+        t_end_gen = time.time()
+        print(f"[{session_hash}] API: Step 1 - Generation pipeline completed in {t_end_gen - t_start_gen:.2f}s.")
+        
+        # Validate outputs immediately
+        if not outputs or 'gaussian' not in outputs or not outputs['gaussian'] or 'mesh' not in outputs or not outputs['mesh']:
+            print(f"[{session_hash}] API: ERROR - Pipeline output is missing expected keys or values.")
+            return None
+            
         gs_output = outputs['gaussian'][0]
         mesh_output = outputs['mesh'][0]
-        print(f"[{req.session_hash}] API: Generation pipeline completed.")
+        
+        if gs_output is None or mesh_output is None:
+             print(f"[{session_hash}] API: ERROR - Pipeline returned None for gs_output or mesh_output.")
+             return None
+             
+        print(f"[{session_hash}] API: Step 1 - Outputs obtained (gs type: {type(gs_output)}, mesh type: {type(mesh_output)}).")
+        
     except Exception as e:
-        print(f"[{req.session_hash}] API: ERROR during generation pipeline: {e}")
-        traceback.print_exc() 
-        torch.cuda.empty_cache()
+        print(f"[{session_hash}] API: ERROR during generation pipeline step: {e}")
+        # Print detailed traceback
+        traceback.print_exc()
+        # Clean up CUDA memory before returning
+        try: 
+            torch.cuda.empty_cache()
+            print(f"[{session_hash}] API: CUDA cache cleared after generation error.")
+        except Exception as cache_e:
+            print(f"[{session_hash}] API: Error clearing CUDA cache after generation error: {cache_e}")
         return None # Return None on failure
         
     # --- Step 2: Extract GLB (adapted from extract_glb) ---
+    glb_path = None # Initialize glb_path
     try:
-        print(f"[{req.session_hash}] API: Extracting GLB (simplify={mesh_simplify}, texture={texture_size})...")
+        print(f"[{session_hash}] API: Step 2 - Extracting GLB (simplify={mesh_simplify}, texture={texture_size})...")
+        # Check if inputs from previous step are valid
+        if gs_output is None or mesh_output is None:
+             print(f"[{session_hash}] API: ERROR - Cannot proceed with GLB extraction, gs_output or mesh_output is None.")
+             return None
+             
+        t_start_glb = time.time()
         # Directly use the outputs from the pipeline
         glb = postprocessing_utils.to_glb(gs_output, mesh_output, simplify=mesh_simplify, texture_size=texture_size, verbose=False)
-        glb_path = os.path.join(user_dir, 'api_generated_sample.glb') # Use a distinct name for API outputs
-        print(f"[{req.session_hash}] API: Saving GLB to {glb_path}")
+        t_end_glb = time.time()
+        print(f"[{session_hash}] API: Step 2 - GLB object created in {t_end_glb - t_start_glb:.2f}s.")
+        
+        if glb is None:
+            print(f"[{session_hash}] API: ERROR - postprocessing_utils.to_glb returned None.")
+            return None
+            
+        glb_path = os.path.join(user_dir, f'api_generated_{session_hash}.glb') # Use unique name
+        print(f"[{session_hash}] API: Step 2 - Saving GLB to {glb_path}...")
+        t_start_save = time.time()
         glb.export(glb_path)
-        print(f"[{req.session_hash}] API: GLB extraction completed.")
+        t_end_save = time.time()
+        print(f"[{session_hash}] API: Step 2 - GLB saved in {t_end_save - t_start_save:.2f}s.")
+        print(f"[{session_hash}] API: Step 2 - GLB extraction completed successfully.")
+        
     except Exception as e:
-        print(f"[{req.session_hash}] API: ERROR during GLB extraction: {e}")
+        print(f"[{session_hash}] API: ERROR during GLB extraction step: {e}")
+        # Print detailed traceback
         traceback.print_exc()
-        torch.cuda.empty_cache()
+        # Clean up CUDA memory before returning
+        try: 
+            torch.cuda.empty_cache()
+            print(f"[{session_hash}] API: CUDA cache cleared after extraction error.")
+        except Exception as cache_e:
+            print(f"[{session_hash}] API: Error clearing CUDA cache after extraction error: {cache_e}")
         return None # Return None on failure
 
-    torch.cuda.empty_cache()
-    print(f"[{req.session_hash}] API: Combined process successful. Returning GLB path: {glb_path}")
-    return glb_path # Return only the path to the generated GLB
+    # --- Final Cleanup and Return ---
+    try:
+        torch.cuda.empty_cache()
+        print(f"[{session_hash}] API: Final CUDA cache cleared.")
+    except Exception as cache_e:
+        print(f"[{session_hash}] API: Error clearing final CUDA cache: {cache_e}")
+        
+    if glb_path and os.path.exists(glb_path):
+        print(f"[{session_hash}] API: ===== generate_and_extract_glb END (Success) ===== Returning GLB path: {glb_path}")
+        return glb_path # Return only the path to the generated GLB
+    else:
+        print(f"[{session_hash}] API: ===== generate_and_extract_glb END (Failure) ===== GLB path not generated or does not exist.")
+        return None # Ensure None is returned if glb_path wasn't set or file doesn't exist
 # --- END NEW COMBINED API FUNCTION ---