Logging

app.py

@@ -13,6 +13,10 @@ from trellis.pipelines import TrellisImageTo3DPipeline
 from trellis.representations import Gaussian, MeshExtractResult
 from trellis.utils import render_utils, postprocessing_utils
 import pydantic
+import logging
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - HF_SPACE - %(levelname)s - %(message)s')
+
 print(pydantic.__version__)
 
 MAX_SEED = np.iinfo(np.int32).max
@@ -20,15 +24,29 @@ TMP_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'tmp')
 os.makedirs(TMP_DIR, exist_ok=True)
 
 def start_session(req: gr.Request):
-    user_dir = os.path.join(TMP_DIR, str(req.session_hash))
+    session_hash = str(req.session_hash)
+    user_dir = os.path.join(TMP_DIR, session_hash)
+    logging.info(f"START SESSION: Creando directorio para la sesión {session_hash} en {user_dir}")
     os.makedirs(user_dir, exist_ok=True)
     
 def end_session(req: gr.Request):
-    user_dir = os.path.join(TMP_DIR, str(req.session_hash))
-    shutil.rmtree(user_dir)
+    session_hash = str(req.session_hash)
+    user_dir = os.path.join(TMP_DIR, session_hash)
+    logging.info(f"END SESSION: Intentando eliminar el directorio de la sesión {session_hash} en {user_dir}")
+    # Hacemos la eliminación más robusta.
+    if os.path.exists(user_dir):
+        try:
+            shutil.rmtree(user_dir)
+            logging.info(f"Directorio de la sesión {session_hash} eliminado correctamente.")
+        except Exception as e:
+            logging.error(f"Error al eliminar el directorio de la sesión {session_hash}: {e}")
+    else:
+        logging.warning(f"El directorio de la sesión {session_hash} no fue encontrado al intentar eliminarlo. Es posible que ya haya sido limpiado.")
 
 def preprocess_image(image: Image.Image) -> Image.Image:
+    logging.info("Preprocesando imagen...")
     processed_image = pipeline.preprocess_image(image)
+    logging.info("Imagen preprocesada correctamente.")
     return processed_image
 
 def pack_state(gs: Gaussian, mesh: MeshExtractResult) -> dict:
@@ -70,7 +88,9 @@ def unpack_state(state: dict) -> Tuple[Gaussian, edict, str]:
     return gs, mesh
 
 def get_seed(randomize_seed: bool, seed: int) -> int:
-    return np.random.randint(0, MAX_SEED) if randomize_seed else seed
+    new_seed = np.random.randint(0, MAX_SEED) if randomize_seed else seed
+    logging.info(f"Usando seed: {new_seed}")
+    return new_seed
 
 @spaces.GPU
 def image_to_3d(
@@ -82,7 +102,10 @@ def image_to_3d(
     slat_sampling_steps: int,
     req: gr.Request,
 ) -> Tuple[dict, str]:
-    user_dir = os.path.join(TMP_DIR, str(req.session_hash))
+    session_hash = str(req.session_hash)
+    logging.info(f"[{session_hash}] Iniciando image_to_3d...")
+    user_dir = os.path.join(TMP_DIR, session_hash)
+
     outputs = pipeline.run(
         image,
         seed=seed,
@@ -98,16 +121,17 @@ def image_to_3d(
         },
     )
    
+    logging.info(f"[{session_hash}] Generación del modelo completada. Renderizando video...")
     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']
-    
-    # Solo usamos el video de color, eliminamos la concatenación
+
     video = video
     
     video_path = os.path.join(user_dir, 'sample.mp4')
     imageio.mimsave(video_path, video, fps=15)
     state = pack_state(outputs['gaussian'][0], outputs['mesh'][0])
     torch.cuda.empty_cache()
+    logging.info(f"[{session_hash}] Video renderizado y estado empaquetado. Devolviendo: {video_path}")
     return state, video_path
 
 @spaces.GPU(duration=90)
@@ -117,12 +141,17 @@ def extract_glb(
     texture_size: int,
     req: gr.Request,
 ) -> Tuple[str, str]:
-    user_dir = os.path.join(TMP_DIR, str(req.session_hash))
+    session_hash = str(req.session_hash)
+    logging.info(f"[{session_hash}] Iniciando extract_glb...")
+    user_dir = os.path.join(TMP_DIR, 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')
     glb.export(glb_path)
+    
     torch.cuda.empty_cache()
+    logging.info(f"[{session_hash}] GLB extraído. Devolviendo: {glb_path}")
     return glb_path, glb_path
 
 def split_image(image: Image.Image) -> List[Image.Image]:
@@ -183,7 +212,6 @@ with gr.Blocks(delete_cache=(600, 600)) as demo:
             
             extract_glb_btn = gr.Button("Export GLB", interactive=False, size="lg")
 
-        # Right column (Outputs)
         with gr.Column(scale=3, min_width=600):
             with gr.Group():
                 video_output = gr.Video(