gallery fix

app/core/pipeline.py

@@ -222,8 +222,9 @@ class CreativePipeline:
                         data_blob_id = parts[0]
                         execution_id = parts[2] if len(parts) > 2 else None
 
-                        # Target directory
-                        images_dir = Path(__file__).parent.parent / "data" / "images"
+                        # Target directory - use the image output directory from environment or class instead of hardcoding
+                        # Use self.text_to_image.output_dir instead of hardcoded path
+                        images_dir = self.text_to_image.output_dir
 
                         # Get the existing metadata filename and use it for the image
                         metadata_filename = Path(image_metadata_path).name

app/ui/app.py

@@ -237,64 +237,111 @@ def main():
         with gr.Tab("Gallery"):
             # Function to update the image gallery
             def update_image_gallery():
-                images = list(images_path.glob("*.png")) + list(
-                    images_path.glob("*.jpg")
-                )
-                return sorted(
-                    [str(img) for img in images],
-                    key=lambda x: os.path.getmtime(x) if os.path.exists(x) else 0,
-                    reverse=True,
-                )
+                try:
+                    # Find all PNG and JPG images in the images directory
+                    images = list(images_path.glob("*.png")) + list(
+                        images_path.glob("*.jpg")
+                    )
+
+                    # Debug output to help diagnose issues
+                    logger.info(
+                        f"Found {len(images)} images in gallery directory: {images_path}"
+                    )
+                    for img in images[:5]:  # Log first 5 images for debugging
+                        logger.info(
+                            f"Image file: {img} (exists: {os.path.exists(img)})"
+                        )
+
+                    # Convert Path objects to strings for the gallery
+                    image_paths = sorted(
+                        [str(img) for img in images if os.path.exists(img)],
+                        key=lambda x: os.path.getmtime(x) if os.path.exists(x) else 0,
+                        reverse=True,
+                    )
+
+                    logger.info(
+                        f"Returning {len(image_paths)} valid images for gallery display"
+                    )
+                    return image_paths
+                except Exception as e:
+                    logger.error(f"Error updating image gallery: {e}")
+                    return []
 
             # Function to update the models gallery and return both the models list and model paths
             def update_models_gallery():
-                models = list(models_path.glob("*.glb")) + list(
-                    models_path.glob("*.gltf")
-                )
-                model_data = []
-                model_paths = []  # Store just the paths for easy access by index
-
-                for model_path in sorted(
-                    models,
-                    key=lambda x: os.path.getmtime(x) if os.path.exists(x) else 0,
-                    reverse=True,
-                ):
-                    # Try to load metadata file if available
-                    metadata_path = model_path.with_suffix(".json")
-                    creation_time = time.strftime(
-                        "%Y-%m-%d %H:%M", time.localtime(os.path.getmtime(model_path))
+                try:
+                    # Find all model files in the models directory
+                    models = list(models_path.glob("*.glb")) + list(
+                        models_path.glob("*.gltf")
                     )
 
-                    if metadata_path.exists():
-                        try:
-                            with open(metadata_path, "r") as f:
-                                metadata = json.load(f)
-                            source_image = metadata.get(
-                                "source_image_filename", "Unknown"
-                            )
-                            format_type = metadata.get("format", model_path.suffix[1:])
-                        except Exception as e:
-                            logger.error(
-                                f"Failed to read metadata for {model_path}: {e}"
-                            )
+                    # Debug output to help diagnose issues
+                    logger.info(
+                        f"Found {len(models)} models in gallery directory: {models_path}"
+                    )
+                    for model in models[:5]:  # Log first 5 models for debugging
+                        logger.info(
+                            f"Model file: {model} (exists: {os.path.exists(model)})"
+                        )
+
+                    model_data = []
+                    model_paths = []  # Store just the paths for easy access by index
+
+                    for model_path in sorted(
+                        models,
+                        key=lambda x: os.path.getmtime(x) if os.path.exists(x) else 0,
+                        reverse=True,
+                    ):
+                        # Skip files that don't exist (should not happen, but just in case)
+                        if not os.path.exists(model_path):
+                            logger.warning(f"Listed model doesn't exist: {model_path}")
+                            continue
+
+                        # Try to load metadata file if available
+                        metadata_path = model_path.with_suffix(".json")
+                        creation_time = time.strftime(
+                            "%Y-%m-%d %H:%M",
+                            time.localtime(os.path.getmtime(model_path)),
+                        )
+
+                        if metadata_path.exists():
+                            try:
+                                with open(metadata_path, "r") as f:
+                                    metadata = json.load(f)
+                                source_image = metadata.get(
+                                    "source_image_filename", "Unknown"
+                                )
+                                format_type = metadata.get(
+                                    "format", model_path.suffix[1:]
+                                )
+                            except Exception as e:
+                                logger.error(
+                                    f"Failed to read metadata for {model_path}: {e}"
+                                )
+                                source_image = "Unknown"
+                                format_type = model_path.suffix[1:]
+                        else:
                             source_image = "Unknown"
                             format_type = model_path.suffix[1:]
-                    else:
-                        source_image = "Unknown"
-                        format_type = model_path.suffix[1:]
-
-                    # Add to data table and path list
-                    model_paths.append(str(model_path))
-                    model_data.append(
-                        [
-                            str(model_path),
-                            source_image,
-                            format_type,
-                            creation_time,
-                        ]
-                    )
 
-                return model_data, model_paths
+                        # Add to data table and path list
+                        model_paths.append(str(model_path))
+                        model_data.append(
+                            [
+                                str(model_path),
+                                source_image,
+                                format_type,
+                                creation_time,
+                            ]
+                        )
+
+                    logger.info(
+                        f"Returning {len(model_data)} valid models for gallery display"
+                    )
+                    return model_data, model_paths
+                except Exception as e:
+                    logger.error(f"Error updating models gallery: {e}")
+                    return [], []
 
             # Function to view model by index instead of relying on DataFrame selection
             def view_model_by_index(evt: gr.SelectData):
@@ -320,8 +367,26 @@ def main():
                     model_path = view_model_by_index.model_paths[row_index]
                     logger.info(f"Selected model at index {row_index}: {model_path}")
 
-                    if not model_path or not os.path.exists(model_path):
-                        logger.warning(f"Model file not found: {model_path}")
+                    # Verify the file exists, if not check if we need to adjust path
+                    if not os.path.exists(model_path):
+                        # Try to recover by checking if it's a path issue
+                        # Models might have paths like: app/data/models/file.glb
+                        # But in Spaces we need /home/user/app/data/models/file.glb
+                        if RUNNING_IN_SPACES and "app/data" in model_path:
+                            # Extract the relative path part
+                            rel_path = model_path.split("app/data/", 1)[-1]
+                            # Construct absolute path using DATA_DIR
+                            if os.environ.get("DATA_DIR"):
+                                corrected_path = os.path.join(
+                                    os.environ.get("DATA_DIR"), rel_path
+                                )
+                                logger.info(f"Trying corrected path: {corrected_path}")
+                                if os.path.exists(corrected_path):
+                                    model_path = corrected_path
+                                    logger.info(f"Using corrected path: {model_path}")
+
+                    if not os.path.exists(model_path):
+                        logger.warning(f"Model file not found at {model_path}")
                         return None, None
 
                 except (IndexError, AttributeError, TypeError) as e: