app.py

import gradio as gr
import pandas as pd
import numpy as np
from search import search_images_by_text, get_similar_images
import requests
from io import BytesIO

def create_collection_url(row):
    base_url = "https://www.vogue.com/fashion-shows/"
    season = str(row["season"]).lower()
    year = str(row["year"])
    category = str(row["category"]).lower() if pd.notna(row["category"]) and row["category"] and str(row["category"]).lower() != "nan" else None
    designer = str(row["designer"]).lower().replace(" ", "-")
    
    # Add city if available
    city = str(row["city"]).lower().replace(" ", "-") if pd.notna(row["city"]) and row["city"] and str(row["city"]).lower() != "nan" else None
    
    if pd.isna(category) or category is None or category == "nan":
        if city:
            return f"{base_url}{city}-{season}-{year}/{designer}"
        else:
            return f"{base_url}{season}-{year}/{designer}"
    else:
        if city:
            return f"{base_url}{city}-{season}-{year}-{category}/{designer}"
        else:
            return f"{base_url}{season}-{year}-{category}/{designer}"

import requests
from io import BytesIO
#@st.cache_data(show_spinner="Loading FashionDB...")
def load_data_hf():
    # Load the Parquet file directly from Hugging Face
    df_url = "https://huggingface.co/datasets/traopia/vogue_runway_small/resolve/main/VogueRunway.parquet"
    df = pd.read_parquet(df_url)

    # Load the .npy file using requests
    npy_url = "https://huggingface.co/datasets/traopia/vogue_runway_small/resolve/main/VogueRunway_image.npy"
    response = requests.get(npy_url)
    response.raise_for_status()  # Raise error if download fails
    embeddings = np.load(BytesIO(response.content))
    df['collection'] = df.apply(create_collection_url, axis=1)
    return df, embeddings


from huggingface_hub import hf_hub_download
def load_data1():
# Login using e.g. `huggingface-cli login` to access this dataset
    path = hf_hub_download(
        repo_id="traopia/fashion_show_data_all_embeddings",
        filename="fashion_show_data_all_embeddings.json"
    )
    df = pd.read_json(path, lines = True)

    #df = pd.read_json("hf://datasets/traopia/fashion_show_data_all_embeddings.json/fashion_show_data_all_embeddings.json", lines=True)
    df["fashion_clip_image"] = df["fashion_clip_image"].apply(lambda x: x[0] if isinstance(x, list) else x)
    df["image_urls"] = df["image_urls"].apply(lambda x: x[0] if x is not None else None)
    df = df.rename(columns={"fashion_house":"designer", "image_urls":"url", "URL":"collection"})
    
    df = df.dropna(subset="fashion_clip_image")
    df = df.reset_index(drop=True)
    df["key"] = df.index
    embeddings = np.vstack(df["fashion_clip_image"].values)
    
    return df, embeddings

df, embeddings = load_data_hf()

# Filter and search
def filter_and_search(fashion_house, category, season, start_year, end_year, query):
    filtered = df.copy()

    if fashion_house:
        filtered = filtered[filtered['designer'].isin(fashion_house)]
    if category:
        filtered = filtered[filtered['category'].isin(category)]
    if season:
        filtered = filtered[filtered['season'].isin(season)]
    filtered = filtered[(filtered['year'] >= start_year) & (filtered['year'] <= end_year)]

    if query:
        results = search_images_by_text(query, filtered, embeddings)
    else:
        results = filtered.head(30)
    
    image_urls = results["url"].tolist()
    metadata = results.to_dict(orient="records")
    return image_urls, metadata

# Display metadata and similar
def show_metadata(idx, metadata):
    item = metadata[idx]
    out = ""
    for field in ["designer", "season", "year", "category"]:
        if field in item and pd.notna(item[field]):
            out += f"**{field.title()}**: {item[field]}\n"
    if 'collection' in item and pd.notna(item['collection']):
        out += f"\n[View Collection]({item['collection']})"
    return out

def find_similar(idx, metadata):
    key = metadata[idx]["key"]
    similar_df = get_similar_images(df, key, embeddings, top_k=5)
    return similar_df["url"].tolist(), similar_df.to_dict(orient="records")

# Gradio UI
with gr.Blocks() as demo:
    gr.Markdown("# 👗 FashionDB Explorer")

    with gr.Row():
        fashion_house = gr.Dropdown(label="Fashion House", choices=sorted(df["designer"].dropna().unique()), multiselect=True)
        category = gr.Dropdown(label="Category", choices=sorted(df["category"].dropna().unique()), multiselect=True)
        season = gr.Dropdown(label="Season", choices=sorted(df["season"].dropna().unique()), multiselect=True)
        #year_range = gr.RangeSlider(label="Year Range", minimum=int(df['year'].min()), maximum=int(df['year'].max()), value=(2000, 2025), step=1)
        
        min_year = int(df['year'].min())
        max_year = int(df['year'].max())

        start_year = gr.Slider(label="Start Year", minimum=min_year, maximum=max_year, value=2000, step=1)
        end_year = gr.Slider(label="End Year", minimum=min_year, maximum=max_year, value=2024, step=1)

    query = gr.Textbox(label="Search", placeholder="e.g., pink dress")
    search_button = gr.Button("Search")
    
    result_gallery = gr.Gallery(label="Search Results", columns=5, height="auto")
    metadata_output = gr.Markdown()
    similar_gallery = gr.Gallery(label="Similar Images", columns = 5, height="auto")

    metadata_state = gr.State([])
    selected_idx = gr.Number(value=0, visible=False)

    def handle_search(*args):
        imgs, meta = filter_and_search(*args)
        return imgs, meta, "", []

    search_button.click(
        handle_search,
        inputs=[fashion_house, category, season, start_year, end_year, query],
        outputs=[result_gallery, metadata_state, metadata_output, similar_gallery]
    )

    def handle_click(evt: gr.SelectData, metadata):
        idx = evt.index
        md = show_metadata(idx, metadata)
        return idx, md

    result_gallery.select(
        handle_click,
        inputs=[metadata_state],
        outputs=[selected_idx, metadata_output]
    )

    # def show_similar(idx, metadata):
    #     return find_similar(int(idx), metadata)
    def show_similar(idx, metadata):
        similar_images, similar_metadata = find_similar(int(idx), metadata)
        return similar_images, similar_metadata

    similar_metadata_state = gr.State()
    similar_metadata_output = gr.Markdown()
    show_similar_button = gr.Button("Show Similar Images")
    show_similar_button.click(
        show_similar,
        inputs=[selected_idx, metadata_state],
        outputs=[similar_gallery, similar_metadata_state]
    )

    def handle_similar_click(evt: gr.SelectData, metadata):
        idx = evt.index
        md = show_metadata(idx, metadata)
        return idx, md
    
    similar_gallery.select(
    handle_similar_click,
    inputs=[similar_metadata_state],
    outputs=[selected_idx, similar_metadata_output]
    )

demo.launch()