refactor(ui): replace subprocess sample build with in-process dataset loader

- New obtener_dataset() generator runs VLM pipeline in-process
- Real-time UI updates: log + gallery filling as garments are processed
- Supports multiple HF datasets (second-hand, fashion-1k)
- Single "Obtener Dataset" button replaces previous two-button setup
- Add event context textbox in Combina tab for LLM ranking
- Detect HF Spaces environment for server binding (0.0.0.0:7860)
- Ensure data/ directories are created at startup

Co-authored-by: Cursor <cursoragent@cursor.com>

app.py

@@ -9,7 +9,6 @@ Built for the Build Small Hackathon (HuggingFace x Gradio, June 2026).
 import io
 import logging
 import os
-import shutil
 from pathlib import Path
 
 from dotenv import load_dotenv
@@ -19,7 +18,7 @@ load_dotenv(Path(__file__).resolve().parent / ".env")
 import gradio as gr
 from PIL import Image
 
-from src.vision import extract_garments, extract_single_from_path, extract_from_crop_bytes
+from src.vision import extract_garments, extract_single_from_path, extract_from_crop_bytes, _extract_single_garment
 from src.catalog import (
     add_garments,
     load_catalog,
@@ -31,6 +30,7 @@ from src.catalog import (
 from src.assistant import ask_streaming
 from src.combinations import (
     generate_combinations,
+    rank_with_llm,
     save_preference,
     get_liked_outfits,
 )
@@ -41,6 +41,10 @@ from gradio_image_annotation import image_annotator
 os.environ.setdefault("CUDA_VISIBLE_DEVICES", "0")
 logging.basicConfig(level=logging.INFO, format="%(name)s | %(message)s")
 
+_DATA_DIR = Path(__file__).resolve().parent / "data"
+_DATA_DIR.mkdir(parents=True, exist_ok=True)
+(_DATA_DIR / "garments").mkdir(parents=True, exist_ok=True)
+
 _startup_catalog = load_catalog()
 logging.info("Startup: catalog loaded with %d garments", len(_startup_catalog))
 del _startup_catalog
@@ -168,29 +172,149 @@ def update_detection_backend(backend_name: str):
 
 
 # ---------------------------------------------------------------------------
-# Sample wardrobe handler
+# Dataset loading handler (in-process with real-time progress)
 # ---------------------------------------------------------------------------
 
-SAMPLES_DIR = Path(__file__).resolve().parent / "data" / "samples"
 DATA_DIR = Path(__file__).resolve().parent / "data"
 
+SAMPLE_DATASETS = [
+    ("second-hand", "Second-hand (prendas individuales)"),
+    ("fashion-1k", "Fashion-1K (multi-garment, requiere detección)"),
+]
 
-def load_sample_wardrobe():
-    """Load the pre-processed sample wardrobe into the active catalog."""
-    if not SAMPLES_DIR.exists() or not (SAMPLES_DIR / "catalog.json").exists():
-        return "Datos de ejemplo no disponibles. Ejecuta scripts/build_sample_wardrobe.py primero."
+TARGET_GARMENTS = 50
 
-    shutil.copy(SAMPLES_DIR / "catalog.json", DATA_DIR / "catalog.json")
 
-    dest = DATA_DIR / "garments"
-    dest.mkdir(parents=True, exist_ok=True)
-    src_garments = SAMPLES_DIR / "garments"
-    if src_garments.exists():
-        for img in src_garments.glob("*.jpg"):
-            shutil.copy(img, dest / img.name)
+def obtener_dataset(dataset_key: str):
+    """Download a HF dataset and process garments in-process with real-time UI updates.
 
-    catalog = load_catalog()
-    return f"Cargadas **{len(catalog)}** prendas de ejemplo. Ve a 'Mi Armario' para explorarlas."
+    Yields (log_markdown, gallery_images) at each step.
+    """
+    from datasets import load_dataset
+
+    ds_configs = {
+        "second-hand": {
+            "hf_id": "fnauman/fashion-second-hand-front-only-rgb",
+            "needs_detection": False,
+        },
+        "fashion-1k": {
+            "hf_id": "Codatta/Fashion-1K",
+            "needs_detection": True,
+        },
+    }
+
+    config = ds_configs.get(dataset_key)
+    if not config:
+        yield "Error: dataset no reconocido.", []
+        return
+
+    yield f"Descargando dataset **{config['hf_id']}**...", []
+
+    try:
+        ds = load_dataset(config["hf_id"], split="train")
+    except Exception as e:
+        yield f"Error descargando dataset: {e}", []
+        return
+
+    yield f"Dataset cargado: **{len(ds)}** imágenes. Iniciando procesamiento...", []
+
+    # Spread indices for variety
+    step = max(1, len(ds) // (TARGET_GARMENTS * 2))
+    indices = list(range(0, len(ds), step))[:TARGET_GARMENTS * 3]
+
+    gallery_images: list[str] = []
+    garments_processed: list[tuple[dict, bytes]] = []
+    log_lines: list[str] = []
+
+    for idx in indices:
+        if len(garments_processed) >= TARGET_GARMENTS:
+            break
+        if idx >= len(ds):
+            continue
+
+        sample = ds[idx]
+        image = sample.get("image") or sample.get("img")
+        if not isinstance(image, Image.Image):
+            continue
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+
+        if config["needs_detection"]:
+            import tempfile
+            with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp:
+                image.save(tmp, format="JPEG", quality=90)
+                tmp_path = tmp.name
+
+            try:
+                from src.detector import detect_and_crop
+                crops = detect_and_crop(tmp_path)
+            except Exception:
+                crops = []
+            finally:
+                Path(tmp_path).unlink(missing_ok=True)
+
+            if not crops:
+                continue
+
+            for crop_bytes in crops:
+                if len(garments_processed) >= TARGET_GARMENTS:
+                    break
+                garment = _extract_single_garment(crop_bytes)
+                if garment:
+                    garments_processed.append((garment, crop_bytes))
+                    img_path = _save_temp_preview(crop_bytes, len(garments_processed))
+                    if img_path:
+                        gallery_images.append(img_path)
+                    n = len(garments_processed)
+                    log_lines.append(
+                        f"**{n}/{TARGET_GARMENTS}** — {garment.get('color', '?')} {garment.get('type', '?')}"
+                    )
+                    yield "\n".join(log_lines[-8:]), gallery_images
+        else:
+            if max(image.size) > 512:
+                image.thumbnail((512, 512), Image.LANCZOS)
+
+            buf = io.BytesIO()
+            image.save(buf, format="JPEG", quality=90)
+            crop_bytes = buf.getvalue()
+
+            garment = _extract_single_garment(crop_bytes)
+            if not garment:
+                continue
+
+            garments_processed.append((garment, crop_bytes))
+            img_path = _save_temp_preview(crop_bytes, len(garments_processed))
+            if img_path:
+                gallery_images.append(img_path)
+            n = len(garments_processed)
+            log_lines.append(
+                f"**{n}/{TARGET_GARMENTS}** — {garment.get('color', '?')} {garment.get('type', '?')}"
+            )
+            yield "\n".join(log_lines[-8:]), gallery_images
+
+    if not garments_processed:
+        yield "No se pudieron extraer prendas del dataset.", gallery_images
+        return
+
+    # Save to catalog
+    added = add_garments(garments_processed)
+    final_log = "\n".join(log_lines[-5:]) + (
+        f"\n\n---\n**Completado: {len(added)} prendas** añadidas al armario. "
+        f"Ve a 'Mi Armario' para explorarlas."
+    )
+    yield final_log, gallery_images
+
+
+def _save_temp_preview(crop_bytes: bytes, index: int) -> str | None:
+    """Save a preview image for the gallery during dataset loading."""
+    preview_dir = DATA_DIR / "garments"
+    preview_dir.mkdir(parents=True, exist_ok=True)
+    path = preview_dir / f"_preview_{index:03d}.jpg"
+    try:
+        path.write_bytes(crop_bytes)
+        return str(path)
+    except Exception:
+        return None
 
 
 # ---------------------------------------------------------------------------
@@ -339,8 +463,8 @@ def _get_combo_display(combo: dict | None) -> tuple[str | None, str | None, str,
     return top_img, bottom_img, top_text, bottom_text
 
 
-def init_combinations(state):
-    """Initialize or refresh the combination queue."""
+def init_combinations(state, context):
+    """Initialize or refresh the combination queue, optionally ranked by context."""
     combos = generate_combinations()
     if not combos:
         return (
@@ -351,6 +475,9 @@ def init_combinations(state):
             "0 combinaciones",
         )
 
+    if context and context.strip():
+        combos = rank_with_llm(combos, context.strip())
+
     state = {"queue": combos, "index": 0}
     combo = combos[0]
     top_img, bottom_img, top_text, bottom_text = _get_combo_display(combo)
@@ -462,16 +589,31 @@ with gr.Blocks(title="Wardrobe AI") as demo:
         )
 
         gr.Markdown("---")
+        gr.Markdown("#### Obtener dataset de ejemplo")
         with gr.Row():
-            sample_btn = gr.Button(
-                "Cargar armario de ejemplo (50 prendas)",
-                variant="secondary", size="sm",
+            dataset_select = gr.Dropdown(
+                choices=[(label, key) for key, label in SAMPLE_DATASETS],
+                value="second-hand",
+                label="Dataset de origen",
+                scale=2,
+            )
+            obtener_btn = gr.Button(
+                "Obtener Dataset", variant="primary", size="lg", scale=1,
             )
-            sample_status = gr.Markdown()
 
-        sample_btn.click(
-            load_sample_wardrobe,
-            outputs=[sample_status],
+        dataset_log = gr.Markdown()
+        dataset_gallery = gr.Gallery(
+            label="Prendas procesadas",
+            columns=6,
+            rows=2,
+            height="auto",
+            object_fit="contain",
+        )
+
+        obtener_btn.click(
+            obtener_dataset,
+            inputs=[dataset_select],
+            outputs=[dataset_log, dataset_gallery],
         )
 
         with gr.Accordion("⚙️ Ajustes de detección", open=False):
@@ -570,6 +712,12 @@ with gr.Blocks(title="Wardrobe AI") as demo:
 
         combo_state = gr.State(value=None)
 
+        event_context = gr.Textbox(
+            placeholder="Ej: cena informal en terraza, 30 grados...",
+            label="Describe la ocasión (opcional — las combinaciones se ordenarán para este contexto)",
+            lines=1,
+        )
+
         with gr.Row():
             generate_btn = gr.Button(
                 "Generar combinaciones", variant="primary", size="lg",
@@ -614,7 +762,7 @@ with gr.Blocks(title="Wardrobe AI") as demo:
 
         generate_btn.click(
             init_combinations,
-            inputs=[combo_state],
+            inputs=[combo_state, event_context],
             outputs=combo_outputs,
         )
         like_btn.click(
@@ -646,7 +794,10 @@ Construido para el [Build Small Hackathon](https://huggingface.co/build-small-ha
 
 
 if __name__ == "__main__":
+    is_spaces = os.environ.get("SPACE_ID") is not None
     demo.launch(
+        server_name="0.0.0.0" if is_spaces else "127.0.0.1",
+        server_port=7860,
         theme=gr.themes.Soft(
             primary_hue="stone",
             secondary_hue="amber",

scripts/build_sample_wardrobe.py

@@ -1,16 +1,18 @@
-"""Build a pre-processed sample wardrobe from Fashion-1K dataset.
+"""Build a pre-processed sample wardrobe from HuggingFace datasets.
 
-Downloads flat lay images from Codatta/Fashion-1K (HuggingFace),
-runs the full detection + VLM pipeline, and saves the results to
-data/samples/ for instant loading in the demo.
+Supports multiple dataset sources:
+  - fashion-1k: Codatta/Fashion-1K (flat lays, needs detection)
+  - second-hand: fnauman/fashion-second-hand-front-only-rgb (individual garments)
 
 Usage:
     cd packages/wardrobe-us
-    .venv/bin/python scripts/build_sample_wardrobe.py
+    .venv/bin/python scripts/build_sample_wardrobe.py --dataset second-hand
+    .venv/bin/python scripts/build_sample_wardrobe.py --dataset fashion-1k
 
 Requires: datasets>=2.18.0 (pip install datasets)
 """
 
+import argparse
 import io
 import json
 import logging
@@ -32,13 +34,24 @@ SAMPLES_DIR = Path(__file__).resolve().parent.parent / "data" / "samples"
 GARMENTS_DIR = SAMPLES_DIR / "garments"
 CATALOG_PATH = SAMPLES_DIR / "catalog.json"
 
-TARGET_GARMENTS = 50
-MAX_IMAGES_TO_PROCESS = 40
-
-# Indices hand-picked from Fashion-1K for variety (tops, bottoms, dresses,
-# outerwear, shoes, accessories). If these don't yield enough garments,
-# the script will continue with sequential images.
-CURATED_INDICES = [
+DEFAULT_TARGET = 50
+TARGET_GARMENTS = DEFAULT_TARGET
+
+DATASETS = {
+    "second-hand": {
+        "hf_id": "fnauman/fashion-second-hand-front-only-rgb",
+        "description": "31K individual garments on uniform background (no detection needed)",
+        "needs_detection": False,
+    },
+    "fashion-1k": {
+        "hf_id": "Codatta/Fashion-1K",
+        "description": "1K flat lay outfits (multi-garment, needs detection + cropping)",
+        "needs_detection": True,
+    },
+}
+
+# Curated indices for Fashion-1K variety
+FASHION_1K_INDICES = [
     0, 5, 12, 18, 25, 33, 41, 50, 58, 67,
     75, 83, 91, 100, 110, 120, 130, 140, 150, 160,
     170, 180, 190, 200, 220, 240, 260, 280, 300, 320,
@@ -55,11 +68,8 @@ def save_crop(garment_id: str, crop_bytes: bytes) -> str:
     return filename
 
 
-def process_image(image: Image.Image, image_idx: int, catalog: list, garment_counter: int) -> int:
-    """Process a single source image through detection + VLM.
-
-    Returns the updated garment counter.
-    """
+def process_with_detection(image: Image.Image, image_idx: int, catalog: list, garment_counter: int) -> int:
+    """Process a flat lay image through detection + VLM. Returns updated garment counter."""
     with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp:
         image.save(tmp, format="JPEG", quality=90)
         tmp_path = tmp.name
@@ -104,61 +114,68 @@ def process_image(image: Image.Image, image_idx: int, catalog: list, garment_cou
     return garment_counter
 
 
-def main():
-    logger.info("=== Building Sample Wardrobe ===")
-    logger.info("Target: %d garments from Fashion-1K", TARGET_GARMENTS)
+def process_individual(image: Image.Image, image_idx: int, catalog: list, garment_counter: int) -> int:
+    """Process a single-garment image directly with VLM (no detection needed)."""
+    buf = io.BytesIO()
+    image.save(buf, format="JPEG", quality=90)
+    crop_bytes = buf.getvalue()
 
-    try:
-        from datasets import load_dataset
-    except ImportError:
-        logger.error("'datasets' package not installed. Run: pip install datasets")
-        sys.exit(1)
+    garment = _extract_single_garment(crop_bytes)
+    if not garment:
+        logger.debug("Image %d: VLM extraction failed, skipping", image_idx)
+        return garment_counter
 
-    logger.info("Loading Codatta/Fashion-1K dataset...")
-    ds = load_dataset("Codatta/Fashion-1K", split="train")
-    logger.info("Dataset loaded: %d images", len(ds))
+    garment_counter += 1
+    garment_id = f"garment_{garment_counter:03d}"
+    garment["id"] = garment_id
 
-    SAMPLES_DIR.mkdir(parents=True, exist_ok=True)
-    GARMENTS_DIR.mkdir(parents=True, exist_ok=True)
+    image_ref = save_crop(garment_id, crop_bytes)
+    garment["image_ref"] = image_ref
+
+    catalog.append(garment)
+    logger.info(
+        "  [%d/%d] %s: %s %s (%s)",
+        garment_counter, TARGET_GARMENTS,
+        garment_id, garment.get("color", "?"), garment.get("type", "?"),
+        garment.get("pattern", "?"),
+    )
 
+    return garment_counter
+
+
+def build_from_fashion_1k(ds) -> list[dict]:
+    """Build sample wardrobe from Fashion-1K (multi-garment flat lays)."""
     catalog: list[dict] = []
     garment_counter = 0
-    images_processed = 0
+    max_images = 40
 
-    # Process curated indices first
-    for idx in CURATED_INDICES:
+    for i, idx in enumerate(FASHION_1K_INDICES):
         if garment_counter >= TARGET_GARMENTS:
             break
         if idx >= len(ds):
             continue
-
-        images_processed += 1
-        if images_processed > MAX_IMAGES_TO_PROCESS:
+        if i >= max_images:
             break
 
         sample = ds[idx]
         image = sample["image"]
         if not isinstance(image, Image.Image):
             continue
-
         if image.mode != "RGB":
             image = image.convert("RGB")
 
-        logger.info("--- Processing image %d (dataset idx %d) ---", images_processed, idx)
-        garment_counter = process_image(image, idx, catalog, garment_counter)
+        logger.info("--- Processing image %d (dataset idx %d) ---", i + 1, idx)
+        garment_counter = process_with_detection(image, idx, catalog, garment_counter)
 
-    # If we haven't reached target, try sequential
+    # Fill remaining with sequential if needed
     if garment_counter < TARGET_GARMENTS:
-        processed_indices = set(CURATED_INDICES)
+        processed = set(FASHION_1K_INDICES[:max_images])
         for idx in range(len(ds)):
             if garment_counter >= TARGET_GARMENTS:
                 break
-            if idx in processed_indices:
+            if idx in processed:
                 continue
-            if images_processed >= MAX_IMAGES_TO_PROCESS:
-                break
 
-            images_processed += 1
             sample = ds[idx]
             image = sample["image"]
             if not isinstance(image, Image.Image):
@@ -166,8 +183,83 @@ def main():
             if image.mode != "RGB":
                 image = image.convert("RGB")
 
-            logger.info("--- Processing image %d (dataset idx %d) ---", images_processed, idx)
-            garment_counter = process_image(image, idx, catalog, garment_counter)
+            logger.info("--- Processing image (dataset idx %d) ---", idx)
+            garment_counter = process_with_detection(image, idx, catalog, garment_counter)
+
+    return catalog
+
+
+def build_from_second_hand(ds) -> list[dict]:
+    """Build sample wardrobe from second-hand dataset (individual garments)."""
+    catalog: list[dict] = []
+    garment_counter = 0
+
+    # Spread indices across the dataset for variety
+    step = max(1, len(ds) // (TARGET_GARMENTS * 2))
+    indices = list(range(0, len(ds), step))[:TARGET_GARMENTS * 2]
+
+    for i, idx in enumerate(indices):
+        if garment_counter >= TARGET_GARMENTS:
+            break
+
+        sample = ds[idx]
+        image = sample.get("image") or sample.get("img")
+        if not isinstance(image, Image.Image):
+            continue
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+
+        # Resize large images to max 512px to save VLM time
+        if max(image.size) > 512:
+            image.thumbnail((512, 512), Image.LANCZOS)
+
+        logger.info("--- Processing image %d/%d (dataset idx %d) ---", i + 1, len(indices), idx)
+        garment_counter = process_individual(image, idx, catalog, garment_counter)
+
+    return catalog
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Build sample wardrobe from HuggingFace dataset")
+    parser.add_argument(
+        "--dataset",
+        choices=list(DATASETS.keys()),
+        default="second-hand",
+        help="Dataset source to use (default: second-hand)",
+    )
+    parser.add_argument(
+        "--target",
+        type=int,
+        default=DEFAULT_TARGET,
+        help=f"Number of garments to generate (default: {DEFAULT_TARGET})",
+    )
+    args = parser.parse_args()
+
+    global TARGET_GARMENTS
+    TARGET_GARMENTS = args.target
+
+    ds_config = DATASETS[args.dataset]
+    logger.info("=== Building Sample Wardrobe ===")
+    logger.info("Dataset: %s (%s)", args.dataset, ds_config["description"])
+    logger.info("Target: %d garments", TARGET_GARMENTS)
+
+    try:
+        from datasets import load_dataset
+    except ImportError:
+        logger.error("'datasets' package not installed. Run: pip install datasets")
+        sys.exit(1)
+
+    logger.info("Loading %s...", ds_config["hf_id"])
+    ds = load_dataset(ds_config["hf_id"], split="train")
+    logger.info("Dataset loaded: %d images", len(ds))
+
+    SAMPLES_DIR.mkdir(parents=True, exist_ok=True)
+    GARMENTS_DIR.mkdir(parents=True, exist_ok=True)
+
+    if args.dataset == "fashion-1k":
+        catalog = build_from_fashion_1k(ds)
+    else:
+        catalog = build_from_second_hand(ds)
 
     # Save catalog
     with open(CATALOG_PATH, "w", encoding="utf-8") as f:
@@ -175,11 +267,10 @@ def main():
 
     logger.info("=== Done ===")
     logger.info("Total garments: %d", len(catalog))
-    logger.info("Images processed: %d", images_processed)
     logger.info("Catalog saved: %s", CATALOG_PATH)
     logger.info("Garment images: %s", GARMENTS_DIR)
 
-    # Print summary by type
+    # Summary by type
     types: dict[str, int] = {}
     for g in catalog:
         t = g.get("type", "unknown")