app.py

#!/usr/bin/env python3
"""
app.py — Gradio Sandbox for V7 Elite Ranker
HuggingFace Spaces compatible. Upload ≤100 candidates → get ranked CSV.
"""

import json
import csv
import sys
import time
import tempfile
import traceback
from pathlib import Path
from io import StringIO

import numpy as np
import pandas as pd
import gradio as gr

# Ensure lib/ is importable
sys.path.insert(0, str(Path(__file__).resolve().parent))

from lib import schema, features, honeypot, embeddings as emb_mod, scoring, reasoning
from lib.jd_parser import get_jd
from lib.hiring_intent import get_intent
from lib.query_expansion import get_expanded_text
from precompute import extract_features_v7

TOP_N = 100

# ── Built-in 10-candidate sample for quick demo ──────────────────────────
SAMPLE_CANDIDATES = [
    {
        "candidate_id": "CAND_0001001",
        "profile": {
            "anonymized_name": "Demo Elite", "headline": "Senior AI Engineer | RAG, Vector Search, Ranking",
            "summary": "8 years building production search and ranking systems. Led the recommendation engine at Razorpay serving 50M+ users. Deep expertise in embeddings, hybrid retrieval, and LLM fine-tuning. Shipped end-to-end systems from data pipeline to production API.",
            "location": "Bangalore", "country": "India", "years_of_experience": 8.2,
            "current_title": "Lead AI Engineer", "current_company": "Razorpay",
            "current_company_size": "1001-5000", "current_industry": "Fintech",
            "notice_period_days": 15, "open_to_relocation": True,
            "expected_salary_range_inr_lpa": {"min": 55, "max": 75},
            "recruiter_response_rate": 0.85, "days_since_last_active": 2,
            "platform_trust_score": 0.9, "interview_completion_rate": 0.8,
        },
        "career_history": [
            {"company": "Razorpay", "title": "Lead AI Engineer", "start_date": "2022-03-01", "end_date": None,
             "duration_months": 38, "is_current": True, "industry": "Fintech", "company_size": "1001-5000",
             "description": "Built and owned the hybrid vector search ranking system serving 50M+ users. Designed the two-tower retrieval pipeline with FAISS, implemented learning-to-rank with XGBoost, and fine-tuned BGE embeddings for domain-specific retrieval. Reduced search latency by 40% while improving NDCG@10 by 15%. Managed a team of 3 engineers."},
            {"company": "Amazon", "title": "SDE II", "start_date": "2018-06-01", "end_date": "2022-02-28",
             "duration_months": 45, "is_current": False, "industry": "E-commerce", "company_size": "10001+",
             "description": "Worked on A9 product search ranking. Implemented query understanding features and built the candidate generation pipeline for product search. Used Word2Vec embeddings for product similarity and improved search relevance metrics."},
            {"company": "Flipkart", "title": "SDE I", "start_date": "2016-07-01", "end_date": "2018-05-31",
             "duration_months": 23, "is_current": False, "industry": "E-commerce", "company_size": "10001+",
             "description": "Built data pipelines for the recommendation system. Worked on collaborative filtering and content-based recommendation algorithms using Python and Spark."}
        ],
        "education": [{"institution": "IIT Bombay", "degree": "B.Tech", "field_of_study": "Computer Science",
                        "start_year": 2012, "end_year": 2016, "grade": "9.1 CGPA", "tier": "tier_1"}],
        "skills": [{"name": "Python", "proficiency": "expert", "duration_months": 96},
                   {"name": "Machine Learning", "proficiency": "expert", "duration_months": 84},
                   {"name": "Vector Search", "proficiency": "advanced", "duration_months": 42},
                   {"name": "RAG", "proficiency": "advanced", "duration_months": 30},
                   {"name": "Embeddings", "proficiency": "expert", "duration_months": 60},
                   {"name": "FAISS", "proficiency": "advanced", "duration_months": 36},
                   {"name": "XGBoost", "proficiency": "advanced", "duration_months": 72},
                   {"name": "LLM Fine-tuning", "proficiency": "advanced", "duration_months": 24}],
        "assessments": [{"name": "ML System Design", "score": 92, "completed": True}],
        "endorsements_count": 28, "github_profile": {"has_public_repos": True, "public_repo_count": 12, "stargazers_total": 450}
    },
    {
        "candidate_id": "CAND_0001002",
        "profile": {
            "anonymized_name": "LangChain Tourist", "headline": "AI Developer | LangChain, OpenAI, ChatGPT",
            "summary": "Recently transitioned to AI development. Built multiple LangChain prototypes and RAG chatbots using OpenAI APIs. Passionate about generative AI.",
            "location": "Mumbai", "country": "India", "years_of_experience": 4.5,
            "current_title": "AI Developer", "current_company": "TCS",
            "current_company_size": "10001+", "current_industry": "IT Services",
            "notice_period_days": 90, "open_to_relocation": False,
            "expected_salary_range_inr_lpa": {"min": 25, "max": 40},
            "recruiter_response_rate": 0.15, "days_since_last_active": 180,
            "platform_trust_score": 0.4, "interview_completion_rate": 0.0,
        },
        "career_history": [
            {"company": "TCS", "title": "AI Developer", "start_date": "2024-01-01", "end_date": None,
             "duration_months": 18, "is_current": True, "industry": "IT Services", "company_size": "10001+",
             "description": "Building RAG chatbots using LangChain and OpenAI APIs for internal clients. Created a proof-of-concept document Q&A system using GPT-4 and Pinecone."},
            {"company": "Infosys", "title": "Software Engineer", "start_date": "2021-07-01", "end_date": "2023-12-31",
             "duration_months": 30, "is_current": False, "industry": "IT Services", "company_size": "10001+",
             "description": "Java backend development for enterprise clients. Built REST APIs and maintained legacy systems."}
        ],
        "education": [{"institution": "VTU", "degree": "B.E.", "field_of_study": "Information Science",
                        "start_year": 2017, "end_year": 2021, "grade": "7.2 CGPA", "tier": "tier_3"}],
        "skills": [{"name": "Python", "proficiency": "intermediate", "duration_months": 42},
                   {"name": "LangChain", "proficiency": "advanced", "duration_months": 14},
                   {"name": "OpenAI API", "proficiency": "advanced", "duration_months": 14},
                   {"name": "RAG", "proficiency": "intermediate", "duration_months": 10},
                   {"name": "Pinecone", "proficiency": "intermediate", "duration_months": 8}],
        "endorsements_count": 3, "github_profile": {"has_public_repos": False, "public_repo_count": 0, "stargazers_total": 0}
    },
    {
        "candidate_id": "CAND_0001003",
        "profile": {
            "anonymized_name": "HR Manager Trap", "headline": "HR Manager | Recruitment, Talent Acquisition",
            "summary": "Experienced HR manager with 12 years in talent acquisition and recruitment. Recently completed a Coursera course on AI.",
            "location": "Delhi", "country": "India", "years_of_experience": 12.0,
            "current_title": "HR Manager", "current_company": "Wipro",
            "current_company_size": "10001+", "current_industry": "IT Services",
            "notice_period_days": 60, "open_to_relocation": False,
            "expected_salary_range_inr_lpa": {"min": 20, "max": 35},
            "recruiter_response_rate": 0.9, "days_since_last_active": 1,
            "platform_trust_score": 0.8, "interview_completion_rate": 0.5,
        },
        "career_history": [
            {"company": "Wipro", "title": "HR Manager", "start_date": "2019-01-01", "end_date": None,
             "duration_months": 77, "is_current": True, "industry": "IT Services", "company_size": "10001+",
             "description": "Managing end-to-end recruitment for the AI/ML division. Hiring 50+ engineers per quarter. Completed Coursera AI for Everyone course."},
            {"company": "Infosys", "title": "Talent Acquisition Lead", "start_date": "2014-01-01", "end_date": "2018-12-31",
             "duration_months": 60, "is_current": False, "industry": "IT Services", "company_size": "10001+",
             "description": "Led campus and lateral hiring for technology roles."}
        ],
        "education": [{"institution": "Delhi University", "degree": "MBA", "field_of_study": "HR",
                        "start_year": 2012, "end_year": 2014, "grade": "7.5 CGPA", "tier": "tier_2"}],
        "skills": [{"name": "Recruitment", "proficiency": "expert", "duration_months": 144},
                   {"name": "Machine Learning", "proficiency": "beginner", "duration_months": 2},
                   {"name": "Python", "proficiency": "beginner", "duration_months": 3}],
        "endorsements_count": 45, "github_profile": {"has_public_repos": False, "public_repo_count": 0, "stargazers_total": 0}
    },
    {
        "candidate_id": "CAND_0001004",
        "profile": {
            "anonymized_name": "Pre-LLM Veteran", "headline": "Staff ML Engineer | IR, Ranking, Recommendations",
            "summary": "10 years in information retrieval and ranking. Built search engines at Microsoft and recommendation systems at Netflix before the LLM era. Deep expertise in classic IR: BM25, learning-to-rank, two-tower models, approximate nearest neighbor search.",
            "location": "Pune", "country": "India", "years_of_experience": 10.5,
            "current_title": "Staff ML Engineer", "current_company": "Sarvam AI",
            "current_company_size": "51-200", "current_industry": "AI/ML",
            "notice_period_days": 20, "open_to_relocation": True,
            "expected_salary_range_inr_lpa": {"min": 60, "max": 85},
            "recruiter_response_rate": 0.70, "days_since_last_active": 5,
            "platform_trust_score": 0.85, "interview_completion_rate": 0.75,
        },
        "career_history": [
            {"company": "Sarvam AI", "title": "Staff ML Engineer", "start_date": "2023-06-01", "end_date": None,
             "duration_months": 36, "is_current": True, "industry": "AI/ML", "company_size": "51-200",
             "description": "Leading the retrieval and ranking infrastructure for Indic language AI products. Built the hybrid retrieval pipeline combining sparse BM25 with dense BGE embeddings. Designed the evaluation framework with NDCG@10 and MRR metrics. Owns the entire ranking stack end-to-end."},
            {"company": "Microsoft", "title": "Senior SDE", "start_date": "2018-04-01", "end_date": "2023-05-31",
             "duration_months": 62, "is_current": False, "industry": "Technology", "company_size": "10001+",
             "description": "Core contributor to Bing's document ranking pipeline. Implemented learning-to-rank features using LambdaMART. Built the query understanding module using transformer-based re-ranking. Optimized serving latency for 100+ billion document index."},
            {"company": "Netflix", "title": "ML Engineer", "start_date": "2015-01-01", "end_date": "2018-03-31",
             "duration_months": 39, "is_current": False, "industry": "Entertainment", "company_size": "10001+",
             "description": "Built the recommendation ranking model for the home page. Worked on collaborative filtering, content-based filtering, and hybrid approaches. Improved click-through rate by 12% through better candidate generation and re-ranking."}
        ],
        "education": [{"institution": "IIT Delhi", "degree": "M.Tech", "field_of_study": "Computer Science",
                        "start_year": 2013, "end_year": 2015, "grade": "9.4 CGPA", "tier": "tier_1"}],
        "skills": [{"name": "Python", "proficiency": "expert", "duration_months": 126},
                   {"name": "Machine Learning", "proficiency": "expert", "duration_months": 120},
                   {"name": "Information Retrieval", "proficiency": "expert", "duration_months": 120},
                   {"name": "Learning to Rank", "proficiency": "expert", "duration_months": 84},
                   {"name": "Vector Search", "proficiency": "expert", "duration_months": 48},
                   {"name": "Embeddings", "proficiency": "expert", "duration_months": 72},
                   {"name": "FAISS", "proficiency": "advanced", "duration_months": 36},
                   {"name": "BM25", "proficiency": "expert", "duration_months": 96}],
        "assessments": [{"name": "System Design", "score": 88, "completed": True}],
        "endorsements_count": 52, "github_profile": {"has_public_repos": True, "public_repo_count": 18, "stargazers_total": 1200}
    },
    {
        "candidate_id": "CAND_0001005",
        "profile": {
            "anonymized_name": "Graphic Designer", "headline": "Senior Graphic Designer | Adobe, Figma, AI Art",
            "summary": "Creative professional with 7 years in graphic design. Recently started using Midjourney and DALL-E for AI art generation. Interested in AI roles.",
            "location": "Hyderabad", "country": "India", "years_of_experience": 7.0,
            "current_title": "Senior Graphic Designer", "current_company": "Accenture",
            "current_company_size": "10001+", "current_industry": "IT Services",
            "notice_period_days": 45, "open_to_relocation": False,
            "expected_salary_range_inr_lpa": {"min": 15, "max": 25},
            "recruiter_response_rate": 0.50, "days_since_last_active": 30,
            "platform_trust_score": 0.6, "interview_completion_rate": 0.3,
        },
        "career_history": [
            {"company": "Accenture", "title": "Senior Graphic Designer", "start_date": "2021-01-01", "end_date": None,
             "duration_months": 53, "is_current": True, "industry": "IT Services", "company_size": "10001+",
             "description": "Leading design projects for Fortune 500 clients. Using AI tools like Midjourney and DALL-E for rapid prototyping."},
            {"company": "Ogilvy", "title": "Graphic Designer", "start_date": "2018-06-01", "end_date": "2020-12-31",
             "duration_months": 31, "is_current": False, "industry": "Advertising", "company_size": "10001+",
             "description": "Created visual campaigns for major brands."}
        ],
        "education": [{"institution": "NID", "degree": "B.Des", "field_of_study": "Graphic Design",
                        "start_year": 2014, "end_year": 2018, "grade": "8.5 CGPA", "tier": "tier_1"}],
        "skills": [{"name": "Adobe Creative Suite", "proficiency": "expert", "duration_months": 84},
                   {"name": "Figma", "proficiency": "advanced", "duration_months": 48},
                   {"name": "Machine Learning", "proficiency": "beginner", "duration_months": 6},
                   {"name": "Python", "proficiency": "beginner", "duration_months": 8}],
        "endorsements_count": 35, "github_profile": {"has_public_repos": False, "public_repo_count": 0, "stargazers_total": 0}
    },
]


def load_candidates_from_upload(file_obj) -> list[dict]:
    """Load candidates from uploaded file (JSONL, JSON array, or .jsonl.gz)."""
    if file_obj is None:
        return []

    path = Path(file_obj.name if hasattr(file_obj, "name") else str(file_obj))
    suffix = path.suffix.lower()

    # JSON array format
    if suffix == ".json":
        with open(file_obj.name, "r", encoding="utf-8") as f:
            data = json.load(f)
        if isinstance(data, list):
            return data
        elif isinstance(data, dict):
            return [data]
        return []

    # JSONL format
    candidates = []
    import gzip
    if suffix == ".gz":
        opener = gzip.open
    else:
        opener = open

    with opener(file_obj.name, "rt", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if not line or line.startswith("#") or line.startswith("candidate_id,"):
                continue
            try:
                candidates.append(json.loads(line))
            except json.JSONDecodeError:
                continue

    return candidates


def run_ranking(candidates: list[dict]) -> tuple[str, str, str, str]:
    """Run the full V7 pipeline on candidates. Returns (csv_text, stats, logs, csv_path)."""
    t0 = time.time()
    logs = []

    if not candidates:
        return "", "No candidates loaded.", "", ""

    n = len(candidates)
    log = f"[sandbox] Loaded {n} candidates"
    logs.append(log)
    print(log)

    if n > 100:
        log = f"[sandbox] WARNING: {n} > 100 limit. Truncating to first 100."
        logs.append(log)
        print(log)
        candidates = candidates[:100]

    # ── Step 1: Feature Extraction ─────────────────────────────────────
    t1 = time.time()
    log = "[sandbox] Step 1/3: Extracting V7 features..."
    logs.append(log)
    print(log)

    rows = []
    texts = []
    for c in candidates:
        row = extract_features_v7(c)
        rows.append(row)
        texts.append(schema.unified_text_blob(c))

    log = f"[sandbox] Extracted features for {len(rows)} candidates in {time.time()-t1:.1f}s"
    logs.append(log)
    print(log)

    # ── Step 2: TF-IDF + SVD Embeddings ────────────────────────────────
    t2 = time.time()
    log = "[sandbox] Step 2/3: Computing TF-IDF+SVD embeddings..."
    logs.append(log)
    print(log)

    jd = get_jd()
    expanded_ideal = get_expanded_text(jd.ideal_text)
    all_texts = texts + [expanded_ideal]
    n_components = min(100, len(all_texts) - 1)
    embedder = emb_mod.TfidfSvdEmbedder(n_components=max(n_components, 2))
    embedder.fit(all_texts)
    doc_emb = embedder.transform(all_texts)[:len(texts)]
    sims = embedder.similarity_to_query(doc_emb, expanded_ideal)
    for row, sim in zip(rows, sims):
        row["embedding_sim"] = float(sim)

    df = pd.DataFrame(rows)
    log = f"[sandbox] Embeddings computed in {time.time()-t2:.1f}s ({len(df.columns)} features)"
    logs.append(log)
    print(log)

    # ── Step 3: Scoring + Ranking ──────────────────────────────────────
    t3 = time.time()
    log = "[sandbox] Step 3/3: Scoring and ranking..."
    logs.append(log)
    print(log)

    # Print hiring intent
    try:
        intent = get_intent()
        log = (f"[sandbox] Hiring Intent: {intent.philosophy} | "
               f"ownership={intent.ownership_expectation:.2f} | "
               f"need={intent.primary_need} | team={intent.team_context}")
        logs.append(log)
        print(log)
    except Exception as e:
        log = f"[sandbox] Warning: hiring intent failed: {e}"
        logs.append(log)

    # Compute scores
    elite = scoring.elite_score_vec(df)
    final = scoring.final_score_vec(df)
    df = df.assign(elite_score=elite.values, raw_score=final.values)

    top_n = min(TOP_N, len(df))
    top = df.sort_values("raw_score", ascending=False).head(top_n).copy()

    # Sigmoid stretch
    raw = top["raw_score"].values.astype(float)
    raw_min, raw_max = raw.min(), raw.max()
    if raw_max > raw_min:
        norm = (raw - raw_min) / (raw_max - raw_min)
        stretched = 1.0 / (1.0 + np.exp(-10.0 * (norm - 0.5)))
        final_scores = 0.52 + 0.47 * stretched
    else:
        final_scores = np.full(top_n, 0.75)

    top["score"] = final_scores
    top["score"] = top["score"].round(6)
    top = top.sort_values(["score", "candidate_id"], ascending=[False, True]).reset_index(drop=True)
    top["rank"] = top.index + 1

    honeypots_in_top = int(top["is_honeypot"].sum())
    scores = top["score"].values

    # Generate reasoning
    log = f"[sandbox] Generating reasoning for {top_n} candidates..."
    logs.append(log)
    print(log)

    t_reason = time.time()
    out_rows = []
    for _, row in top.iterrows():
        cid = row["candidate_id"]
        candidate = json.loads(row["_candidate_json"])
        disq_reasons = json.loads(row["_disq_reasons"])
        beh_evidence = json.loads(row["_behaviour_evidence"])
        narrative_suspicious = json.loads(row.get("narrative_suspicious", "[]"))

        feat = {
            "current_title": row["current_title"],
            "current_company": row["current_company"],
            "years_of_experience": row["years_of_experience"],
            "skill_coverage": float(row.get("skill_coverage", 0)),
            "impact_magnitude": float(row.get("impact_magnitude", 0)),
            "ownership_hierarchy": float(row.get("ownership_hierarchy", 0)),
            "evaluation_experience": float(row.get("evaluation_experience", 0)),
            "pre_llm_months": float(row.get("pre_llm_months", 0)),
            "evidence_strength": float(row.get("evidence_strength", 0)),
            "notice_period_days": beh_evidence.get("notice_period_days", 45),
            "days_since_active": beh_evidence.get("days_since_active", 90),
            "recruiter_response_rate": beh_evidence.get("recruiter_response_rate", 0.3),
            "disqualifier_reasons": disq_reasons,
            "tier5_signature": float(row.get("tier5_signature", 0)),
            "behavioral_twin_penalty": float(row.get("behavioral_twin_penalty", 1.0)),
            "langchain_only_penalty": float(row.get("langchain_only_penalty", 1.0)),
            "closed_source_penalty": float(row.get("closed_source_penalty", 1.0)),
            "pre_llm_x_ownership": float(row.get("pre_llm_x_ownership", 0)),
            "salary_compatibility": float(row.get("salary_compatibility", 0.7)),
            "is_honeypot": bool(row.get("is_honeypot", False)),
            "assessment_signal": float(row.get("assessment_signal", 0.5)),
            "endorsement_signal": float(row.get("endorsement_signal", 0.5)),
            "education_tier": float(row.get("education_tier", 0.5)),
            "cross_validation": float(row.get("cross_validation", 0.5)),
            "_candidate_json": row.get("_candidate_json", "{}"),
            "_beh_twin_evidence": row.get("_beh_twin_evidence", "{}"),
            "_langchain_evidence": row.get("_langchain_evidence", "{}"),
            "_closed_source_evidence": row.get("_closed_source_evidence", "{}"),
            "_salary_evidence": row.get("_salary_evidence", "{}"),
            "_assessment_evidence": row.get("_assessment_evidence", "{}"),
            "_endorsement_evidence": row.get("_endorsement_evidence", "{}"),
            "_education_evidence": row.get("_education_evidence", "{}"),
        }
        text = reasoning.generate(cid, candidate, feat, narrative_suspicious)
        out_rows.append({
            "candidate_id": cid,
            "rank": int(row["rank"]),
            "score": f'{row["score"]:.6f}',
            "reasoning": text,
        })

    log = f"[sandbox] Reasoning generated in {time.time()-t_reason:.1f}s"
    logs.append(log)
    print(log)

    # Build CSV string
    csv_buf = StringIO()
    writer = csv.DictWriter(csv_buf, fieldnames=["candidate_id", "rank", "score", "reasoning"])
    writer.writeheader()
    writer.writerows(out_rows)
    csv_text = csv_buf.getvalue()

    # Write temp file for download
    tmp_path = Path(tempfile.gettempdir()) / "sandbox_submission.csv"
    with open(tmp_path, "w", encoding="utf-8") as f:
        f.write(csv_text)

    # Stats
    total_time = time.time() - t0
    unique_scores = len(set(scores))
    non_mono = sum(1 for i in range(len(scores) - 1) if scores[i] < scores[i + 1])
    honeypots_total = int(df["is_honeypot"].sum())

    stats = (
        f"**Pipeline Stats**\n\n"
        f"| Metric | Value |\n|---|---|\n"
        f"| Candidates input | {n} |\n"
        f"| Candidates ranked | {top_n} |\n"
        f"| Honeypots detected | {honeypots_total} / {n} |\n"
        f"| Honeypots in top {top_n} | {honeypots_in_top} |\n"
        f"| Score range | {scores[0]:.6f} → {scores[-1]:.6f} |\n"
        f"| Unique scores | {unique_scores} / {top_n} |\n"
        f"| Monotonicity violations | {non_mono} |\n"
        f"| Total time | {total_time:.1f}s |\n"
        f"| Under 5-min budget | {'✅ Yes' if total_time < 300 else '❌ No'} |\n"
    )

    top5_table = "| Rank | Candidate ID | Score | Title | Company |\n|---|---|---|---|---|\n"
    for _, row in top.head(5).iterrows():
        top5_table += f"| {int(row['rank'])} | {row['candidate_id']} | {row['score']:.6f} | {row['current_title']} | {row['current_company']} |\n"
    stats += f"\n\n**Top 5 Candidates**\n\n{top5_table}"

    log = f"[sandbox] Total time: {total_time:.1f}s — CSV ready for download"
    logs.append(log)
    print(log)

    # Return pandas DataFrame for Gradio Dataframe component
    result_df = pd.DataFrame(out_rows)
    return result_df, stats, "\n".join(logs), str(tmp_path)


def on_upload_and_rank(file_obj):
    """Handle file upload + rank button."""
    if file_obj is None:
        return pd.DataFrame(columns=["candidate_id", "rank", "score", "reasoning"]), "", "", None

    try:
        candidates = load_candidates_from_upload(file_obj)
        if not candidates:
            return pd.DataFrame(columns=["candidate_id", "rank", "score", "reasoning"]), "No valid candidates found in file. Use JSONL (one JSON per line) or JSON array format.", "", None
        return run_ranking(candidates)
    except Exception as e:
        tb = traceback.format_exc()
        return pd.DataFrame(columns=["candidate_id", "rank", "score", "reasoning"]), f"ERROR: {e}\n\n{tb}", "", None


def on_demo_rank():
    """Run with built-in 5-candidate demo set."""
    return run_ranking(SAMPLE_CANDIDATES)


# ── Gradio UI ───────────────────────────────────────────────────────────

with gr.Blocks(
    title="V7 Elite Ranker — Redrob Hackathon Sandbox",
    theme=gr.themes.Soft(),
) as demo:

    gr.Markdown(
        """
        # V7 Elite Ranker — Hackathon Sandbox

        **Redrob AI Hackathon:** India Runs Data & AI Challenge
        **Role:** Senior AI Engineer — Founding Team

        Upload a candidate file (≤100 candidates) or use the built-in demo to see the ranking pipeline in action.
        The sandbox runs the **exact same code** that runs at Stage 3 reproduction.
        """
    )

    with gr.Row():
        with gr.Column(scale=1):
            gr.Markdown("### Input")
            file_input = gr.File(
                label="Upload Candidates (.jsonl, .json, .jsonl.gz)",
                file_types=[".json", ".jsonl", ".gz"],
            )
            gr.Markdown(
                """
                **Accepted formats:**
                - `.jsonl` — one JSON object per line
                - `.json` — JSON array of candidate objects
                - `.jsonl.gz` — gzipped JSONL
                - Max **100 candidates** (sandbox limit)

                **Or click "Run Demo" to use 5 built-in test candidates** (1 elite, 1 LangChain tourist, 1 HR trap, 1 pre-LLM veteran, 1 graphic designer).
                """
            )
            with gr.Row():
                btn_demo = gr.Button("Run Demo (5 Candidates)", variant="secondary")
                btn_run = gr.Button("Rank Uploaded File", variant="primary")

            gr.Markdown("### Logs")
            log_output = gr.Textbox(label="Pipeline Logs", lines=12, interactive=False, max_lines=20)

        with gr.Column(scale=2):
            gr.Markdown("### Output")
            stats_output = gr.Markdown(label="Stats")
            csv_output = gr.Dataframe(
                label="Ranked Candidates (submission.csv)",
                headers=["candidate_id", "rank", "score", "reasoning"],
                interactive=False,
            )
            download_btn = gr.File(
                label="Download submission.csv",
                interactive=False,
            )

    gr.Markdown(
        """
        ---
        ### Pipeline Architecture

        ```
        candidates.jsonl → Feature Extraction (55 features) → TF-IDF+SVD Embeddings
        → Intent-Aware Scoring (Impact 42% + Ownership 33% + Search 15% + Behaviour 10%)
        → 4 Additive Boosts → 5 Multiplicative Penalties → Honeypot ×0.01
        → 13-term Tiebreaker → Sigmoid Stretch → Evidence-Graph Reasoning
        → submission.csv
        ```

        **Constraints met:** CPU-only | No network | <5 min | ≤16 GB RAM | Deterministic
        """
    )

    # Wire up events
    btn_demo.click(fn=on_demo_rank, outputs=[csv_output, stats_output, log_output, download_btn])
    btn_run.click(fn=on_upload_and_rank, inputs=[file_input], outputs=[csv_output, stats_output, log_output, download_btn])


if __name__ == "__main__":
    demo.launch(
        server_name="0.0.0.0",
        server_port=7860,
    )