Logging

app.py

@@ -12,22 +12,40 @@ from PIL import Image
 from trellis.pipelines import TrellisImageTo3DPipeline
 from trellis.representations import Gaussian, MeshExtractResult
 from trellis.utils import render_utils, postprocessing_utils
+
+import logging 
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - HF_SPACE_MULTIIMG - %(levelname)s - %(message)s')
+
 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)
 
-# Funciones auxiliares
 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}")
+    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_images(images: List[Tuple[Image.Image, str]]) -> List[Image.Image]:
+def preprocess_images(images: List[Tuple[Image.Image, str]], req: gr.Request) -> List[Image.Image]:
+    session_hash = str(req.session_hash)
+    logging.info(f"[{session_hash}] Preprocesando {len(images)} imágenes.")
     images = [image[0] for image in images]
     processed_images = [pipeline.preprocess_image(image) for image in images]
+    logging.info(f"[{session_hash}] Preprocesamiento completado.")
     return processed_images
 
 def pack_state(gs: Gaussian, mesh: MeshExtractResult) -> dict:
@@ -67,7 +85,9 @@ def unpack_state(state: dict) -> Tuple[Gaussian, edict]:
     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(
@@ -80,12 +100,15 @@ def image_to_3d(
     multiimage_algo: Literal["multidiffusion", "stochastic"],
     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 con {len(multiimages)} imágenes.")
+    user_dir = os.path.join(TMP_DIR, session_hash)
+
     outputs = pipeline.run_multi_image(
         [image[0] for image in multiimages],
         seed=seed,
         formats=["gaussian", "mesh"],
-        preprocess_image=False,
+        preprocess_image=False, 
         sparse_structure_sampler_params={
             "steps": ss_sampling_steps,
             "cfg_strength": ss_guidance_strength,
@@ -96,13 +119,17 @@ def image_to_3d(
         },
         mode=multiimage_algo,
     )
+    
+    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']
     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')
     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)
@@ -112,15 +139,19 @@ 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
 
-# Interfaz Gradio
 with gr.Blocks(delete_cache=(600, 600)) as demo:
     gr.Markdown("""
     # UTPL - Conversión de Multiples Imágenes a objetos 3D usando IA  
@@ -164,24 +195,26 @@ with gr.Blocks(delete_cache=(600, 600)) as demo:
 
     output_buf = gr.State()
 
-    # Manejadores
-    demo.load(start_session)
+    demo.load(start_session, inputs=None, outputs=None, api_name="start_session")
     demo.unload(end_session)
     
     multiimage_prompt.upload(
         preprocess_images,
         inputs=[multiimage_prompt],
         outputs=[multiimage_prompt],
+        api_name="preprocess_images"
     )
     
     generate_btn.click(
         get_seed,
         inputs=[randomize_seed, seed],
         outputs=[seed],
+        api_name="get_seed"
     ).then(
         image_to_3d,
         inputs=[multiimage_prompt, seed, ss_guidance_strength, ss_sampling_steps, slat_guidance_strength, slat_sampling_steps, multiimage_algo],
         outputs=[output_buf, video_output],
+        api_name="image_to_3d"
     ).then(
         lambda: gr.Button(interactive=True),
         outputs=[extract_glb_btn],
@@ -196,6 +229,7 @@ with gr.Blocks(delete_cache=(600, 600)) as demo:
         extract_glb,
         inputs=[output_buf, mesh_simplify, texture_size],
         outputs=[model_output, download_glb],
+        api_name="extract_glb"
     ).then(
         lambda: gr.Button(interactive=True),
         outputs=[download_glb],