Spaces:

Levimichael4
/

RideSearch

Sleeping

App Files Files Community

Levimichael4 commited on Aug 11, 2025

Commit

cd41536

verified ·

1 Parent(s): eb25f6f

Update app.py

Browse files

Files changed (1) hide show

app.py +615 -373

app.py CHANGED Viewed

@@ -1,419 +1,661 @@
-# app.py — RideSearch (Fixed trim levels and 0-100 acceleration)
-import os, glob, urllib.parse
 import numpy as np
 import pandas as pd
-from sklearn.metrics.pairwise import cosine_similarity
-from sklearn.preprocessing import StandardScaler
 import gradio as gr
-import json
-# =========================
-# Data loading & embeddings
-# =========================
 def load_df():
-    if os.path.exists('RideSearch_dataset.csv'):
-        return pd.read_csv('RideSearch_dataset.csv')
-    parts = sorted(glob.glob('RideSearch_part*_small.csv'))
     if not parts:
         raise FileNotFoundError("Upload RideSearch_dataset.csv OR the 10 parts RideSearch_part*_small.csv.")
     df = pd.concat([pd.read_csv(p) for p in parts], ignore_index=True)
-    df.to_csv('RideSearch_dataset.csv', index=False)
     return df
-DF = load_df()
-NUM_COLS = [
-    'horsepower','zero_to_100_kmh_s','seats','cargo_liters','price_usd',
-    'popularity_score','comfort_score','reliability_score','tech_score',
-    'ownership_cost_score','safety_rating'
-]
-def load_trims_map():
-    """Load the trims mapping from JSON file if it exists"""
-    try:
-        with open('trims_map.json', 'r') as f:
-            return json.load(f)
-    except FileNotFoundError:
-        return {}
-TRIMS_MAP = load_trims_map()
-def ensure_emb():
-    txt_ok = os.path.exists('emb_text.npy')
-    num_ok = os.path.exists('emb_num.npy')
     if txt_ok and num_ok:
-        return np.load('emb_text.npy'), np.load('emb_num.npy')
     from sentence_transformers import SentenceTransformer
-    m = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
-    texts = DF['text_record'].astype(str).tolist()
-    Etext = m.encode(texts, batch_size=256, show_progress_bar=True, normalize_embeddings=True)
-    Etext = np.asarray(Etext, dtype='float32'); np.save('emb_text.npy', Etext)
-    X = DF[NUM_COLS].copy()
-    # FIX: Don't negate acceleration times - lower is better but we handle that in similarity calculation
-    # The original code had: X['zero_to_100_kmh_s'] = -X['zero_to_100_kmh_s'].astype('float32')
-    # This is incorrect - we want to preserve actual acceleration times
-    X['zero_to_100_kmh_s'] = X['zero_to_100_kmh_s'].astype('float32')
-    # Handle missing values
-    X = X.fillna(X.mean())
-    Xs = StandardScaler().fit_transform(X.values.astype('float32'))
-    Enum = Xs.astype('float32'); np.save('emb_num.npy', Enum)
     return Etext, Enum
-# ==========================================
-# Simplified and data-driven trim handling
-# ==========================================
-def get_available_trims(make=None, model=None):
-    """Get available trims from actual data"""
-    df = DF.copy()
-    if make:
-        df = df[df['make'] == make]
-    if model:
-        df = df[df['model'] == model]
-    # Get unique trims and clean them up
-    trims = df['trim'].dropna().astype(str).unique()
-    # Remove any obviously bad data
-    trims = [t for t in trims if t not in ['nan', 'None', '', 'null']]
-    return sorted(trims)
-def get_available_years(make=None, model=None):
-    """Get available years from actual data"""
-    df = DF.copy()
-    if make:
-        df = df[df['make'] == make]
-    if model:
-        df = df[df['model'] == model]
-    years = df['year'].dropna().astype(int).unique()
-    return sorted(years)
-# ==============================
-# Dropdowns, filters, formatting
-# ==============================
-def models_for(make):
-    if not make:
-        return gr.update(choices=[], value=None)
-    opts = sorted(DF.loc[DF['make'].eq(make), 'model'].dropna().unique().tolist())
-    return gr.update(choices=opts, value=None)
-def on_model_change(make, model):
-    trims = get_available_trims(make, model)
-    years = get_available_years(make, model)
-    return gr.update(choices=trims, value=None), gr.update(choices=years, value=None)
-def apply_filters(df, body, fuel, y_min, y_max, p_min, p_max, safety, reliab):
-    out = df.copy()
-    if body != 'Any':
-        out = out[out['body_type'] == body]
-    if fuel != 'Any':
-        out = out[out['fuel'] == fuel]
-    out = out[(out['year'] >= y_min) & (out['year'] <= y_max)]
-    out = out[(out['price_usd'] >= p_min) & (out['price_usd'] <= p_max)]
-    out = out[(out['safety_rating'] >= safety) & (out['reliability_score'] >= reliab)]
     return out
-def fmt_anchor(r):
-    # Handle NaN values gracefully
-    trim_display = str(r['trim']) if pd.notna(r['trim']) else ""
-    acceleration = f"{r['zero_to_100_kmh_s']:.1f}s" if pd.notna(r['zero_to_100_kmh_s']) else "N/A"
-    return (f"**{r['make']} {r['model']} {trim_display} {int(r['year'])}**  \n"
-            f"Body: {r['body_type']} • Fuel: {r['fuel']} • Engine: {r['engine_type']}  \n"
-            f"HP: {int(r['horsepower'])} • 0–100: {acceleration} • Price: ${int(r['price_usd']):,}  \n"
-            f"Popularity {int(r['popularity_score'])}/10 • Comfort {int(r['comfort_score'])}/10 • "
-            f"Reliability {int(r['reliability_score'])}/100 • Safety {int(r['safety_rating'])}★")
-# ==============
-# Photo helpers
-# ==============
-def placeholder_svg_data_uri(title):
-    # Clean inline SVG placeholder
-    txt = urllib.parse.quote(title)
-    svg = f"""<svg xmlns='http://www.w3.org/2000/svg' width='480' height='320'>
-      <rect width='100%' height='100%' fill='#e8eef7'/>
-      <text x='50%' y='50%' dominant-baseline='middle' text-anchor='middle'
-            font-family='Arial' font-size='26' fill='#223'>
-        {title}
-      </text>
-    </svg>"""
-    return "data:image/svg+xml;utf8," + urllib.parse.quote(svg)
-def build_gallery_html(df_rows):
-    cards = []
-    for _, r in df_rows.iterrows():
-        trim_str = f" {r['trim']}" if pd.notna(r['trim']) and str(r['trim']) != 'nan' else ""
-        label = f"{r['make']} {r['model']}{trim_str}"
-        if 'image_url' in r and isinstance(r['image_url'], str) and r['image_url'].strip():
-            img_src = r['image_url'].strip()
-        else:
-            img_src = placeholder_svg_data_uri(f"{r['make']} {r['model']}")
-        cards.append(f"""
-        <div style="width:240px;margin:6px;border:1px solid #ddd;border-radius:12px;overflow:hidden;background:#fff;">
-          <img src="{img_src}" style="width:240px;height:160px;object-fit:cover;display:block" />
-          <div style="padding:8px 10px;font:14px/1.3 Arial,sans-serif;color:#111">{label}</div>
-        </div>
-        """)
-    return f"<div style='display:flex;flex-wrap:wrap'>{''.join(cards)}</div>"
-# ===========================
-# Anchor selection & ranking
-# ===========================
-def anchor_row(make, model, trim, year):
-    """Find the best matching anchor car from the dataset"""
-    sub = DF.copy()
-    if make:
-        sub = sub[sub['make'] == make]
-    if model:
-        sub = sub[sub['model'] == model]
-    def pick_best(df_):
-        if df_.empty:
-            return None
-        # Sort by popularity score (descending) then by year (descending)
-        return df_.sort_values(['popularity_score', 'year'], ascending=[False, False]).iloc[0]
-    # Try exact match first
-    exact = sub.copy()
-    if trim and str(trim) != 'nan':
-        exact = exact[exact['trim'] == trim]
-    if year:
-        exact = exact[exact['year'] == year]
-    if not exact.empty:
-        return pick_best(exact)
-    # Try same year, any trim
-    if year:
-        y_only = sub[sub['year'] == year]
-        if not y_only.empty:
-            return pick_best(y_only)
-    # Try same trim, any year
-    if trim and str(trim) != 'nan':
-        t_only = sub[sub['trim'] == trim]
-        if not t_only.empty:
-            return pick_best(t_only)
-    # Fallback to any match for make/model
-    return pick_best(sub)
-def calculate_custom_similarity(anchor_idx, candidate_indices, text_emb, num_emb, alpha):
-    """Calculate similarity with proper handling of acceleration times"""
-    # Text similarity
-    text_sim = cosine_similarity(
-        text_emb[anchor_idx:anchor_idx+1],
-        text_emb[candidate_indices]
-    )[0]
-    # Numerical similarity - but we need to handle acceleration specially
-    # For acceleration, lower is better, so we need to invert the similarity logic
-    anchor_features = num_emb[anchor_idx:anchor_idx+1]
-    candidate_features = num_emb[candidate_indices]
-    # Calculate cosine similarity for numerical features
-    num_sim = cosine_similarity(anchor_features, candidate_features)[0]
-    # Combine similarities
-    combined_sim = alpha * text_sim + (1 - alpha) * num_sim
-    return combined_sim, text_sim, num_sim
-def recommend(make, model, trim, year, topk, alpha,
               body, fuel, y_min, y_max, p_min, p_max, safety, reliab,
-              cross_brand_only=True, exclude_same_model=True):
-    # Find anchor car
-    a = anchor_row(make, model, trim, year)
-    if a is None:
-        return "No match found for that combination.", None, "", None
-    # Build candidate pool
-    pool = DF.copy()
     if cross_brand_only:
-        pool = pool[pool['make'] != a['make']]
     if exclude_same_model:
-        pool = pool[~((pool['make'] == a['make']) & (pool['model'] == a['model']))]
-    # Apply filters
-    pool = apply_filters(pool, body, fuel, int(y_min), int(y_max), int(p_min), int(p_max), int(safety), int(reliab))
     if pool.empty:
-        return "No cars match your filters. Try widening the criteria.", None, "", None
-    # Calculate similarities
-    Etext, Enum = ensure_emb()
-    anchor_idx = int(a.name)
-    candidate_indices = pool.index.values
-    combined_sim, text_sim, num_sim = calculate_custom_similarity(
-        anchor_idx, candidate_indices, Etext, Enum, alpha
-    )
-    # Rank and select top recommendations
-    order = np.argsort(-combined_sim)
-    seen_models = set()
-    chosen_indices = []
     for j in order:
-        row_idx = candidate_indices[j]
-        r = DF.loc[row_idx]
-        model_key = (r['make'], r['model'])
-        if model_key in seen_models:
             continue
-        seen_models.add(model_key)
-        chosen_indices.append(row_idx)
-        if len(chosen_indices) >= int(topk):
             break
-    if not chosen_indices:
-        return "No recommendations found after applying constraints.", None, "", None
-    # Prepare results
-    results = DF.loc[chosen_indices].copy()
-    # Add similarity scores
-    similarity_scores = {}
-    for i, idx in enumerate(chosen_indices):
-        # Find the position in the original candidate list
-        pos = np.where(candidate_indices == idx)[0][0]
-        similarity_scores[idx] = round(float(combined_sim[pos]) * 100, 1)
-    results['similarity_%'] = results.index.map(lambda x: similarity_scores.get(x, 0.0))
-    # Format acceleration properly
-    results['zero_to_100_display'] = results['zero_to_100_kmh_s'].apply(
-        lambda x: f"{x:.1f}s" if pd.notna(x) else "N/A"
-    )
-    # Select and order columns for display
-    display_cols = [
-        'name', 'make', 'model', 'trim', 'year', 'body_type', 'fuel', 'engine_type',
-        'price_usd', 'horsepower', 'zero_to_100_display', 'popularity_score',
-        'comfort_score', 'reliability_score', 'tech_score', 'ownership_cost_score',
-        'safety_rating', 'similarity_%'
-    ]
-    # Only include columns that exist in the dataframe
-    available_cols = [col for col in display_cols if col in results.columns]
-    note = (f"α = {float(alpha):.2f} (text ↔ numeric) • Cross-brand only = {cross_brand_only} "
-            f"• Exclude same model = {exclude_same_model}")
-    gallery_html = build_gallery_html(results)
-    return fmt_anchor(a), results[available_cols], note, gallery_html
-# ============
-# Gradio UI
-# ============
-def build_ui():
-    # Get data ranges
-    y_lo, y_hi = int(DF['year'].min()), int(DF['year'].max())
-    p_lo, p_hi = int(DF['price_usd'].min()), int(DF['price_usd'].max())
-    with gr.Blocks(title="RideSearch - Fixed") as demo:
-        gr.Markdown("# RideSearch — Cross-brand recommendations (Fixed trim levels & acceleration)")
         with gr.Tab("Pick & Recommend"):
             with gr.Row():
-                mk = gr.Dropdown(
-                    choices=sorted(DF['make'].dropna().unique().tolist()),
-                    label="Make",
-                    value=None
-                )
-                md = gr.Dropdown([], label="Model", value=None)
-                tr = gr.Dropdown([], label="Trim (optional)", value=None)
-                yr = gr.Dropdown([], label="Year (optional)", value=None)
-            # Set up dropdown dependencies
             mk.change(models_for, mk, md)
-            md.change(on_model_change, [mk, md], [tr, yr])
             with gr.Row():
-                body = gr.Dropdown(
-                    choices=['Any'] + sorted(DF['body_type'].dropna().unique().tolist()),
-                    value='Any',
-                    label='Body Type'
-                )
-                fuel = gr.Dropdown(
-                    choices=['Any'] + sorted(DF['fuel'].dropna().unique().tolist()),
-                    value='Any',
-                    label='Fuel Type'
-                )
             with gr.Row():
-                y_min = gr.Slider(y_lo, y_hi, value=y_lo, step=1, label='Min Year')
-                y_max = gr.Slider(y_lo, y_hi, value=y_hi, step=1, label='Max Year')
             with gr.Row():
-                p_min = gr.Slider(p_lo, p_hi, value=p_lo, step=500, label='Min Price (USD)')
-                p_max = gr.Slider(p_lo, p_hi, value=min(p_hi, 80000), step=500, label='Max Price (USD)')
             with gr.Row():
-                safety = gr.Slider(3, 5, value=4, step=1, label='Min Safety Rating ★')
-                reliab = gr.Slider(55, 99, value=70, step=1, label='Min Reliability Score')
             with gr.Row():
-                topk = gr.Slider(1, 10, value=5, step=1, label='Number of Recommendations')
-                alpha = gr.Slider(0, 1, value=0.7, step=0.05, label='α — Text vs Numeric Weight')
             with gr.Row():
-                cross = gr.Checkbox(label="Cross-brand only", value=True)
-                xmodel = gr.Checkbox(label="Exclude same model family", value=True)
-            go = gr.Button("Get Recommendations", variant="primary")
-            # Output components
-            anchor_display = gr.Markdown(label="Your Selected Car")
-            results_table = gr.Dataframe(interactive=False, label="Recommendations")
-            settings_note = gr.Markdown(label="Settings Used")
-            gallery = gr.HTML(label="Visual Gallery")
-            # Connect the button
-            go.click(
-                recommend,
-                inputs=[mk, md, tr, yr, topk, alpha, body, fuel, y_min, y_max, p_min, p_max, safety, reliab, cross, xmodel],
-                outputs=[anchor_display, results_table, settings_note, gallery]
-            )
-        with gr.Tab("Data Info"):
-            gr.Markdown("""
-            ## Fixes Applied:
-            1. **Acceleration Times**: Fixed the incorrect negation of 0-100 km/h times
-            2. **Trim Levels**: Simplified trim handling to use actual data from your CSV files
-            3. **Data Validation**: Added proper handling of missing/invalid values
-            4. **Similarity Calculation**: Improved the similarity algorithm for better recommendations
-            5. **UI Improvements**: Better error handling and user feedback
-            ## Dataset Overview:
-            - Cars in database: {:,}
-            - Years covered: {} - {}
-            - Price range: ${:,} - ${:,}
-            - Makes available: {}
-            """.format(
-                len(DF),
-                int(DF['year'].min()), int(DF['year'].max()),
-                int(DF['price_usd'].min()), int(DF['price_usd'].max()),
-                len(DF['make'].unique())
-            ))
-    return demo
-# Initialize and run
-demo = build_ui()
 if __name__ == "__main__":
     demo.queue().launch(server_name="0.0.0.0", server_port=7860)

+# app.py — RideSearch (real trims, fixed 0–100, cross‑brand, photos)
+import os, glob, json, math, requests
 import numpy as np
 import pandas as pd
 import gradio as gr
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics.pairwise import cosine_similarity
+# --------- Files / constants ----------
+CSV_MAIN = "RideSearch_dataset.csv"
+CSV_PARTS_GLOB = "RideSearch_part*_small.csv"
+EMB_TEXT_NPY = "emb_text.npy"
+EMB_NUM_NPY  = "emb_num.npy"
+EMBED_MODEL  = "sentence-transformers/all-MiniLM-L6-v2"
+NUM_COLS = [
+    "horsepower","zero_to_100_kmh_s","seats","cargo_liters","price_usd",
+    "popularity_score","comfort_score","reliability_score","tech_score",
+    "ownership_cost_score","safety_rating"
+]
+# --------- Trim database (your long list, deduped) ----------
+REAL_WORLD_TRIMS = {
+    # BMW
+    ("BMW", "1 Series"): ["116i","118i","120i","125i","M135i"],
+    ("BMW", "2 Series"): ["218i","220i","225i","230i","M235i","M240i"],
+    ("BMW", "3 Series"): ["318i","320i","325i","330i","330e","335i","340i","M340i","M3"],
+    ("BMW", "4 Series"): ["420i","430i","435i","440i","M440i","M4"],
+    ("BMW", "5 Series"): ["520i","525i","530i","530e","535i","540i","550i","M550i","M5"],
+    ("BMW", "6 Series"): ["630i","640i","650i","M6"],
+    ("BMW", "7 Series"): ["730i","740i","750i","760i","M760i"],
+    ("BMW", "8 Series"): ["840i","850i","M850i","M8"],
+    ("BMW", "X1"): ["sDrive18i","sDrive20i","xDrive20i","xDrive25i"],
+    ("BMW", "X2"): ["sDrive18i","sDrive20i","xDrive20i","xDrive25i","M35i"],
+    ("BMW", "X3"): ["sDrive20i","xDrive20i","xDrive30i","M40i","X3 M"],
+    ("BMW", "X4"): ["xDrive20i","xDrive30i","M40i","X4 M"],
+    ("BMW", "X5"): ["sDrive40i","xDrive40i","xDrive45e","M50i","X5 M"],
+    ("BMW", "X6"): ["sDrive40i","xDrive40i","M50i","X6 M"],
+    ("BMW", "X7"): ["xDrive40i","xDrive50i","M50i"],
+    ("BMW", "Z4"): ["sDrive20i","sDrive30i","M40i"],
+    # Audi
+    ("Audi", "A1"): ["25 TFSI","30 TFSI","35 TFSI","S1"],
+    ("Audi", "A3"): ["30 TFSI","35 TFSI","40 TFSI","45 TFSI e","S3","RS3"],
+    ("Audi", "A4"): ["35 TFSI","40 TFSI","45 TFSI","45 TFSI e","S4","RS4"],
+    ("Audi", "A5"): ["35 TFSI","40 TFSI","45 TFSI","S5","RS5"],
+    ("Audi", "A6"): ["40 TFSI","45 TFSI","50 TFSI","55 TFSI e","S6","RS6"],
+    ("Audi", "A7"): ["45 TFSI","50 TFSI","55 TFSI e","S7","RS7"],
+    ("Audi", "A8"): ["50 TFSI","55 TFSI","60 TFSI e","S8"],
+    ("Audi", "Q2"): ["30 TFSI","35 TFSI","40 TFSI"],
+    ("Audi", "Q3"): ["35 TFSI","40 TFSI","45 TFSI e","RS Q3"],
+    ("Audi", "Q5"): ["40 TFSI","45 TFSI e","SQ5"],
+    ("Audi", "Q7"): ["45 TFSI","50 TDI","55 TFSI e","SQ7"],
+    ("Audi", "Q8"): ["50 TDI","55 TFSI","SQ8","RS Q8"],
+    ("Audi", "TT"): ["40 TFSI","45 TFSI","TTS","TT RS"],
+    ("Audi", "R8"): ["V10","V10 Performance","V10 Plus"],
+    # Mercedes-Benz
+    ("Mercedes-Benz", "A-Class"): ["A180","A200","A220","A250","A250e","AMG A35","AMG A45"],
+    ("Mercedes-Benz", "B-Class"): ["B180","B200","B220","B250e"],
+    ("Mercedes-Benz", "C-Class"): ["C180","C200","C220d","C250","C300","C350e","AMG C43","AMG C63"],
+    ("Mercedes-Benz", "E-Class"): ["E200","E220d","E300","E350","E400","E450","AMG E53","AMG E63"],
+    ("Mercedes-Benz", "S-Class"): ["S450","S500","S580","AMG S63","AMG S65"],
+    ("Mercedes-Benz", "CLA"): ["CLA180","CLA200","CLA220","CLA250","AMG CLA35","AMG CLA45"],
+    ("Mercedes-Benz", "CLS"): ["CLS350","CLS450","AMG CLS53","AMG CLS63"],
+    ("Mercedes-Benz", "GLA"): ["GLA180","GLA200","GLA220","GLA250","AMG GLA35","AMG GLA45"],
+    ("Mercedes-Benz", "GLB"): ["GLB200","GLB220","GLB250","AMG GLB35"],
+    ("Mercedes-Benz", "GLC"): ["GLC200","GLC220d","GLC300","GLC350e","AMG GLC43","AMG GLC63"],
+    ("Mercedes-Benz", "GLE"): ["GLE350","GLE450","GLE580","AMG GLE53","AMG GLE63"],
+    ("Mercedes-Benz", "GLS"): ["GLS450","GLS580","AMG GLS63"],
+    ("Mercedes-Benz", "G-Class"): ["G500","G550","AMG G63"],
+    # Toyota (sedans/SUVs)
+    ("Toyota", "Corolla"): ["L","LE","XLE","SE","XSE","GR Corolla"],
+    ("Toyota", "Camry"): ["LE","SE","XLE","XSE","TRD"],
+    ("Toyota", "Avalon"): ["XLE","XSE","Limited","TRD"],
+    ("Toyota", "Prius"): ["LE","XLE","Limited","Prime"],
+    ("Toyota", "RAV4"): ["LE","XLE","XLE Premium","Adventure","TRD Off-Road","Limited","Prime"],
+    ("Toyota", "Highlander"): ["L","LE","XLE","Limited","Platinum","Hybrid"],
+    ("Toyota", "4Runner"): ["SR5","TRD Off-Road","TRD Pro","Limited"],
+    ("Toyota", "Tacoma"): ["SR","SR5","TRD Sport","TRD Off-Road","TRD Pro","Limited"],
+    ("Toyota", "Tundra"): ["SR","SR5","Limited","Platinum","1794","TRD Pro"],
+    ("Toyota", "Land Cruiser"): ["Base","Heritage Edition"],
+    ("Toyota", "Supra"): ["2.0","3.0","3.0 Premium"],
+    ("Toyota", "Yaris"): ["L","LE","XLE","GRMN"],
+    ("Toyota", "C-HR"): ["LE","XLE","Nightshade","Limited"],
+    ("Toyota", "Sequoia"): ["SR5","Limited","Platinum","TRD Pro","Capstone"],
+    ("Toyota", "Sienna"): ["LE","XLE","XSE","Limited","Platinum"],
+    # Honda
+    ("Honda", "Civic"): ["LX","Sport","EX","EX-L","Sport Touring","Touring","Si","Type R"],
+    ("Honda", "Accord"): ["LX","Sport","EX","EX-L","Touring","Sport-L"],
+    ("Honda", "CR-V"): ["LX","EX","EX-L","Touring","Hybrid"],
+    ("Honda", "HR-V"): ["LX","Sport","EX","EX-L"],
+    ("Honda", "Pilot"): ["LX","EX","EX-L","Touring","Elite","TrailSport"],
+    ("Honda", "Passport"): ["Sport","EX-L","Touring","Elite","TrailSport"],
+    ("Honda", "Ridgeline"): ["Sport","RTL","RTL-E","Black Edition"],
+    ("Honda", "Insight"): ["LX","EX","Touring"],
+    ("Honda", "Fit / Jazz"): ["LX","Sport","EX","EX-L"],
+    ("Honda", "Odyssey"): ["EX","EX-L","Touring","Elite"],
+    # Volkswagen
+    ("Volkswagen", "Golf"): ["S","SE","SEL","Autobahn","GTI","R"],
+    ("Volkswagen", "Jetta"): ["S","SE","SEL","SEL Premium","GLI"],
+    ("Volkswagen", "Passat"): ["S","SE","SEL Premium","R-Line"],
+    ("Volkswagen", "Tiguan"): ["S","SE","SEL","SEL Premium","R-Line"],
+    ("Volkswagen", "Atlas"): ["S","SE","SEL","SEL Premium","Cross Sport"],
+    ("Volkswagen", "Arteon"): ["SE","SEL","SEL Premium","R-Line"],
+    ("Volkswagen", "ID.4"): ["Pro","Pro S","1st Edition"],
+    ("Volkswagen", "Tiguan (alt)"): ["S","SE","SEL","R-Line"],
+    # Nissan
+    ("Nissan", "Sentra"): ["S","SV","SR"],
+    ("Nissan", "Altima"): ["S","SV","SL","SR","Platinum"],
+    ("Nissan", "Maxima"): ["S","SV","SL","SR","Platinum"],
+    ("Nissan", "Versa"): ["S","SV","SR"],
+    ("Nissan", "Rogue"): ["S","SV","SL","Platinum"],
+    ("Nissan", "Murano"): ["S","SV","SL","Platinum"],
+    ("Nissan", "Pathfinder"): ["S","SV","SL","Platinum"],
+    ("Nissan", "Armada"): ["SV","SL","Platinum"],
+    ("Nissan", "Frontier"): ["S","SV","PRO-4X"],
+    ("Nissan", "Titan"): ["S","SV","PRO-4X","Platinum Reserve"],
+    ("Nissan", "Z"): ["Sport","Performance"],
+    ("Nissan", "GT-R"): ["Premium","NISMO","Track Edition"],
+    ("Nissan", "Qashqai / Rogue Sport"): ["S","SV","SL"],
+    ("Nissan", "X-Trail"): ["Visia","Acenta","N-Connecta","Tekna"],
+    # Hyundai
+    ("Hyundai", "Elantra"): ["SE","SEL","Limited","N Line","N"],
+    ("Hyundai", "Sonata"): ["SE","SEL","Limited","N Line"],
+    ("Hyundai", "Accent"): ["SE","SEL"],
+    ("Hyundai", "Tucson"): ["SE","SEL","Limited","N Line"],
+    ("Hyundai", "Santa Fe"): ["SE","SEL","Limited","Calligraphy"],
+    ("Hyundai", "Palisade"): ["SE","SEL","Limited","Calligraphy"],
+    ("Hyundai", "Kona"): ["SE","SEL","Limited","N Line","N"],
+    ("Hyundai", "Venue"): ["SE","SEL"],
+    ("Hyundai", "Ioniq 5"): ["SE","SEL","Limited"],
+    ("Hyundai", "Ioniq 6"): ["SE","SEL","Limited"],
+    ("Hyundai", "Santa Cruz"): ["SE","SEL","Night","Limited"],
+    # Kia
+    ("Kia", "Rio"): ["LX","S"],
+    ("Kia", "Forte"): ["LX","S","EX","GT-Line","GT"],
+    ("Kia", "K5"): ["LX","S","EX","GT-Line"],
+    ("Kia", "Stinger"): ["GT-Line","GT1","GT2"],
+    ("Kia", "Soul"): ["LX","S","EX","GT-Line"],
+    ("Kia", "Seltos"): ["LX","S","EX","SX Turbo"],
+    ("Kia", "Sportage"): ["LX","S","EX","SX Turbo"],
+    ("Kia", "Sorento"): ["LX","S","EX","SX","SX Turbo"],
+    ("Kia", "Telluride"): ["LX","S","EX","SX"],
+    ("Kia", "Carnival"): ["LX","S","EX","SX"],
+    ("Kia", "EV6"): ["Light","Wind","GT-Line"],
+    ("Kia", "Niro"): ["LX","EX","SX Touring"],
+    ("Kia", "EV9"): ["Light","Wind","Land","GT-Line"],
+    # Ford
+    ("Ford", "Fiesta"): ["S","SE","Titanium","ST"],
+    ("Ford", "Focus"): ["S","SE","SEL","Titanium","ST","RS"],
+    ("Ford", "Fusion"): ["S","SE","SEL","Titanium","Sport"],
+    ("Ford", "Mustang"): ["EcoBoost","GT","Mach 1","Shelby GT350","Shelby GT500"],
+    ("Ford", "Escape"): ["S","SE","SEL","Titanium"],
+    ("Ford", "Edge"): ["SE","SEL","Titanium","ST"],
+    ("Ford", "Explorer"): ["Base","XLT","Limited","King Ranch","Platinum","ST"],
+    ("Ford", "Expedition"): ["XLT","Limited","King Ranch","Platinum"],
+    ("Ford", "F-150"): ["Regular Cab","SuperCab","SuperCrew","Raptor","Lightning"],
+    ("Ford", "Ranger"): ["XL","XLT","Lariat"],
+    ("Ford", "Bronco"): ["Base","Big Bend","Black Diamond","Outer Banks","Badlands","Wildtrak","Raptor"],
+    ("Ford", "Maverick"): ["XL","XLT","Lariat","Tremor"],
+    ("Ford", "Bronco Sport"): ["Base","Big Bend","Outer Banks","Badlands"],
+    # Chevrolet
+    ("Chevrolet", "Spark"): ["LS","LT","Premier"],
+    ("Chevrolet", "Sonic"): ["LS","LT","Premier"],
+    ("Chevrolet", "Cruze"): ["L","LS","LT","Premier"],
+    ("Chevrolet", "Malibu"): ["L","LS","LT","Premier"],
+    ("Chevrolet", "Impala"): ["LS","LT","Premier"],
+    ("Chevrolet", "Camaro"): ["1LS","1LT","2LT","1SS","2SS","ZL1"],
+    ("Chevrolet", "Corvette"): ["1LT","2LT","3LT","Z06","ZR1"],
+    ("Chevrolet", "Trax"): ["L","LS","LT","Premier"],
+    ("Chevrolet", "Equinox"): ["L","LS","LT","Premier"],
+    ("Chevrolet", "Traverse"): ["L","LS","LT","Premier","High Country"],
+    ("Chevrolet", "Tahoe"): ["LS","LT","RST","Premier","High Country"],
+    ("Chevrolet", "Suburban"): ["LS","LT","RST","Premier","High Country"],
+    ("Chevrolet", "Blazer"): ["LT","RS","Premier"],
+    ("Chevrolet", "Trailblazer"): ["LS","LT","ACTIV","RS"],
+    ("Chevrolet", "Bolt EV"): ["1LT","2LT"],
+    ("Chevrolet", "Silverado 1500"): ["Work Truck","Custom","LT","RST","LTZ","High Country"],
+    # Lexus
+    ("Lexus", "IS"): ["300","350","500 F SPORT Performance"],
+    ("Lexus", "ES"): ["250","300h","350"],
+    ("Lexus", "GS"): ["300","350","450h","F"],
+    ("Lexus", "LS"): ["500","500h"],
+    ("Lexus", "LC"): ["500","500h"],
+    ("Lexus", "RC"): ["300","350","F"],
+    ("Lexus", "UX"): ["200","250h"],
+    ("Lexus", "NX"): ["250","350","350h","450h+"],
+    ("Lexus", "RX"): ["350","350h","500h F SPORT Performance"],
+    ("Lexus", "GX"): ["460"],
+    ("Lexus", "LX"): ["570","600"],
+    # Infiniti
+    ("Infiniti", "Q50"): ["Pure","Luxe","Sensory","Red Sport 400"],
+    ("Infiniti", "Q60"): ["Pure","Luxe","Sensory","Red Sport 400"],
+    ("Infiniti", "Q70"): ["Base","Sport"],
+    ("Infiniti", "QX50"): ["Pure","Luxe","Sensory","Autograph"],
+    ("Infiniti", "QX55"): ["Luxe","Essential","Sensory"],
+    ("Infiniti", "QX60"): ["Pure","Luxe","Sensory","Autograph"],
+    ("Infiniti", "QX80"): ["Pure","Luxe","Sensory","Autograph"],
+    # Acura
+    ("Acura", "ILX"): ["Base","Premium","A-Spec"],
+    ("Acura", "TLX"): ["Base","Technology","A-Spec","Advance","Type S"],
+    ("Acura", "RLX"): ["Base","Technology","Advance"],
+    ("Acura", "NSX"): ["Base","Type S"],
+    ("Acura", "RDX"): ["Base","Technology","A-Spec","Advance"],
+    ("Acura", "MDX"): ["Base","Technology","A-Spec","Advance","Type S"],
+    # Cadillac
+    ("Cadillac", "ATS"): ["Base","Luxury","Premium Luxury","V-Sport","V"],
+    ("Cadillac", "CTS"): ["Base","Luxury","Premium Luxury","V-Sport","V"],
+    ("Cadillac", "CT4"): ["Luxury","Premium Luxury","Sport","V-Series","V-Series Blackwing"],
+    ("Cadillac", "CT5"): ["Luxury","Premium Luxury","Sport","V-Series","V-Series Blackwing"],
+    ("Cadillac", "XTS"): ["Base","Luxury","Premium Luxury","Platinum"],
+    ("Cadillac", "XT4"): ["Luxury","Premium Luxury","Sport"],
+    ("Cadillac", "XT5"): ["Luxury","Premium Luxury","Sport"],
+    ("Cadillac", "XT6"): ["Luxury","Premium Luxury","Sport"],
+    ("Cadillac", "Escalade"): ["Luxury","Premium Luxury","Sport","V-Series"],
+    # Lincoln
+    ("Lincoln", "MKZ"): ["Premiere","Select","Reserve"],
+    ("Lincoln", "Continental"): ["Premiere","Select","Reserve","Coach Door Edition"],
+    ("Lincoln", "Corsair"): ["Base","Reserve"],
+    ("Lincoln", "Nautilus"): ["Base","Reserve"],
+    ("Lincoln", "Aviator"): ["Premiere","Reserve","Grand Touring","Black Label"],
+    ("Lincoln", "Navigator"): ["Premiere","Select","Reserve","Black Label"],
+    # Buick
+    ("Buick", "Verano"): ["Base","Convenience","Leather","Premium"],
+    ("Buick", "Regal"): ["1SV","Preferred","Essence","GS"],
+    ("Buick", "LaCrosse"): ["Base","Preferred","Essence","Premium","Avenir"],
+    ("Buick", "Encore"): ["Base","Convenience","Leather","Premium"],
+    ("Buick", "Envision"): ["Preferred","Essence","Premium","Avenir"],
+    ("Buick", "Enclave"): ["Base","Essence","Premium","Avenir"],
+    # Genesis
+    ("Genesis", "G70"): ["2.0T","2.0T Advanced","3.3T Sport","3.3T Sport Prestige"],
+    ("Genesis", "G80"): ["2.5T","2.5T Advanced","3.5T Sport","3.5T Sport Prestige"],
+    ("Genesis", "G90"): ["3.3T Premium","3.3T Prestige","5.0 Ultimate"],
+    ("Genesis", "GV70"): ["2.5T","2.5T Advanced","3.5T Sport","3.5T Sport Prestige"],
+    ("Genesis", "GV80"): ["2.5T","2.5T Advanced","3.5T","3.5T Prestige"],
+    # Tesla
+    ("Tesla", "Model S"): ["Standard Range","Long Range","Plaid"],
+    ("Tesla", "Model 3"): ["Standard Range Plus","Long Range","Performance"],
+    ("Tesla", "Model X"): ["Standard Range","Long Range","Plaid"],
+    ("Tesla", "Model Y"): ["Standard Range","Long Range","Performance"],
+    # Porsche
+    ("Porsche", "911"): ["Carrera","Carrera S","Carrera 4","Carrera 4S","Turbo","Turbo S","GT3","GT3 RS","GT2 RS"],
+    ("Porsche", "Boxster"): ["Base","S","GTS","Spyder"],
+    ("Porsche", "Cayman"): ["Base","S","GTS","GT4"],
+    ("Porsche", "Panamera"): ["Base","4","S","4S","GTS","Turbo","Turbo S"],
+    ("Porsche", "Macan"): ["Base","S","GTS","Turbo"],
+    ("Porsche", "Cayenne"): ["Base","S","GTS","Turbo","Turbo S","E-Hybrid"],
+    ("Porsche", "Taycan"): ["Base","4S","Turbo","Turbo S"],
+    # Jaguar
+    ("Jaguar", "XE"): ["Base","Premium","Prestige","R-Sport","S"],
+    ("Jaguar", "XF"): ["Premium","Prestige","R-Sport","S"],
+    ("Jaguar", "XJ"): ["Premium Luxury","Portfolio","Autobiography","XJR575"],
+    ("Jaguar", "F-TYPE"): ["Base","Premium","R-Dynamic","R","SVR"],
+    ("Jaguar", "E-PACE"): ["Base","S","SE","HSE","R-Dynamic"],
+    ("Jaguar", "F-PACE"): ["Premium","Prestige","R-Sport","S","SVR"],
+    ("Jaguar", "I-PACE"): ["S","SE","HSE","First Edition"],
+    # Land Rover
+    ("Land Rover", "Range Rover Evoque"): ["S","SE","HSE","HSE Dynamic","Autobiography"],
+    ("Land Rover", "Range Rover Velar"): ["S","SE","HSE","R-Dynamic","P380","P550"],
+    ("Land Rover", "Range Rover Sport"): ["HSE","HSE Dynamic","Autobiography","SVR"],
+    ("Land Rover", "Range Rover"): ["Base","HSE","Autobiography","SV","SVAutobiography"],
+    ("Land Rover", "Discovery Sport"): ["S","SE","HSE","HSE Luxury"],
+    ("Land Rover", "Discovery"): ["S","SE","HSE","HSE Luxury"],
+    ("Land Rover", "Defender"): ["90","110","130","X","X-Dynamic","First Edition"],
+    # Volvo
+    ("Volvo", "S60"): ["T5 Momentum","T5 R-Design","T6 R-Design","T8 Polestar"],
+    ("Volvo", "S90"): ["T5 Momentum","T6 Momentum","T6 R-Design","T8 Inscription"],
+    ("Volvo", "V60"): ["T5 Momentum","T5 R-Design","T6 R-Design","T8 Polestar"],
+    ("Volvo", "V90"): ["T5 Momentum","T6 Momentum","T6 R-Design","T8 Inscription"],
+    ("Volvo", "XC40"): ["T4 Momentum","T5 Momentum","T5 R-Design","Recharge"],
+    ("Volvo", "XC60"): ["Core","Plus","Ultimate","Polestar Engineered"],
+    ("Volvo", "XC90"): ["Momentum","R-Design","Inscription","Recharge"],
+    # MINI
+    ("Mini", "Cooper"): ["Base","Classic","Signature","Iconic","John Cooper Works"],
+    ("Mini", "Countryman"): ["Classic","Signature","Iconic","John Cooper Works"],
+    ("Mini", "Clubman"): ["Classic","Signature","Iconic","John Cooper Works"],
+    # Mazda
+    ("Mazda", "Mazda3"): ["Base","Select","Preferred","Premium","Turbo"],
+    ("Mazda", "Mazda6"): ["Sport","Touring","Grand Touring","Grand Touring Reserve","Signature"],
+    ("Mazda", "CX-3"): ["Sport","Touring","Grand Touring"],
+    ("Mazda", "CX-30"): ["S","Select","Preferred","Premium","Turbo","Turbo Premium Plus"],
+    ("Mazda", "CX-5"): ["S","Select","Preferred","Premium","Turbo","Turbo Signature"],
+    ("Mazda", "CX-50"): ["2.5 S","2.5 S Select","2.5 S Preferred","2.5 Turbo","2.5 Turbo Premium"],
+    ("Mazda", "CX-9"): ["Sport","Touring","Grand Touring","Signature","Carbon Edition"],
+    ("Mazda", "MX-5 Miata"): ["Sport","Club","Grand Touring"],
+    ("Mazda", "MX-30"): ["EV","EV Premium Plus"],
+    # Peugeot
+    ("Peugeot", "208"): ["Active","Allure","GT"],
+    ("Peugeot", "2008"): ["Active","Allure","GT"],
+    ("Peugeot", "308"): ["Active","Allure","GT"],
+    ("Peugeot", "3008"): ["Active","Allure","GT","GT Pack"],
+    ("Peugeot", "5008"): ["Active","Allure","GT"],
+    ("Peugeot", "508"): ["Active","Allure","GT","PSE"],
+    # Renault
+    ("Renault", "Clio"): ["Play","Iconic","S Edition","RS Line"],
+    ("Renault", "Megane"): ["Play","Iconic","RS Line","RS Trophy"],
+    ("Renault", "Captur"): ["Play","Iconic","S Edition","RS Line"],
+    ("Renault", "Kadjar"): ["Play","Iconic","S Edition","GT Line"],
+    ("Renault", "Arkana"): ["Iconic","S Edition","RS Line"],
+    ("Renault", "Austral"): ["Equilibre","Techno","Esprit Alpine"],
+    # Škoda / Skoda
+    ("Skoda", "Fabia"): ["S","SE","SE L","Monte Carlo"],
+    ("Skoda", "Octavia"): ["S","SE","SE L","SportLine","vRS"],
+    ("Skoda", "Superb"): ["SE","SE L","SportLine","L&K"],
+    ("Skoda", "Karoq"): ["SE Drive","SE L","SportLine"],
+    ("Skoda", "Kodiaq"): ["SE","SE L","SportLine","vRS"],
+    # SEAT
+    ("Seat", "Ibiza"): ["Reference","Style","Xcellence","FR"],
+    ("Seat", "Leon"): ["Reference","Style","Xcellence","FR","Cupra"],
+    ("Seat", "Arona"): ["Reference","Style","Xcellence","FR"],
+    ("Seat", "Ateca"): ["Reference","Style","Xcellence","FR"],
+    ("Seat", "Tarraco"): ["SE","SE Technology","Xcellence","FR"],
+    # Alfa Romeo
+    ("Alfa Romeo", "Giulia"): ["Sprint","Ti","Veloce","Quadrifoglio"],
+    ("Alfa Romeo", "Stelvio"): ["Sprint","Ti","Veloce","Quadrifoglio"],
+    ("Alfa Romeo", "Tonale"): ["Ti","Veloce","Edizione Speciale"],
+    # Citroën
+    ("Citroen", "C3"): ["Live","Feel","Shine"],
+    ("Citroen", "C4"): ["Live","Feel","Shine"],
+    ("Citroen", "C5 Aircross"): ["Feel","Shine","C-Series","Max"],
+    # Dodge
+    ("Dodge", "Charger"): ["SXT","GT","R/T","Scat Pack","SRT Hellcat"],
+    ("Dodge", "Challenger"): ["SXT","GT","R/T","Scat Pack","SRT Hellcat"],
+    ("Dodge", "Durango"): ["SXT","GT","R/T","Citadel","SRT"],
+    # Ram
+    ("Ram", "1500"): ["Tradesman","Big Horn","Laramie","Rebel","Limited"],
+    # GMC
+    ("GMC", "Terrain"): ["SLE","SLT","AT4","Denali"],
+    ("GMC", "Acadia"): ["SLE","SLT","AT4","Denali"],
+    ("GMC", "Yukon"): ["SLE","SLT","AT4","Denali"],
+    ("GMC", "Sierra 1500"): ["Pro","SLE","Elevation","SLT","AT4","Denali"],
+    # Chrysler
+    ("Chrysler", "300"): ["Touring","Touring L","S"],
+    ("Chrysler", "Pacifica"): ["Touring","Touring L","Limited","Pinnacle"],
+}
+# --------- Load + unify ----------
 def load_df():
+    if os.path.exists(CSV_MAIN):
+        return pd.read_csv(CSV_MAIN)
+    parts = sorted(glob.glob(CSV_PARTS_GLOB))
     if not parts:
         raise FileNotFoundError("Upload RideSearch_dataset.csv OR the 10 parts RideSearch_part*_small.csv.")
     df = pd.concat([pd.read_csv(p) for p in parts], ignore_index=True)
+    df.to_csv(CSV_MAIN, index=False)
     return df
+def unify_columns(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.copy()
+    # create missing columns
+    for c in ["make","model","trim_display","year","body_type","fuel","engine_type","name"]:
+        if c not in df.columns:
+            df[c] = ""
+    if df["trim_display"].isna().all() and "trim" in df.columns:
+        df["trim_display"] = df["trim"].fillna("")
+    # alias numeric score names
+    if "popularity" in df.columns and "popularity_score" not in df.columns:
+        df["popularity_score"] = df["popularity"]
+    if "comfort" in df.columns and "comfort_score" not in df.columns:
+        df["comfort_score"] = df["comfort"]
+    if "reliability" in df.columns and "reliability_score" not in df.columns:
+        df["reliability_score"] = df["reliability"]
+    if "safety" in df.columns and "safety_rating" not in df.columns:
+        df["safety_rating"] = df["safety"]
+    for c in NUM_COLS:
+        if c not in df.columns: df[c] = np.nan
+        df[c] = pd.to_numeric(df[c], errors="coerce")
+    # build text_record if missing
+    if "text_record" not in df.columns:
+        cols = ["make","model","trim_display","body_type","fuel","engine_type"]
+        df["text_record"] = df[cols].fillna("").astype(str).agg(" ".join, axis=1)
+    return df
+# --------- Fix 0–100 if broken ----------
+def suspicious_zero_to_100(series: pd.Series) -> bool:
+    s = series.dropna()
+    if len(s) < 30:  # need some mass to judge
+        return False
+    return (s.nunique() <= max(2, int(0.03*len(s)))) or (s.std() < 0.18)
+def estimate_0_100(row):
+    # Heuristic depending on hp, body, fuel, trim hints. Clamped 2.8..14.5
+    try: hp = float(row.get("horsepower", 150) or 150)
+    except Exception: hp = 150.0
+    body = str(row.get("body_type","")).lower()
+    fuel = str(row.get("fuel","")).lower()
+    trim = f"{row.get('model','')} {row.get('trim_display','')}".lower()
+    base = 26.0 - 3.2*np.log(max(hp, 60.0))  # ~10s @100hp; ~6s @300hp
+    if any(k in body for k in ["suv","crossover","pickup","truck","van"]): base += 0.7
+    if any(k in body for k in ["coupe","roadster","hatch"]): base -= 0.3
+    if "electric" in fuel or "ev" in fuel: base -= 0.8
+    if "hybrid"  in fuel: base -= 0.3
+    if "diesel"  in fuel: base += 0.2
+    if any(x in trim for x in [" m ","amg","rs","type r","sti","gts","gt3","hellcat","svr","cupra","john cooper works"]):
+        base -= 0.6
+    return float(np.clip(round(base,2), 2.8, 14.5))
+# --------- Embeddings (text + numeric) ----------
+def ensure_embeddings(df):
+    txt_ok = os.path.exists(EMB_TEXT_NPY)
+    num_ok = os.path.exists(EMB_NUM_NPY)
     if txt_ok and num_ok:
+        return np.load(EMB_TEXT_NPY), np.load(EMB_NUM_NPY)
+    # Text embeddings
     from sentence_transformers import SentenceTransformer
+    m = SentenceTransformer(EMBED_MODEL)
+    texts = df["text_record"].astype(str).tolist()
+    Etext = m.encode(texts, batch_size=256, show_progress_bar=False, normalize_embeddings=True)
+    Etext = np.asarray(Etext, dtype="float32"); np.save(EMB_TEXT_NPY, Etext)
+    # Numeric embeddings
+    X = df[NUM_COLS].copy()
+    X["zero_to_100_kmh_s"] = X["zero_to_100_kmh_s"].astype("float32")
+    X = X.fillna(X.mean(numeric_only=True))
+    Xs = StandardScaler().fit_transform(X.values.astype("float32"))
+    Enum = Xs.astype("float32"); np.save(EMB_NUM_NPY, Enum)
     return Etext, Enum
+# --------- Trims (curated + learned from CSV) ----------
+def learned_trims_from_csv(df):
+    out = {}
+    grp = df.groupby(["make","model"])
+    for (mk, md), sub in grp:
+        vals = sub["trim_display"].dropna().astype(str).value_counts().index.tolist()
+        vals = [v for v in vals if v.lower() not in ("", "nan", "none")]
+        if vals: out[(mk, md)] = vals[:20]
     return out
+def trims_for(make, model, learned):
+    key = (make, model)
+    if key in REAL_WORLD_TRIMS: return REAL_WORLD_TRIMS[key]
+    if key in learned: return learned[key]
+    return ["Base"]
+# --------- Images via Wikipedia ----------
+def wiki_image(make, model, year=None):
+    q = f"{year} {make} {model}" if year else f"{make} {model}"
+    try:
+        r = requests.get(
+            "https://en.wikipedia.org/w/api.php",
+            params={
+                "action":"query","format":"json","prop":"pageimages",
+                "piprop":"thumbnail","pithumbsize":600,
+                "generator":"search","gsrsearch":q,"gsrlimit":1,"gsrnamespace":0
+            },
+            timeout=6
+        ).json()
+        pages = r.get("query",{}).get("pages",{})
+        if pages:
+            page = next(iter(pages.values()))
+            return page.get("thumbnail",{}).get("source")
+    except Exception:
+        pass
+    return None
+# --------- Recommend ----------
+def recommend(df, Etext, Enum, make, model, trim, year, topk, alpha,
               body, fuel, y_min, y_max, p_min, p_max, safety, reliab,
+              cross_brand_only=True, exclude_same_model=True, unique_brand=True):
+    if not make or not model:
+        return "Pick a make & model first.", None, "", []
+    # anchor candidates
+    sub = df[(df["make"]==make) & (df["model"]==model)].copy()
+    if trim:
+        sub = sub[sub["trim_display"].astype(str).str.lower() == str(trim).lower()]
+    if year:
+        sub = sub[pd.to_numeric(sub["year"], errors="coerce")==int(year)]
+    if sub.empty:
+        sub = df[(df["make"]==make) & (df["model"]==model)].copy()
+        if sub.empty:
+            return "No such make/model in dataset.", None, "", []
+    a = sub.sort_values("popularity_score", ascending=False).iloc[0]
+    a_idx = int(a.name)
+    # candidate pool
+    pool = df.copy()
     if cross_brand_only:
+        pool = pool[pool["make"] != a["make"]]
     if exclude_same_model:
+        pool = pool[~((pool["make"] == a["make"]) & (pool["model"] == a["model"]))]
+    if body and body != "Any": pool = pool[pool["body_type"] == body]
+    if fuel and fuel != "Any": pool = pool[pool["fuel"] == fuel]
+    pool = pool[(pool["year"] >= y_min) & (pool["year"] <= y_max)]
+    pool = pool[(pool["price_usd"] >= p_min) & (pool["price_usd"] <= p_max)]
+    pool = pool[(pool["safety_rating"] >= safety) & (pool["reliability_score"] >= reliab)]
     if pool.empty:
+        return "No cars after your filters. Loosen price/year/safety.", None, "", []
+    cand_idx = pool.index.values
+    st = cosine_similarity(Etext[cand_idx], Etext[a_idx].reshape(1,-1)).ravel()
+    sn = cosine_similarity(Enum[cand_idx],  Enum[a_idx].reshape(1,-1)).ravel()
+    s  = float(alpha)*st + (1-float(alpha))*sn
+    order = np.argsort(-s)
+    chosen, seen = [], set()
     for j in order:
+        k = cand_idx[j]
+        brand = str(df.loc[k,"make"]).lower()
+        if unique_brand and brand in seen:
             continue
+        seen.add(brand)
+        chosen.append(k)
+        if len(chosen) >= int(topk):
             break
+    if not chosen:
+        return "No recommendations after constraints.", None, "", []
+    out = df.loc[chosen].copy()
+    out["similarity_%"] = [round(float(s[np.where(cand_idx==k)[0][0]])*100,1) for k in chosen]
+    cols = ["name","make","model","trim_display","year","body_type","fuel","engine_type",
+            "price_usd","horsepower","zero_to_100_kmh_s","popularity_score","comfort_score",
+            "reliability_score","tech_score","ownership_cost_score","safety_rating","similarity_%"]
+    table = out[[c for c in cols if c in out.columns]].reset_index(drop=True)
+    disp_trim = str(a.get("trim_display","")).strip()
+    anchor_md = (f"**{a['make']} {a['model']} {disp_trim} {int(a['year']) if pd.notna(a['year']) else ''}**  \n"
+                 f"Body: {a.get('body_type','')} • Fuel: {a.get('fuel','')} • Engine: {a.get('engine_type','')}  \n"
+                 f"HP: {int(a['horsepower']) if pd.notna(a['horsepower']) else '—'} • 0–100: {a.get('zero_to_100_kmh_s','—')}s "
+                 f"• Price: ${int(a['price_usd']) if pd.notna(a['price_usd']) else '—'}  \n"
+                 f"Popularity {int(a.get('popularity_score',0))}/10 • Comfort {int(a.get('comfort_score',0))}/10 • "
+                 f"Reliability {int(a.get('reliability_score',0))}/100 • Safety {int(a.get('safety_rating',0))}★")
+    cards = []
+    for _, r in out.head(3).iterrows():
+        img = wiki_image(r.get("make",""), r.get("model",""), r.get("year",None))
+        title = f"{r.get('make','')} {r.get('model','')} {str(r.get('trim_display','')).strip()}"
+        cards.append((img, title))
+    return None, table, anchor_md, cards
+# --------- Build UI ----------
+def build_app():
+    df = unify_columns(load_df())
+    # repair acceleration if clearly broken
+    if suspicious_zero_to_100(df["zero_to_100_kmh_s"]):
+        df["zero_to_100_kmh_s"] = df.apply(estimate_0_100, axis=1)
+    Etext, Enum = ensure_embeddings(df)
+    learned = learned_trims_from_csv(df)
+    makes = sorted(df["make"].dropna().astype(str).unique().tolist())
+    body_choices = ["Any"] + sorted([b for b in df["body_type"].dropna().astype(str).unique().tolist() if b])
+    fuel_choices = ["Any"] + sorted([f for f in df["fuel"].dropna().astype(str).unique().tolist() if f])
+    y_lo, y_hi = int(df["year"].min(skipna=True)), int(df["year"].max(skipna=True))
+    p_lo, p_hi = int(df["price_usd"].min(skipna=True)), int(df["price_usd"].max(skipna=True))
+    def models_for(make):
+        if not make: return gr.update(choices=[], value=None)
+        opts = sorted(df.loc[df["make"].eq(make), "model"].dropna().astype(str).unique().tolist())
+        return gr.update(choices=opts, value=None)
+    def trims_years_for(make, model):
+        if not make or not model:
+            return gr.update(choices=[], value=None), gr.update(choices=[], value=None)
+        trims = REAL_WORLD_TRIMS.get((make, model)) or learned.get((make, model)) or ["Base"]
+        years = sorted(pd.to_numeric(df[(df["make"]==make)&(df["model"]==model)]["year"], errors="coerce").dropna().astype(int).unique().tolist())
+        return gr.update(choices=trims, value=None), gr.update(choices=[None]+years, value=None)
+    with gr.Blocks(theme=gr.themes.Soft(), title="RideSearch") as demo:
+        gr.Markdown("## RideSearch — cross‑brand recommendations with realistic trims & photos")
         with gr.Tab("Pick & Recommend"):
             with gr.Row():
+                mk = gr.Dropdown(makes, label="Make")
+                md = gr.Dropdown([], label="Model")
+                tr = gr.Dropdown([], label="Trim (optional)")
+                yr = gr.Dropdown([], label="Year (optional)")
             mk.change(models_for, mk, md)
+            md.change(lambda a,b: trims_years_for(a,b), [mk, md], [tr, yr])
             with gr.Row():
+                body = gr.Dropdown(body_choices, value="Any", label="Body")
+                fuel = gr.Dropdown(fuel_choices, value="Any", label="Fuel")
             with gr.Row():
+                y_min = gr.Slider(y_lo, y_hi, value=max(y_lo, y_lo), step=1, label="Year min")
+                y_max = gr.Slider(y_lo, y_hi, value=y_hi, step=1, label="Year max")
             with gr.Row():
+                p_min = gr.Slider(p_lo, p_hi, value=p_lo, step=500, label="Price min (USD)")
+                p_max = gr.Slider(p_lo, p_hi, value=min(p_hi, max(p_lo+15000, p_lo+5000)), step=500, label="Price max (USD)")
             with gr.Row():
+                safety = gr.Slider(3, 5, value=4, step=1, label="Min Safety ★")
+                reliab = gr.Slider(55, 99, value=70, step=1, label="Min Reliability")
             with gr.Row():
+                topk = gr.Slider(1, 10, value=5, step=1, label="Recommendations")
+                alpha = gr.Slider(0, 1, value=0.7, step=0.05, label="α — Text vs Numeric")
             with gr.Row():
+                cross = gr.Checkbox(True, label="Cross‑brand only")
+                xmodel = gr.Checkbox(True, label="Exclude same model family")
+                uniqb = gr.Checkbox(True, label="Unique brands (no repeats)")
+            run = gr.Button("Recommend", variant="primary")
+            err = gr.Markdown()
+            anchor_md = gr.Markdown()
+            table = gr.Dataframe(interactive=False, wrap=True, label="Recommendations")
+            gallery = gr.Gallery(label="Photos", height=220, columns=[3])
+            def on_click(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o):
+                msg, tbl, atext, cards = recommend(
+                    df, Etext, Enum, a,b,c,d,e,f,int(g),int(h),int(i),int(j),int(k),int(l),
+                    cross_brand_only=m, exclude_same_model=n, unique_brand=o
+                )
+                if msg:
+                    return gr.update(value=f"**{msg}**"), gr.update(value=""), pd.DataFrame(), []
+                return gr.update(value=""), gr.update(value=atext), tbl, cards
+            run.click(on_click,
+                      [mk, md, tr, yr, topk, alpha, body, fuel, y_min, y_max, p_min, p_max, safety, reliab, cross, xmodel, uniqb],
+                      [err, anchor_md, table, gallery])
+        gr.Markdown("Tip: First run may be slower (embeddings build). Next runs are fast.")
+    return demo
 if __name__ == "__main__":
+    demo = build_app()
     demo.queue().launch(server_name="0.0.0.0", server_port=7860)