another fucking try

app.py

@@ -1,14 +1,12 @@
-# Version: 1.1.2 - API State Fix + DEBUG (Video Disabled) + Import Fix (2025-05-04)
+# Version: 1.1.3 - API State Fix + DEBUG (Video Disabled) + unload() Fix (2025-05-04)
 # Changes:
+# - FIXED TypeError in demo.unload() by removing incorrect 'inputs'/'outputs' arguments.
 # - ENSURED `import spaces` is present for the @spaces.GPU decorator.
 # - TEMPORARY DEBUGGING STEP: Commented out video rendering in `text_to_3d`
 #   and return None for video_path to isolate the "Session not found" error.
-# - Modified `text_to_3d` to explicitly return the serializable `state_dict` from `pack_state`
-#   as the first return value. This ensures the dictionary is available via the API.
-# - Modified `extract_glb` and `extract_gaussian` to accept `state_dict: dict` as their first argument
-#   instead of relying on the implicit `gr.State` object type when called via API.
-# - Kept Gradio UI bindings (`outputs=[output_buf, ...]`, `inputs=[output_buf, ...]`)
-#   so the UI continues to function by passing the dictionary through output_buf.
+# - Modified `text_to_3d` to explicitly return the serializable `state_dict` from `pack_state`.
+# - Modified `extract_glb`/`extract_gaussian` to accept `state_dict: dict`.
+# - Kept Gradio UI bindings using `output_buf`.
 # - Added minor safety checks and logging.
 
 import gradio as gr
@@ -17,8 +15,6 @@ import spaces  # <<<--- ENSURE THIS IMPORT IS PRESENT
 import os
 import shutil
 os.environ['TOKENIZERS_PARALLELISM'] = 'true'
-# Fix potential SpConv issue if needed, try 'hash' or 'native'
-# os.environ.setdefault('SPCONV_ALGO', 'native') # Use setdefault to avoid overwriting if already set
 os.environ['SPCONV_ALGO'] = 'native' # Direct set as per original
 
 from typing import *
@@ -35,33 +31,43 @@ import sys
 
 
 MAX_SEED = np.iinfo(np.int32).max
-# Ensure TMP_DIR is correctly defined relative to the script location
-# Using /tmp/ directly might be more robust in some container environments
-# TMP_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'tmp')
-TMP_DIR = '/tmp/gradio_sessions' # Use standard /tmp directory
+# Use standard /tmp directory which is usually available in container environments
+TMP_DIR = '/tmp/gradio_sessions'
 print(f"Using temporary directory: {TMP_DIR}")
-os.makedirs(TMP_DIR, exist_ok=True)
+# Ensure the base temp directory exists
+try:
+    os.makedirs(TMP_DIR, exist_ok=True)
+except OSError as e:
+    print(f"Warning: Could not create base temp directory {TMP_DIR}: {e}", file=sys.stderr)
+    # Potentially fall back or exit if temp dir is critical
+    TMP_DIR = '.' # Fallback to current directory (less ideal)
+    print(f"Warning: Falling back to use current directory for temp files: {os.path.abspath(TMP_DIR)}")
 
 
 def start_session(req: gr.Request):
     """Creates a temporary directory for the user session."""
+    user_dir = None # Initialize
     try:
         session_hash = req.session_hash
         if not session_hash:
-             # Fallback or generate a temporary ID if session_hash is missing (might happen on first load?)
              session_hash = f"no_session_{np.random.randint(10000, 99999)}"
              print(f"Warning: No session_hash in request, using temporary ID: {session_hash}")
 
+        # Ensure TMP_DIR exists before joining path
+        if not os.path.exists(TMP_DIR):
+             os.makedirs(TMP_DIR, exist_ok=True)
+
         user_dir = os.path.join(TMP_DIR, str(session_hash))
         os.makedirs(user_dir, exist_ok=True)
-        print(f"Started session, created directory: {user_dir}")
+        print(f"Started session, ensured directory exists: {user_dir}")
     except Exception as e:
-        print(f"Error in start_session: {e}", file=sys.stderr)
-        # Decide if this is critical - maybe raise to prevent further issues?
+        print(f"Error in start_session creating directory '{user_dir}': {e}", file=sys.stderr)
+        traceback.print_exc()
 
 
 def end_session(req: gr.Request):
     """Removes the temporary directory for the user session."""
+    user_dir = None # Initialize
     try:
         session_hash = req.session_hash
         if not session_hash:
@@ -69,16 +75,16 @@ def end_session(req: gr.Request):
             return
 
         user_dir = os.path.join(TMP_DIR, str(session_hash))
-        if os.path.exists(user_dir):
+        if os.path.exists(user_dir) and os.path.isdir(user_dir): # Extra check if it's a directory
             try:
                 shutil.rmtree(user_dir)
                 print(f"Ended session, removed directory: {user_dir}")
             except OSError as e:
                 print(f"Error removing tmp directory {user_dir}: {e.strerror}", file=sys.stderr)
         else:
-            print(f"Ended session, directory already removed or hash mismatch: {user_dir}")
+            print(f"Ended session, directory not found or not a directory: {user_dir}")
     except Exception as e:
-        print(f"Error in end_session: {e}", file=sys.stderr)
+        print(f"Error in end_session cleaning directory '{user_dir}': {e}", file=sys.stderr)
 
 
 def pack_state(gs: Gaussian, mesh: MeshExtractResult) -> dict:
@@ -87,7 +93,7 @@ def pack_state(gs: Gaussian, mesh: MeshExtractResult) -> dict:
     try:
         packed_data = {
             'gaussian': {
-                **{k: v for k, v in gs.init_params.items()}, # Ensure init_params are included
+                **{k: v for k, v in gs.init_params.items()},
                 '_xyz': gs._xyz.detach().cpu().numpy(),
                 '_features_dc': gs._features_dc.detach().cpu().numpy(),
                 '_scaling': gs._scaling.detach().cpu().numpy(),
@@ -104,7 +110,7 @@ def pack_state(gs: Gaussian, mesh: MeshExtractResult) -> dict:
     except Exception as e:
         print(f"Error during pack_state: {e}", file=sys.stderr)
         traceback.print_exc()
-        raise  # Re-raise the error to be caught upstream
+        raise
 
 
 def unpack_state(state_dict: dict) -> Tuple[Gaussian, edict]:
@@ -114,23 +120,20 @@ def unpack_state(state_dict: dict) -> Tuple[Gaussian, edict]:
         if not isinstance(state_dict, dict) or 'gaussian' not in state_dict or 'mesh' not in state_dict:
             raise ValueError("Invalid state_dict structure passed to unpack_state.")
 
-        # Ensure the device is correctly set when unpacking
         device = 'cuda' if torch.cuda.is_available() else 'cpu'
         print(f"[unpack_state] Using device: {device}")
 
         gauss_data = state_dict['gaussian']
         mesh_data = state_dict['mesh']
 
-        # Recreate Gaussian object using parameters stored during packing
         gs = Gaussian(
-            aabb=gauss_data.get('aabb'), # Use .get for safety
+            aabb=gauss_data.get('aabb'),
             sh_degree=gauss_data.get('sh_degree'),
             mininum_kernel_size=gauss_data.get('mininum_kernel_size'),
             scaling_bias=gauss_data.get('scaling_bias'),
             opacity_bias=gauss_data.get('opacity_bias'),
             scaling_activation=gauss_data.get('scaling_activation'),
         )
-        # Load tensors, ensuring they are created on the correct device
         gs._xyz = torch.tensor(gauss_data['_xyz'], device=device, dtype=torch.float32)
         gs._features_dc = torch.tensor(gauss_data['_features_dc'], device=device, dtype=torch.float32)
         gs._scaling = torch.tensor(gauss_data['_scaling'], device=device, dtype=torch.float32)
@@ -138,10 +141,9 @@ def unpack_state(state_dict: dict) -> Tuple[Gaussian, edict]:
         gs._opacity = torch.tensor(gauss_data['_opacity'], device=device, dtype=torch.float32)
         print(f"[unpack_state] Gaussian unpacked. Points: {gs.get_xyz.shape[0]}")
 
-        # Recreate mesh object using edict for compatibility if needed elsewhere
         mesh = edict(
             vertices=torch.tensor(mesh_data['vertices'], device=device, dtype=torch.float32),
-            faces=torch.tensor(mesh_data['faces'], device=device, dtype=torch.int64), # Faces are typically long/int64
+            faces=torch.tensor(mesh_data['faces'], device=device, dtype=torch.int64),
         )
         print(f"[unpack_state] Mesh unpacked. Vertices: {mesh.vertices.shape[0]}, Faces: {mesh.faces.shape[0]}")
 
@@ -149,14 +151,14 @@ def unpack_state(state_dict: dict) -> Tuple[Gaussian, edict]:
     except Exception as e:
         print(f"Error during unpack_state: {e}", file=sys.stderr)
         traceback.print_exc()
-        raise # Re-raise the error
+        raise
 
 
 def get_seed(randomize_seed: bool, seed: int) -> int:
     """Gets a seed value, randomizing if requested."""
     new_seed = np.random.randint(0, MAX_SEED) if randomize_seed else seed
     print(f"[get_seed] Randomize: {randomize_seed}, Input Seed: {seed}, Output Seed: {new_seed}")
-    return int(new_seed) # Ensure it's a standard int
+    return int(new_seed)
 
 
 @spaces.GPU
@@ -168,73 +170,57 @@ def text_to_3d(
     slat_guidance_strength: float,
     slat_sampling_steps: int,
     req: gr.Request,
-) -> Tuple[dict, Optional[str]]: # Return type changed Optional[str] for video path
+) -> Tuple[dict, Optional[str]]:
     """
     Generates a 3D model (Gaussian and Mesh) from text and returns a
     serializable state dictionary and potentially a video preview path.
     >>> TEMPORARILY DISABLED VIDEO RENDERING FOR DEBUGGING <<<
     """
     print(f"[text_to_3d - DEBUG MODE] Received prompt: '{prompt}', Seed: {seed}")
-    session_hash = req.session_hash
-    if not session_hash:
-        session_hash = f"no_session_{np.random.randint(10000, 99999)}" # Use consistent fallback
-        print(f"Warning: No session_hash in text_to_3d request, using temporary ID: {session_hash}")
-    user_dir = os.path.join(TMP_DIR, str(session_hash))
-    os.makedirs(user_dir, exist_ok=True) # Ensure it exists for this request
-    print(f"[text_to_3d - DEBUG MODE] User directory: {user_dir}")
-
-    # --- Generation Pipeline ---
+    user_dir = None # Initialize
+    state_dict = None # Initialize
     try:
+        session_hash = req.session_hash
+        if not session_hash:
+            session_hash = f"no_session_{np.random.randint(10000, 99999)}"
+            print(f"Warning: No session_hash in text_to_3d request, using temporary ID: {session_hash}")
+
+        # Ensure user directory exists
+        user_dir = os.path.join(TMP_DIR, str(session_hash))
+        os.makedirs(user_dir, exist_ok=True)
+        print(f"[text_to_3d - DEBUG MODE] User directory: {user_dir}")
+
+        # --- Generation Pipeline ---
         print("[text_to_3d - DEBUG MODE] Running Trellis pipeline...")
-        # Add more specific pipeline settings if needed based on Trellis docs
         outputs = pipeline.run(
             prompt=prompt,
             seed=seed,
-            formats=["gaussian", "mesh"], # Ensure both are generated
+            formats=["gaussian", "mesh"],
             sparse_structure_sampler_params={
-                "steps": int(ss_sampling_steps), # Ensure steps are int
+                "steps": int(ss_sampling_steps),
                 "cfg_strength": float(ss_guidance_strength),
             },
             slat_sampler_params={
-                "steps": int(slat_sampling_steps), # Ensure steps are int
+                "steps": int(slat_sampling_steps),
                 "cfg_strength": float(slat_guidance_strength),
             },
-            # device='cuda' # Explicitly specify device if needed
         )
         print("[text_to_3d - DEBUG MODE] Pipeline run completed.")
-    except Exception as e:
-        print(f"❌ [text_to_3d - DEBUG MODE] Pipeline error: {e}", file=sys.stderr)
-        traceback.print_exc()
-        raise gr.Error(f"Trellis pipeline failed during generation: {e}") # More specific error
 
-    # --- Create Serializable State Dictionary ---
-    try:
+        # --- Create Serializable State Dictionary ---
         state_dict = pack_state(outputs['gaussian'][0], outputs['mesh'][0])
+
     except Exception as e:
-        print(f"❌ [text_to_3d - DEBUG MODE] pack_state error: {e}", file=sys.stderr)
+        print(f"❌ [text_to_3d - DEBUG MODE] Error during generation or packing: {e}", file=sys.stderr)
         traceback.print_exc()
-        raise gr.Error(f"Failed to pack state after generation: {e}")
+        # Raise a Gradio error to send failure message back to client if possible
+        raise gr.Error(f"Core generation failed: {e}")
 
     # --- Render Video Preview (TEMPORARILY DISABLED FOR DEBUGGING) ---
-    video_path = None # Explicitly set path to None for this debug version
+    video_path = None
     print("[text_to_3d - DEBUG MODE] Skipping video rendering.")
-    # --- Original Video Code Block Start (Keep commented for now) ---
-    # try:
-    #     print("[text_to_3d] Rendering video preview...")
-    #     video = render_utils.render_video(outputs['gaussian'][0], num_frames=120)['color']
-    #     video_geo = render_utils.render_video(outputs['mesh'][0], num_frames=120)['normal']
-    #     # Ensure video frames are uint8
-    #     video = [np.concatenate([v.astype(np.uint8), vg.astype(np.uint8)], axis=1) for v, vg in zip(video, video_geo)]
-    #     video_path_tmp = os.path.join(user_dir, 'sample.mp4') # Use temp name
-    #     imageio.mimsave(video_path_tmp, video, fps=15, quality=8) # Added quality setting
-    #     print(f"[text_to_3d] Video saved to: {video_path_tmp}")
-    #     video_path = video_path_tmp # Assign if successful
-    # except Exception as e:
-    #     print(f"❌ [text_to_3d] Video rendering/saving error: {e}", file=sys.stderr)
-    #     traceback.print_exc()
-    #     # Still return state_dict, but maybe signal video error? Return None for path.
-    #     video_path = None # Indicate video failure
-    # --- Original Video Code Block End ---
+    # --- Original Video Code Block (Keep commented) ---
+    # ... (video code commented out) ...
 
     # --- Cleanup and Return ---
     if torch.cuda.is_available():
@@ -243,15 +229,16 @@ def text_to_3d(
 
     # --- Return Serializable Dictionary and None Video Path ---
     print("[text_to_3d - DEBUG MODE] Returning state dictionary and None video path.")
-    # Ensure state_dict is not None before returning
     if state_dict is None:
-         raise gr.Error("Failed to create state dictionary.")
+         # This case should ideally be caught by the exception handling above
+         print("Error: state_dict is None before return, generation likely failed.", file=sys.stderr)
+         raise gr.Error("State dictionary creation failed.")
     return state_dict, video_path
 
 
-@spaces.GPU(duration=120) # Increased duration slightly
+@spaces.GPU(duration=120)
 def extract_glb(
-    state_dict: dict, # <-- Accepts the dictionary directly
+    state_dict: dict,
     mesh_simplify: float,
     texture_size: int,
     req: gr.Request,
@@ -260,31 +247,27 @@ def extract_glb(
     Extracts a GLB file from the provided 3D model state dictionary.
     """
     print(f"[extract_glb] Received request. Simplify: {mesh_simplify}, Texture Size: {texture_size}")
-    session_hash = req.session_hash
-    if not session_hash:
-        session_hash = f"no_session_{np.random.randint(10000, 99999)}"
-        print(f"Warning: No session_hash in extract_glb request, using temporary ID: {session_hash}")
+    user_dir = None # Initialize
+    glb_path = None # Initialize
+    try:
+        session_hash = req.session_hash
+        if not session_hash:
+            session_hash = f"no_session_{np.random.randint(10000, 99999)}"
+            print(f"Warning: No session_hash in extract_glb request, using temporary ID: {session_hash}")
 
-    if not isinstance(state_dict, dict):
-        print("❌ [extract_glb] Error: Invalid state_dict received (not a dictionary).")
-        raise gr.Error("Invalid state data received. Please generate the model first.")
+        if not isinstance(state_dict, dict):
+            print("❌ [extract_glb] Error: Invalid state_dict received (not a dictionary).")
+            raise gr.Error("Invalid state data received. Please generate the model first.")
 
-    user_dir = os.path.join(TMP_DIR, str(session_hash))
-    os.makedirs(user_dir, exist_ok=True) # Ensure it exists
-    print(f"[extract_glb] User directory: {user_dir}")
+        user_dir = os.path.join(TMP_DIR, str(session_hash))
+        os.makedirs(user_dir, exist_ok=True)
+        print(f"[extract_glb] User directory: {user_dir}")
 
-    # --- Unpack state from the dictionary ---
-    try:
+        # --- Unpack state from the dictionary ---
         gs, mesh = unpack_state(state_dict)
-    except Exception as e:
-        print(f"❌ [extract_glb] unpack_state error: {e}", file=sys.stderr)
-        traceback.print_exc()
-        raise gr.Error(f"Failed to unpack state during GLB extraction: {e}")
 
-    # --- Postprocessing and Export ---
-    try:
+        # --- Postprocessing and Export ---
         print("[extract_glb] Converting to GLB...")
-        # Ensure parameters have correct types
         simplify_factor = float(mesh_simplify)
         tex_size = int(texture_size)
         glb = postprocessing_utils.to_glb(gs, mesh, simplify=simplify_factor, texture_size=tex_size, verbose=True)
@@ -292,77 +275,77 @@ def extract_glb(
         print(f"[extract_glb] Exporting GLB to: {glb_path}")
         glb.export(glb_path)
         print("[extract_glb] GLB exported successfully.")
+
     except Exception as e:
-        print(f"❌ [extract_glb] GLB conversion/export error: {e}", file=sys.stderr)
+        print(f"❌ [extract_glb] Error during GLB extraction: {e}", file=sys.stderr)
         traceback.print_exc()
-        raise gr.Error(f"Failed to extract GLB: {e}")
+        raise gr.Error(f"Failed to extract GLB: {e}") # Propagate error
 
     # --- Cleanup and Return ---
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
         print("[extract_glb] Cleared CUDA cache.")
 
-    # Return path twice for both Model3D and DownloadButton components
     print("[extract_glb] Returning GLB path.")
-    # Ensure path is returned, even if export failed somehow (though error should raise first)
+    if glb_path is None:
+         print("Error: glb_path is None before return, extraction likely failed.", file=sys.stderr)
+         raise gr.Error("GLB path generation failed.")
     return glb_path, glb_path
 
 
 @spaces.GPU
 def extract_gaussian(
-    state_dict: dict, # <-- Accepts the dictionary directly
+    state_dict: dict,
     req: gr.Request
 ) -> Tuple[str, str]:
     """
     Extracts a PLY (Gaussian) file from the provided 3D model state dictionary.
     """
     print("[extract_gaussian] Received request.")
-    session_hash = req.session_hash
-    if not session_hash:
-        session_hash = f"no_session_{np.random.randint(10000, 99999)}"
-        print(f"Warning: No session_hash in extract_gaussian request, using temporary ID: {session_hash}")
+    user_dir = None # Initialize
+    gaussian_path = None # Initialize
+    try:
+        session_hash = req.session_hash
+        if not session_hash:
+            session_hash = f"no_session_{np.random.randint(10000, 99999)}"
+            print(f"Warning: No session_hash in extract_gaussian request, using temporary ID: {session_hash}")
 
-    if not isinstance(state_dict, dict):
-        print("❌ [extract_gaussian] Error: Invalid state_dict received (not a dictionary).")
-        raise gr.Error("Invalid state data received. Please generate the model first.")
+        if not isinstance(state_dict, dict):
+            print("❌ [extract_gaussian] Error: Invalid state_dict received (not a dictionary).")
+            raise gr.Error("Invalid state data received. Please generate the model first.")
 
-    user_dir = os.path.join(TMP_DIR, str(session_hash))
-    os.makedirs(user_dir, exist_ok=True) # Ensure it exists
-    print(f"[extract_gaussian] User directory: {user_dir}")
+        user_dir = os.path.join(TMP_DIR, str(session_hash))
+        os.makedirs(user_dir, exist_ok=True)
+        print(f"[extract_gaussian] User directory: {user_dir}")
 
-    # --- Unpack state from the dictionary ---
-    try:
-        gs, _ = unpack_state(state_dict) # Only need Gaussian part
-    except Exception as e:
-        print(f"❌ [extract_gaussian] unpack_state error: {e}", file=sys.stderr)
-        traceback.print_exc()
-        raise gr.Error(f"Failed to unpack state during Gaussian extraction: {e}")
+        # --- Unpack state from the dictionary ---
+        gs, _ = unpack_state(state_dict)
 
-    # --- Export PLY ---
-    try:
+        # --- Export PLY ---
         gaussian_path = os.path.join(user_dir, 'sample.ply')
         print(f"[extract_gaussian] Saving PLY to: {gaussian_path}")
         gs.save_ply(gaussian_path)
         print("[extract_gaussian] PLY saved successfully.")
+
     except Exception as e:
-        print(f"❌ [extract_gaussian] PLY saving error: {e}", file=sys.stderr)
+        print(f"❌ [extract_gaussian] Error during Gaussian extraction: {e}", file=sys.stderr)
         traceback.print_exc()
-        raise gr.Error(f"Failed to extract Gaussian PLY: {e}")
+        raise gr.Error(f"Failed to extract Gaussian PLY: {e}") # Propagate error
 
     # --- Cleanup and Return ---
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
         print("[extract_gaussian] Cleared CUDA cache.")
 
-    # Return path twice for both Model3D and DownloadButton components
     print("[extract_gaussian] Returning PLY path.")
-    # Ensure path is returned
+    if gaussian_path is None:
+         print("Error: gaussian_path is None before return, extraction likely failed.", file=sys.stderr)
+         raise gr.Error("Gaussian PLY path generation failed.")
     return gaussian_path, gaussian_path
 
 
 # --- Gradio UI Definition ---
 print("Setting up Gradio Blocks interface...")
-# Define the interface layout
 with gr.Blocks(delete_cache=(600, 600), title="TRELLIS Text-to-3D") as demo:
     gr.Markdown("""
     # Text to 3D Asset with [TRELLIS](https://trellis3d.github.io/)
@@ -373,7 +356,6 @@ with gr.Blocks(delete_cache=(600, 600), title="TRELLIS Text-to-3D") as demo:
     """)
 
     # --- State Buffer ---
-    # This hidden component holds the dictionary linking generation and extraction.
     output_buf = gr.State()
 
     with gr.Row():
@@ -394,7 +376,7 @@ with gr.Blocks(delete_cache=(600, 600), title="TRELLIS Text-to-3D") as demo:
 
             generate_btn = gr.Button("Generate 3D Preview", variant="primary")
 
-            with gr.Accordion(label="GLB Extraction Settings", open=True): # Open by default
+            with gr.Accordion(label="GLB Extraction Settings", open=True):
                 mesh_simplify = gr.Slider(0.9, 0.99, label="Simplify Factor", value=0.95, step=0.01, info="Higher value = less simplification (more polys)")
                 texture_size = gr.Slider(512, 2048, label="Texture Size (pixels)", value=1024, step=512, info="Size of the generated texture map")
 
@@ -408,7 +390,7 @@ with gr.Blocks(delete_cache=(600, 600), title="TRELLIS Text-to-3D") as demo:
         with gr.Column(scale=1): # Output column
             # Video component remains for layout but won't show anything in this debug version
             video_output = gr.Video(label="Generated 3D Preview (DISABLED FOR DEBUG)", autoplay=False, loop=False, value=None, height=350)
-            model_output = gr.Model3D(label="Extracted Model Preview", height=350, clear_color=[0.95, 0.95, 0.95, 1.0]) # Light background
+            model_output = gr.Model3D(label="Extracted Model Preview", height=350, clear_color=[0.95, 0.95, 0.95, 1.0])
 
             with gr.Row():
                 download_glb = gr.DownloadButton(label="Download GLB", interactive=False)
@@ -418,8 +400,10 @@ with gr.Blocks(delete_cache=(600, 600), title="TRELLIS Text-to-3D") as demo:
     print("Defining Gradio event handlers...")
 
     # Handle session start/end
+    # demo.load() is valid with inputs=None, outputs=None (though default)
     demo.load(start_session, inputs=None, outputs=None)
-    demo.unload(end_session, inputs=None, outputs=None)
+    # >>> FIX: demo.unload() does NOT take inputs/outputs arguments <<<
+    demo.unload(end_session) # Removed inputs/outputs kwargs
 
     # --- Generate Button Click Flow ---
     generate_event = generate_btn.click(
@@ -430,18 +414,16 @@ with gr.Blocks(delete_cache=(600, 600), title="TRELLIS Text-to-3D") as demo:
     ).then(
         text_to_3d,
         inputs=[text_prompt, seed, ss_guidance_strength, ss_sampling_steps, slat_guidance_strength, slat_sampling_steps],
-        # Output state_dict to buffer, output None to video component
-        outputs=[output_buf, video_output],
+        outputs=[output_buf, video_output], # state_dict -> output_buf, None -> video_output
         api_name="text_to_3d"
     ).then(
-        # Function to update button interactivity after generation attempt
         lambda: (
             gr.Button(interactive=True),
             gr.Button(interactive=True),
             gr.DownloadButton(interactive=False),
             gr.DownloadButton(interactive=False)
         ),
-        inputs=None, # No inputs needed for the lambda
+        inputs=None,
         outputs=[extract_glb_btn, extract_gs_btn, download_glb, download_gs],
     )
 
@@ -475,7 +457,6 @@ with gr.Blocks(delete_cache=(600, 600), title="TRELLIS Text-to-3D") as demo:
         inputs=None,
         outputs=[download_glb, download_gs]
     )
-    # Also disable buttons if the (currently disabled) video output is cleared
     video_output.clear(
          lambda: (
             gr.Button(interactive=False),
@@ -491,18 +472,15 @@ with gr.Blocks(delete_cache=(600, 600), title="TRELLIS Text-to-3D") as demo:
 
 
 # --- Launch the Gradio app ---
-# Main execution block
 if __name__ == "__main__":
     print("Loading Trellis pipeline...")
     pipeline_loaded = False
+    pipeline = None # Initialize
     try:
-        # Ensure model/variant matches requirements, use revision if needed
         pipeline = TrellisTextTo3DPipeline.from_pretrained(
             "JeffreyXiang/TRELLIS-text-xlarge",
-            # revision="main", # Specify if needed
-            torch_dtype=torch.float16 # Use float16 if GPU supports it for less memory
+            torch_dtype=torch.float16 # Use float16 if GPU supports it
         )
-        # Move to GPU if available
         if torch.cuda.is_available():
             pipeline = pipeline.to("cuda")
             print("✅ Trellis pipeline loaded successfully to GPU.")
@@ -513,23 +491,20 @@ if __name__ == "__main__":
     except Exception as e:
         print(f"❌ Failed to load Trellis pipeline: {e}", file=sys.stderr)
         traceback.print_exc()
-        # Exit if pipeline is critical for the app to run
         print("❌ Exiting due to pipeline load failure.")
-        sys.exit(1) # Exit if pipeline fails
+        sys.exit(1)
 
     if pipeline_loaded:
         print("Launching Gradio demo...")
-        # Set share=True if you need a public link (e.g., for testing from outside local network)
-        # Set server_name="0.0.0.0" to allow access from local network IP
-        # Increased concurrency_limit and timeout for queue might help
+        # Consider increasing queue timeout if tasks are long
         demo.queue(
-             # default_concurrency_limit=5, # Adjust based on expected load and space resources
-             # api_open=True # Keep API accessible
+             # default_concurrency_limit=2, # Limit concurrency if resource issues suspected
+             # status_update_rate='auto'
         ).launch(
-            # server_name="0.0.0.0", # Make accessible on local network
-            # share=False, # Set to True for public link if needed
-            debug=True, # Enable Gradio debug mode for more detailed logs
-            # prevent_thread_lock=True # May help with async issues in some cases
+            # server_name="0.0.0.0", # Allows access from local network
+            # share=False, # Set True for public link (careful with resources)
+            debug=True, # Enable Gradio/FastAPI debug logs
+            # prevent_thread_lock=True # Might help sometimes
         )
         print("Gradio demo launched.")
     else: