just uplaod file to server first then process

app.py

@@ -16,7 +16,6 @@ import requests
 import base64
 import io
 import tempfile
-import traceback
 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)
@@ -142,167 +141,144 @@ def generate_model_from_images_and_upload(
     model_description: str,
     req: gr.Request
 ) -> str:
-    try:
-        user_dir = os.path.join(TMP_DIR, str(req.session_hash))
-        os.makedirs(user_dir, exist_ok=True)
-
-        print(f"Python DEBUG: Raw image_inputs (as received by function): {image_inputs}")
-        print(f"Python DEBUG: Type of image_inputs: {type(image_inputs)}")
-        if isinstance(image_inputs, list):
-            print(f"Python DEBUG: Length of image_inputs list: {len(image_inputs)}")
-            if len(image_inputs) > 0 and isinstance(image_inputs[0], dict):
-                print(f"Python DEBUG: First element of image_inputs (should be a dict): {image_inputs[0]}")
-                print(f"Python DEBUG: Type of first element: {type(image_inputs[0])}")
-        print(f"Python DEBUG: Received input_type from Node.js: '{input_type}'")
+    user_dir = os.path.join(TMP_DIR, str(req.session_hash))
+    os.makedirs(user_dir, exist_ok=True)
+
+    # --- DEBUG LOGS ---
+    print(f"Python DEBUG: Raw image_inputs (as received by function): {image_inputs}")
+    print(f"Python DEBUG: Type of image_inputs: {type(image_inputs)}")
+    if isinstance(image_inputs, list):
+        print(f"Python DEBUG: Length of image_inputs list: {len(image_inputs)}")
+        if len(image_inputs) > 0 and isinstance(image_inputs[0], dict):
+            print(f"Python DEBUG: First element of image_inputs (should be a dict): {image_inputs[0]}")
+            print(f"Python DEBUG: Type of first element: {type(image_inputs[0])}")
+    print(f"Python DEBUG: Received input_type from Node.js: '{input_type}'") # Should always be 'url' now
+    # --- END DEBUG LOGS ---
+    
+    pil_images = []
+    image_basenames_for_prompt = []
+
+    for i, file_data_obj in enumerate(image_inputs): # file_data_obj is one dict from the list
+        img_to_open_path = None
+        current_image_name = file_data_obj.get('name', f"image_{i}.png") 
+
+        print(f"Python DEBUG: Processing item {i}: {file_data_obj}, current_image_name: {current_image_name}")
+
+        # For URLs (which is now always the case from Node.js), 
+        # Gradio should have downloaded the image and put its local path in file_data_obj.get('path')
+        img_to_open_path = file_data_obj.get('path')
+        if not img_to_open_path:
+            print(f"Error: 'path' was missing in item {i}: {file_data_obj}. Skipping.")
+            continue 
+        print(f"Python INFO: Using Gradio-provided path for '{current_image_name}': {img_to_open_path}")
+
+        # Now, process the image using img_to_open_path
+        try:
+            print(f"Python INFO: Opening image from path: {img_to_open_path} (intended name for prompt: {current_image_name})")
+            img = Image.open(img_to_open_path)
+            
+            image_basenames_for_prompt.append(os.path.splitext(current_image_name)[0] or f"image_{i}")
+
+            if img.mode == 'RGBA' or img.mode == 'P':
+                print(f"Converting image '{current_image_name}' from {img.mode} to RGB")
+                img = img.convert('RGB')
+
+            processed_img = pipeline.preprocess_image(img)
+            pil_images.append(processed_img)
+            print(f"Image '{current_image_name}' (item {i+1}) processed successfully and added to list.")
+
+        except Exception as e_img_proc:
+            print(f"Error opening or processing image at '{img_to_open_path}' (item {i}, name: '{current_image_name}'): {e_img_proc}")
+            import traceback
+            traceback.print_exc()
+            # Continue to next image if one fails
         
-        pil_images = []
-        image_basenames_for_prompt = []
-
-        for i, file_data_obj in enumerate(image_inputs):
-            img_to_open_path = None
-            current_image_name = file_data_obj.get('name', f"image_{i}.png") 
-            print(f"Python DEBUG: Processing item {i}: {file_data_obj}, current_image_name: {current_image_name}")
-
-            if input_type == 'url':
-                img_to_open_path = file_data_obj.get('path')
-                if not img_to_open_path:
-                    print(f"Error: For 'url' input_type, 'path' was missing in item {i}: {file_data_obj}")
-                    continue
-                print(f"Python INFO: 'url' type. Using Gradio-provided path for '{current_image_name}': {img_to_open_path}")
-            elif input_type == 'base64':
-                base64_data_uri = file_data_obj.get('data_uri')
-                if not base64_data_uri or not isinstance(base64_data_uri, str) or not base64_data_uri.startswith('data:image'):
-                    print(f"Error: For 'base64' input_type, 'data_uri' was missing or invalid in item {i}: {file_data_obj}")
-                    continue
-                try:
-                    print(f"Python INFO: 'base64' type. Decoding data_uri for '{current_image_name}'...")
-                    header, encoded_data = base64_data_uri.split(',', 1)
-                    image_data_bytes = base64.b64decode(encoded_data)
-                    file_extension = ".png"
-                    try:
-                        parsed_extension = os.path.splitext(current_image_name)[1]
-                        if parsed_extension:
-                            file_extension = parsed_extension
-                        elif '/' in header and ';' in header:
-                            mime_subtype = header.split('/')[1].split(';')[0]
-                            if mime_subtype:
-                                file_extension = "." + mime_subtype
-                    except Exception as e_ext:
-                        print(f"Python WARNING: Could not parse precise extension for '{current_image_name}' from header/name: {e_ext}. Using {file_extension}.")
-                    with tempfile.NamedTemporaryFile(delete=False, suffix=file_extension, dir=TMP_DIR) as tmp_file:
-                        tmp_file.write(image_data_bytes)
-                        img_to_open_path = tmp_file.name
-                    print(f"Python INFO: Decoded base64 for '{current_image_name}' and saved to temporary file: {img_to_open_path}")
-                except Exception as e_b64:
-                    print(f"Error processing base64 image data for item {i} ('{current_image_name}'): {e_b64}")
-                    traceback.print_exc()
-                    continue
-            else:
-                print(f"Error: Unrecognized input_type '{input_type}' for item {i}. Skipping.")
-                continue
-
-            if not img_to_open_path:
-                print(f"Error: No valid image path could be derived for item {i} (name: '{current_image_name}', type: '{input_type}'). Skipping.")
-                continue
-            try:
-                print(f"Python INFO: Opening image from path: {img_to_open_path} (intended name for prompt: {current_image_name})")
-                img = Image.open(img_to_open_path)
-                image_basenames_for_prompt.append(os.path.splitext(current_image_name)[0] or f"image_{i}")
-                if img.mode == 'RGBA' or img.mode == 'P':
-                    print(f"Converting image '{current_image_name}' from {img.mode} to RGB")
-                    img = img.convert('RGB')
-                processed_img = pipeline.preprocess_image(img)
-                pil_images.append(processed_img)
-                print(f"Image '{current_image_name}' (item {i+1}) processed successfully and added to list.")
-            except Exception as e_img_proc:
-                print(f"Error opening or processing image at '{img_to_open_path}' (item {i}, name: '{current_image_name}'): {e_img_proc}")
-                traceback.print_exc()
-            finally:
-                if input_type == 'base64' and img_to_open_path and os.path.exists(img_to_open_path):
-                    if TMP_DIR in os.path.abspath(img_to_open_path):
-                        try:
-                            os.remove(img_to_open_path)
-                            print(f"Python INFO: Removed temporary base64 file: {img_to_open_path}")
-                        except Exception as e_remove:
-                            print(f"Python WARNING: Could not remove temp file {img_to_open_path}: {e_remove}")
-                    else:
-                        print(f"Python WARNING: Skipped deletion of temp file as it's not in TMP_DIR (or was a Gradio-managed URL path): {img_to_open_path}")
-
-        if not pil_images:
-            print("Python ERROR: No valid images could be processed from the input list.")
-            raise gr.Error("No valid images could be processed.")
-        print(f"Python INFO: Total PIL images ready for pipeline: {len(pil_images)}")
-        print("Running multi-image pipeline...")
-        outputs = pipeline.run_multi_image(
-            pil_images,
+        # No finally block needed here anymore for deleting temp base64 files
+
+    if not pil_images:
+        print("Error: No images could be processed from the input. Aborting generation.")
+        raise gr.Error("Failed to process any input images.")
+
+    print(f"Python INFO: Total images processed for pipeline: {len(pil_images)}")
+    effective_model_description = model_description
+    if not effective_model_description and image_basenames_for_prompt:
+        effective_model_description = "_prompted_by_" + "_and_".join(image_basenames_for_prompt)
+        effective_model_description = effective_model_description[:100] # Keep it reasonably short
+    elif not effective_model_description:
+        effective_model_description = "ImageGenModel"
+    print(f"Python INFO: Using model_description for upload: {effective_model_description}")
+
+    # Generate 3D model using the Trellis image pipeline
+    try:
+        print(f"Python INFO: Calling internal image_to_3d with {len(pil_images)} images.")
+        # The image_to_3d function expects a list of tuples (PIL.Image, str_filename_or_label)
+        # We have processed_img in pil_images which are already PIL.Image objects after pipeline.preprocess_image
+        # We can use the current_image_name (or derived basenames) as the string part if needed by image_to_3d,
+        # but Trellis's run_multi_image takes a list of PIL images directly.
+        # Let's adapt multiimages for image_to_3d to be List[Tuple[Image.Image, str]]
+        multiimages_for_pipeline = []
+        for idx, p_img in enumerate(pil_images):
+            # Create a simple label for each image for the tuple structure
+            label = image_basenames_for_prompt[idx] if idx < len(image_basenames_for_prompt) else f"image_{idx}"
+            multiimages_for_pipeline.append((p_img, label)) # p_img here is already the *processed* image tensor.
+                                                        # image_to_3d will take image[0] from this list.
+                                                        # This might need adjustment if image_to_3d expects raw PIL Images.
+                                                        # Re-checking Trellis: pipeline.run_multi_image takes List[Image.Image]
+                                                        # and preprocesses them internally if preprocess_image=True (default).
+                                                        # Since we pre-process above, we should pass preprocess_image=False if run_multi_image allows.
+                                                        # The `image_to_3d` in this file is a wrapper for run_multi_image.
+                                                        # It passes `preprocess_image=False`.
+                                                        # So, `pil_images` containing already processed images is what `image_to_3d` expects for `[image[0] for image in multiimages]`
+
+        state, _ = image_to_3d(
+            multiimages=[(img, name) for img, name in zip(pil_images, image_basenames_for_prompt)], # Pass list of (processed_PIL_image, name_str)
             seed=seed_val,
-            formats=["gaussian", "mesh"],
-            preprocess_image=False, 
-            sparse_structure_sampler_params={
-                "steps": ss_sampling_steps_val,
-                "cfg_strength": ss_guidance_strength_val,
-            },
-            slat_sampler_params={
-                "steps": slat_sampling_steps_val,
-                "cfg_strength": slat_guidance_strength_val,
-            },
-            mode=multiimage_algo_val,
+            ss_guidance_strength=ss_guidance_strength_val,
+            ss_sampling_steps=ss_sampling_steps_val,
+            slat_guidance_strength=slat_guidance_strength_val,
+            slat_sampling_steps=slat_sampling_steps_val,
+            multiimage_algo=multiimage_algo_val,
+            req=req
+        )
+        if state is None:
+            print("Error: Internal image_to_3d returned None state!")
+            raise ValueError("Internal image_to_3d failed to return state")
+        print(f"Python INFO: Internal image_to_3d completed. State type: {type(state)}")
+
+        print("Python INFO: Calling internal extract_glb...")
+        glb_path, _ = extract_glb(
+            state, mesh_simplify_val, texture_size_val, req
         )
-        print("Multi-image pipeline completed.")
-        gs_result = outputs['gaussian'][0]
-        mesh_result = outputs['mesh'][0]
-        print(f"Extracting GLB with simplify: {mesh_simplify_val}, texture_size: {texture_size_val}")
-        glb_data = postprocessing_utils.to_glb(gs_result, mesh_result, simplify=mesh_simplify_val, texture_size=texture_size_val, verbose=False)
-        temp_glb_filename = 'temp_output_image_model.glb'
-        temp_glb_path = os.path.join(user_dir, temp_glb_filename)
-        print(f"Exporting GLB to temporary path: {temp_glb_path}")
-        glb_data.export(temp_glb_path)
-        torch.cuda.empty_cache()
-        print("CUDA cache cleared.")
-        print(f"Uploading GLB from {temp_glb_path} to {NODE_SERVER_UPLOAD_URL}")
+        if glb_path is None or not os.path.isfile(glb_path):
+            print(f"Error: Internal extract_glb returned None or invalid path: {glb_path}")
+            raise FileNotFoundError(f"Generated GLB file not found at {glb_path}")
+        print(f"Python INFO: Internal extract_glb completed. GLB path: {glb_path}")
+
+        print(f"Python INFO: Uploading GLB from {glb_path} to {NODE_SERVER_UPLOAD_URL}")
         persistent_url = None
-        upload_prompt_name = model_description or "_".join(filter(None, image_basenames_for_prompt)) or "imagen_generated_model"
-        upload_prompt_name = "".join(c if c.isalnum() or c in ['_', '-'] else '_' for c in upload_prompt_name)[:50]
-        try:
-            with open(temp_glb_path, "rb") as f:
-                files = {"modelFile": (temp_glb_filename, f, "model/gltf-binary")}
-                payload = {
-                    "clientType": "imagen",
-                    "prompt": upload_prompt_name,
-                    "modelStage": "imagen_mesh"
-                }
-                print(f"Upload payload to Node.js: {payload}")
-                response = requests.post(NODE_SERVER_UPLOAD_URL, files=files, data=payload, timeout=120)
-                response.raise_for_status()
-                result = response.json()
-                persistent_url = result.get("persistentUrl")
-                if not persistent_url:
-                    print(f"No persistent URL in Node.js server response: {result}")
-                    raise ValueError("Upload successful, but no persistent URL returned from Node.js server")
-                print(f"Successfully uploaded to Node server. Persistent URL: {persistent_url}")
-        except requests.exceptions.RequestException as upload_err:
-            print(f"FAILED to upload GLB to Node server: {upload_err}")
-            if hasattr(upload_err, 'response') and upload_err.response is not None:
-                print(f"Node server response status: {upload_err.response.status_code}")
-                print(f"Node server response text: {upload_err.response.text}")
-            raise gr.Error(f"Failed to upload result to backend server: {upload_err}")
-        except Exception as e:
-            print(f"UNEXPECTED error during upload: {e}", exc_info=True)
-            raise gr.Error(f"Unexpected error during upload: {e}")
-        finally:
-            if os.path.exists(temp_glb_path):
-                print(f"Cleaning up temporary GLB: {temp_glb_path}")
-                os.remove(temp_glb_path)
-        if not persistent_url:
-            print("Failed to obtain a persistent URL for the generated model.")
-            raise gr.Error("Failed to obtain a persistent URL for the generated model.")
-        print(f"Returning persistent URL: {persistent_url}")
+        with open(glb_path, "rb") as f:
+            files = {"modelFile": (os.path.basename(glb_path), f, "model/gltf-binary")}
+            payload = {
+                "clientType": "imagen", 
+                "modelStage": "imagen_mesh",
+                "prompt": effective_model_description # Use the description here
+            }
+            print(f"Python INFO: Upload payload: {payload}")
+            response = requests.post(NODE_SERVER_UPLOAD_URL, files=files, data=payload)
+            response.raise_for_status() # Raise an exception for bad status codes
+            result = response.json()
+            persistent_url = result.get("persistentUrl")
+            if not persistent_url:
+                print(f"Error: No persistent URL in Node.js server response: {result}")
+                raise ValueError("Upload successful, but no persistent URL returned")
+        print(f"Python INFO: Successfully uploaded to Node server. Persistent URL: {persistent_url}")
         return persistent_url
 
-    except Exception as e_main:
-        print(f"TOP LEVEL PYTHON ERROR IN generate_model_from_images_and_upload: {e_main}")
+    except Exception as e:
+        print(f"ERROR in Image-to-3D pipeline: {e}")
+        import traceback
         traceback.print_exc()
-        raise gr.Error(f"A critical error occurred in the Python backend: {e_main}")
+        raise gr.Error(f"Image-to-3D pipeline failed: {e}")
 
 # Interfaz Gradio
 with gr.Blocks(delete_cache=(600, 600)) as demo: