revert back to without fast api

app.py

@@ -17,22 +17,11 @@ from trellis.utils import render_utils, postprocessing_utils
 import traceback
 import sys
 
-# --- Import the FastAPI integration module ---
-import trellis_fastAPI_integration
-import logging
 
 MAX_SEED = np.iinfo(np.int32).max
 TMP_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'tmp')
 os.makedirs(TMP_DIR, exist_ok=True)
 
-# --- Global Pipeline Variable ---
-pipeline = None
-
-# --- Logging Setup ---
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-logger.info("Trellis App: Script starting.")
 
 def start_session(req: gr.Request):
     user_dir = os.path.join(TMP_DIR, str(req.session_hash))
@@ -41,11 +30,7 @@ def start_session(req: gr.Request):
     
 def end_session(req: gr.Request):
     user_dir = os.path.join(TMP_DIR, str(req.session_hash))
-    try:
-        if os.path.exists(user_dir):
-             shutil.rmtree(user_dir)
-    except OSError as e:
-        logger.warning(f"Warning: Could not remove temp session dir {user_dir}: {e}")
+    shutil.rmtree(user_dir)
 
 
 def pack_state(gs: Gaussian, mesh: MeshExtractResult) -> dict:
@@ -65,7 +50,7 @@ def pack_state(gs: Gaussian, mesh: MeshExtractResult) -> dict:
     }
     
     
-def unpack_state(state: dict) -> Tuple[Gaussian, edict]:
+def unpack_state(state: dict) -> Tuple[Gaussian, edict, str]:
     gs = Gaussian(
         aabb=state['gaussian']['aabb'],
         sh_degree=state['gaussian']['sh_degree'],
@@ -107,7 +92,6 @@ def text_to_3d(
 ) -> Tuple[dict, str]:
     """
     Convert an text prompt to a 3D model.
-
     Args:
         prompt (str): The text prompt.
         seed (int): The random seed.
@@ -115,22 +99,11 @@ def text_to_3d(
         ss_sampling_steps (int): The number of sampling steps for sparse structure generation.
         slat_guidance_strength (float): The guidance strength for structured latent generation.
         slat_sampling_steps (int): The number of sampling steps for structured latent generation.
-
     Returns:
         dict: The information of the generated 3D model.
         str: The path to the video of the 3D model.
     """
-    # --- Determine user_dir robustly ---
-    session_hash_str = str(req.session_hash) if hasattr(req, 'session_hash') and req.session_hash else f"gradio_call_{np.random.randint(10000)}"
-    user_dir = os.path.join(TMP_DIR, session_hash_str)
-    os.makedirs(user_dir, exist_ok=True) # Ensure directory exists
-
-    # Use the global pipeline initialized later
-    if pipeline is None:
-        logger.error("Gradio Error: Pipeline not initialized")
-        # Handle error appropriately for Gradio - maybe return None or raise gr.Error?
-        return {}, None
-
+    user_dir = os.path.join(TMP_DIR, str(req.session_hash))
     outputs = pipeline.run(
         prompt,
         seed=seed,
@@ -148,11 +121,7 @@ def text_to_3d(
     video_geo = render_utils.render_video(outputs['mesh'][0], num_frames=120)['normal']
     video = [np.concatenate([video[i], video_geo[i]], axis=1) for i in range(len(video))]
     video_path = os.path.join(user_dir, 'sample.mp4')
-    try:
-        imageio.mimsave(video_path, video, fps=15) # Now the directory should exist
-    except FileNotFoundError:
-         logger.error(f"ERROR: Directory {user_dir} still not found before mimsave!", exc_info=True)
-         raise
+    imageio.mimsave(video_path, video, fps=15)
     state = pack_state(outputs['gaussian'][0], outputs['mesh'][0])
     torch.cuda.empty_cache()
     return state, video_path
@@ -167,28 +136,18 @@ def extract_glb(
 ) -> Tuple[str, str]:
     """
     Extract a GLB file from the 3D model.
-
     Args:
         state (dict): The state of the generated 3D model.
         mesh_simplify (float): The mesh simplification factor.
         texture_size (int): The texture resolution.
-
     Returns:
         str: The path to the extracted GLB file.
     """
-    # --- Determine user_dir robustly ---
-    session_hash_str = str(req.session_hash) if hasattr(req, 'session_hash') and req.session_hash else f"gradio_call_{np.random.randint(10000)}"
-    user_dir = os.path.join(TMP_DIR, session_hash_str)
-    os.makedirs(user_dir, exist_ok=True) # Ensure directory exists
-
+    user_dir = os.path.join(TMP_DIR, str(req.session_hash))
     gs, mesh = unpack_state(state)
     glb = postprocessing_utils.to_glb(gs, mesh, simplify=mesh_simplify, texture_size=texture_size, verbose=False)
     glb_path = os.path.join(user_dir, 'sample.glb')
-    try:
-        glb.export(glb_path) # Now the directory should exist
-    except FileNotFoundError:
-        logger.error(f"ERROR: Directory {user_dir} still not found before glb.export!", exc_info=True)
-        raise
+    glb.export(glb_path)
     torch.cuda.empty_cache()
     return glb_path, glb_path
 
@@ -197,30 +156,19 @@ def extract_glb(
 def extract_gaussian(state: dict, req: gr.Request) -> Tuple[str, str]:
     """
     Extract a Gaussian file from the 3D model.
-
     Args:
         state (dict): The state of the generated 3D model.
-
     Returns:
         str: The path to the extracted Gaussian file.
     """
-    # --- Determine user_dir robustly ---
-    session_hash_str = str(req.session_hash) if hasattr(req, 'session_hash') and req.session_hash else f"gradio_call_{np.random.randint(10000)}"
-    user_dir = os.path.join(TMP_DIR, session_hash_str)
-    os.makedirs(user_dir, exist_ok=True) # Ensure directory exists
-
+    user_dir = os.path.join(TMP_DIR, str(req.session_hash))
     gs, _ = unpack_state(state)
     gaussian_path = os.path.join(user_dir, 'sample.ply')
-    try:
-        gs.save_ply(gaussian_path) # Now the directory should exist
-    except FileNotFoundError:
-        logger.error(f"ERROR: Directory {user_dir} still not found before gs.save_ply!", exc_info=True)
-        raise
+    gs.save_ply(gaussian_path)
     torch.cuda.empty_cache()
     return gaussian_path, gaussian_path
 
 
-# --- Gradio Blocks Definition ---
 with gr.Blocks(delete_cache=(600, 600)) as demo:
     gr.Markdown("""
     ## Text to 3D Asset with [TRELLIS](https://trellis3d.github.io/)
@@ -313,41 +261,8 @@ with gr.Blocks(delete_cache=(600, 600)) as demo:
     )
     
 
-# Launch the Gradio app and FastAPI server
+# Launch the Gradio app
 if __name__ == "__main__":
-    logger.info("Trellis App: Initializing Trellis Pipeline...")
-    try:
-        # Make pipeline global so Gradio functions and API endpoint can access it
-        pipeline = TrellisTextTo3DPipeline.from_pretrained("JeffreyXiang/TRELLIS-text-xlarge")
-        pipeline.cuda()
-        logger.info("Trellis App: Trellis Pipeline Initialized successfully.")
-    except Exception as e:
-        logger.error(f"Trellis App: FATAL ERROR initializing pipeline: {e}", exc_info=True)
-        pipeline = None # Ensure pipeline is None if initialization failed
-        # Optionally exit if pipeline is critical
-        # import sys
-        # sys.exit("Pipeline initialization failed.")
-
-    # Start the background API server using the integration module only if pipeline loaded
-    if pipeline:
-        logger.info("Trellis App: Attempting to start FastAPI server thread...")
-        try:
-            api_thread = trellis_fastAPI_integration.start_api_thread(pipeline)
-            if api_thread and api_thread.is_alive():
-                 logger.info("Trellis App: FastAPI server thread started successfully (is_alive check passed).")
-            elif api_thread:
-                 logger.warning("Trellis App: FastAPI server thread was created but is not alive shortly after starting.")
-            else:
-                 logger.error("Trellis App: start_api_thread returned None, thread not created.")
-        except Exception as e:
-            logger.error(f"Trellis App: Error occurred during start_api_thread call: {e}", exc_info=True)
-    else:
-        logger.error("Trellis App: Skipping FastAPI server start because pipeline failed to initialize.")
-
-    # Launch the Gradio interface (blocking call)
-    logger.info("Trellis App: Launching Gradio Demo...")
-    try:
-        demo.launch()
-        logger.info("Trellis App: Gradio Demo launched.") # This might not be reached if launch blocks indefinitely
-    except Exception as e:
-        logger.error(f"Trellis App: Error launching Gradio demo: {e}", exc_info=True)
+    pipeline = TrellisTextTo3DPipeline.from_pretrained("JeffreyXiang/TRELLIS-text-xlarge")
+    pipeline.cuda()
+    demo.launch()