Update app.py

app.py

@@ -1,458 +1,848 @@
-import os
-import io
-import json
-import random
-import tempfile
-import smtplib
-from email.message import EmailMessage
-from datetime import datetime, timedelta, timezone
-from fastapi import FastAPI, UploadFile, Form, Request
-from fastapi.responses import JSONResponse
-from starlette.middleware.cors import CORSMiddleware
-from sentence_transformers import SentenceTransformer, util
-from PyPDF2 import PdfReader
 import gradio as gr
-import torch
-import pytz
-from dropbox_utils import upload_to_dropbox
-import asyncio
-os.environ["HF_HOME"] = "/app/cache"
-os.environ["TRANSFORMERS_CACHE"] = "/app/cache"
-os.environ["HF_DATASETS_CACHE"] = "/app/cache"
-
-smtp_user = os.getenv("SMTP_USER")
-smtp_pass = os.getenv("SMTP_PASS")
-if not smtp_user or not smtp_pass:
-    raise EnvironmentError("SMTP credentials are not set in environment variables.")
-
-
-# Setup model cache path
-# os.environ["TRANSFORMERS_CACHE"] = os.environ.get("TRANSFORMERS_CACHE", "/app/cache")
-# os.environ["HF_HOME"] = os.environ.get("HF_HOME", "/app/cache")
-
-# === Profile Save/Load ===
-PROFILE_DIR = os.path.join(os.getenv("HF_HOME", "/app/cache"), "user_profiles")
-os.makedirs(PROFILE_DIR, exist_ok=True)
-
-def test_writable_dirs():
-    for path in ["/app/cache", PROFILE_DIR, "/tmp"]:
-        print(f"🔍 Checking write permission for: {path}")
-        if os.access(path, os.W_OK):
-            print("✅ Writable")
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+import pandas as pd
+import numpy as np
+import os
+from datetime import datetime
+import socket
+import nltk
+#nltk.download("all")
+
+
+# For sentence tokenization
+nltk.download('punkt')
+nltk.download("punkt_tab")
+###############################
+#  LOGGING SETUP
+###############################
+log_file_path = os.path.expanduser("~/Second_Opinion_Logs.log")
+
+if not os.path.exists(log_file_path):
+    with open(log_file_path, mode='w') as log_file:
+        log_file.write("Timestamp (GMT) - IP: [IP Address] - [Action]\n")
+
+def log_action(action, request=None):
+    """
+    Logs major actions with IP address and UTC timestamp.
+    """
+    try:
+        user_ip = "Unknown IP"
+        if request and hasattr(request, 'client'):
+            user_ip = request.client.host
         else:
-            print("❌ Not writable")
-
-test_writable_dirs()
-# from huggingface_hub import login
+            user_ip = socket.gethostbyname(socket.gethostname())
+            if user_ip in ("127.0.0.1", "::1"):
+                user_ip = "Localhost (127.0.0.1)"
+    except Exception:
+        user_ip = "Unknown IP"
 
-# # Load HF token and login
-hf_token = os.environ.get("HUGGINGFACE_HUB_TOKEN")
-# if hf_token:
-#     login(token=hf_token, add_to_git_credential=False, write_permission=False)
+    timestamp = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+    log_entry = f"{timestamp} (GMT) - IP: {user_ip} - {action}\n"
 
-# === Load Model with CUDA if available and safe cache ===
-device = "cuda" if torch.cuda.is_available() else "cpu"
-print(f"🚀 Loading SentenceTransformer on: {device}")
-
-
-
-
-# === Define Cohorts ===
-COHORTS = {
-    "consulting": "Management consulting, strategy, analytics, client interaction",
-    "bfsi": "Banking, finance, investment analysis, risk, fintech",
-    "sales": "Sales, business development, GTM strategy, CRM, channel sales",
-    "it": "Software development, cloud, AI/ML, backend systems",
-    "hr": "Human resources, L&D, talent acquisition, HRBP",
-    "legal": "Contracts, litigation, compliance, intellectual property",
-    "scm": "Logistics, procurement, inventory, operations, manufacturing",
-    "bpo": "Customer service, support, inbound/outbound calling, operations"
-}
-
-
-# === Helper to extract text from PDF ===
-def extract_text(file):
-    reader = PdfReader(file)
-    return "\n".join([page.extract_text() or "" for page in reader.pages])
-
-# === Gradio UI function for resume match ===
-def match_resume(resume_pdf, job_description):
-    text = extract_text(resume_pdf)
-    resume_emb = model.encode(text, convert_to_tensor=True)
-    jd_emb = model.encode(job_description, convert_to_tensor=True)
-    score = util.cos_sim(jd_emb, resume_emb).item() * 100
-    label = "✅ Strong Match" if score > 70 else "⚠️ Needs Tailoring"
-    return f"Match Score: {round(score, 2)}%\n\n{label}"
-
-demo = gr.Interface(
-    fn=match_resume,
-    inputs=[
-        gr.File(label="Upload Resume PDF", file_types=[".pdf"]),
-        gr.Textbox(label="Paste Job Description", lines=6)
-    ],
-    outputs="text",
-    title="🧠 Resume to JD Matcher",
-    description="Upload your resume PDF and paste a job description to get a similarity score and feedback!"
-)
-
-# === FastAPI App ===
-fastapi_app = FastAPI()
-model = None
-COHORT_EMBEDDINGS = {}
-# === Load model eagerly before app starts ===
-print("🕐 Preloading SentenceTransformer model before app declaration...")
-
-model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2", use_auth_token=hf_token).to(device)
-COHORT_EMBEDDINGS = {
-    k: model.encode(v, convert_to_tensor=True) for k, v in COHORTS.items()
+    try:
+        with open(log_file_path, 'a') as log_file:
+            log_file.write(log_entry)
+        print(f"Log entry added: {log_entry.strip()}")
+    except Exception as e:
+        print(f"Error logging action: {e}")
+
+###############################
+#  LOAD MODELS
+###############################
+models = {
+    "all-MiniLM-L6-v2": SentenceTransformer("all-MiniLM-L6-v2"),
+    "paraphrase-MiniLM-L6-v2": SentenceTransformer("paraphrase-MiniLM-L6-v2"),
+    "multi-qa-MiniLM-L6-cos-v1": SentenceTransformer("multi-qa-MiniLM-L6-cos-v1"),
+    "all-mpnet-base-v2": SentenceTransformer("all-mpnet-base-v2"),
+    "paraphrase-mpnet-base-v2": SentenceTransformer("paraphrase-mpnet-base-v2"),
+    "all-distilroberta-v1": SentenceTransformer("all-distilroberta-v1"),
+    "paraphrase-albert-small-v2": SentenceTransformer("paraphrase-albert-small-v2"),
+    "multi-qa-distilbert-cos-v1": SentenceTransformer("multi-qa-distilbert-cos-v1"),
+    "distiluse-base-multilingual-cased-v2": SentenceTransformer("distiluse-base-multilingual-cased-v2"),
+    "all-MiniLM-L12-v2": SentenceTransformer("all-MiniLM-L12-v2"),
 }
 
-print("✅ Model and cohort embeddings loaded.")
+###############################
+#  MAIN SIMILARITY FUNCTION
+###############################
+def compute_similarity(resume_text, job_descriptions):
+    """
+    Computes similarity for each model between the resume_text and each job description (split by double line breaks).
+    Returns a tuple of (reasoning_html, table_html).
+    """
+    try:
+        if not resume_text.strip() or not job_descriptions.strip():
+            return "<b>Error:</b> Resume and job descriptions cannot be empty.", None
+
+        # Split job descriptions by double line break
+        job_list = job_descriptions.split("\n\n")
+        if len(job_list) == 0:
+            return "<b>Error:</b> Provide at least one job description separated by double line breaks.", None
+
+        # Dictionary to hold model results
+        results = {}
+        for model_name, model in models.items():
+            # Encode resume and all job descriptions
+            documents = [resume_text] + job_list
+            embeddings = model.encode(documents)
+            resume_embedding = embeddings[0]
+            job_embeddings = embeddings[1:]
+            similarities = cosine_similarity([resume_embedding], job_embeddings).flatten()
+            results[model_name] = similarities
+
+        # Convert to DataFrame
+        df = pd.DataFrame(results, index=[f"Job {i+1}" for i in range(len(job_list))]).T
+
+        # Compute metrics
+        metrics = {
+            "Average": df.mean(axis=0),
+            "Variance": df.var(axis=0),
+            "Median": df.median(axis=0),
+            "Standard Deviation": df.std(axis=0),
+            "Certainty Score": 1 - (df.var(axis=0) / df.var(axis=0).max()),
+        }
+        for metric_name, values in metrics.items():
+            df.loc[metric_name] = values
+
+        # Separate model rows from metrics rows
+        model_rows = df.iloc[:-5]
+        metrics_rows = df.iloc[-5:]
+
+        # Style the DataFrame
+        styled_df = model_rows.style.background_gradient(cmap="Greens", axis=None).to_html()
+        styled_df += metrics_rows.to_html(header=False)
+
+        # Identify best job by highest average similarity
+        best_job = metrics["Average"].idxmax()
+        reasoning = f"<b>The best job match is {best_job} based on the highest average similarity score.</b>"
+
+        # Additional description
+        description = """
+        <p><b>Explanation of the Table:</b></p>
+        <ul>
+            <li><b>Models:</b> Each row corresponds to a pre-trained model used for computing similarity. Below are details about each model:</li>
+            <ul>
+                <li><b>all-MiniLM-L6-v2:</b> Trained on NLI and STS datasets. Developed by Hugging Face and Microsoft. (<a href="https://arxiv.org/abs/2012.15832" target="_blank">Research Paper</a>).</li>
+                <li><b>paraphrase-MiniLM-L6-v2:</b> Optimized for paraphrase detection on datasets like Quora Questions and MSRPC. (<a href="https://arxiv.org/abs/2012.15832" target="_blank">Research Paper</a>).</li>
+                <li><b>multi-qa-MiniLM-L6-cos-v1:</b> Fine-tuned for question-answering tasks using datasets like SQuAD and Natural Questions.</li>
+                <li><b>all-mpnet-base-v2:</b> Robust embeddings for high-contextualized tasks. (<a href="https://arxiv.org/abs/2004.09297" target="_blank">Research Paper</a>).</li>
+                <li><b>paraphrase-mpnet-base-v2:</b> Reliable for paraphrase tasks, trained on diverse datasets.</li>
+                <li><b>all-distilroberta-v1:</b> A lightweight RoBERTa-based model for sentence embeddings. (<a href="https://arxiv.org/abs/1907.11692" target="_blank">Research Paper</a>).</li>
+                <li><b>paraphrase-albert-small-v2:</b> Suitable for paraphrasing in resource-constrained environments.</li>
+                <li><b>multi-qa-distilbert-cos-v1:</b> Optimized for multilingual question-answering tasks.</li>
+                <li><b>distiluse-base-multilingual-cased-v2:</b> Trained on multilingual datasets for cross-lingual embeddings.</li>
+                <li><b>all-MiniLM-L12-v2:</b> Deeper MiniLM variant for enhanced contextual understanding.</li>
+            </ul>
+            <li><b>Metrics:</b>
+                <ul>
+                    <li><b>Average:</b> Mean similarity score for each job description.</li>
+                    <li><b>Variance:</b> Variability in the similarity scores.</li>
+                    <li><b>Median:</b> Middle value of the similarity scores.</li>
+                    <li><b>Standard Deviation:</b> Spread of the similarity scores around the mean.</li>
+                    <li><b>Certainty Score:</b> Indicates model agreement, with 1 being the highest consensus.</li>
+                </ul>
+            </li>
+        </ul>
+        <p>If you liked this application, feel free to send your feedback, suggestions, or adulations to <b>21f1006368@ds.study.iitm.ac.in</b>.</p>
+        """
+
+        return reasoning, styled_df + description
 
-fastapi_app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"]
-)
+    except Exception as e:
+        return f"<b>Error during computation:</b> {str(e)}", None
+
+###############################
+#  APPROACH A EXPLANATION
+###############################
+def explain_scores_by_sentences(model, resume_text, job_text, top_k=3):
+    """
+    Given a SentenceTransformer model, a resume, and one job description,
+    returns HTML with the top-k (resume_sentence, job_sentence) pairs by similarity.
+    """
+    from nltk.tokenize import sent_tokenize
+
+    resume_sents = sent_tokenize(resume_text)
+    job_sents = sent_tokenize(job_text)
+
+    if not resume_sents or not job_sents:
+        return "<b>No sentences found in resume or job description.</b>"
+
+    # Encode each sentence
+    resume_embeddings = model.encode(resume_sents)
+    job_embeddings = model.encode(job_sents)
+
+    # Pairwise cosine similarity
+    sim_matrix = cosine_similarity(resume_embeddings, job_embeddings)
+
+    # Flatten and pick top K
+    flat_sim = sim_matrix.flatten()
+    top_k_indices = np.argsort(flat_sim)[::-1][:top_k]
+
+    explanation_html = "<h4>Top Similar Sentence Pairs</h4>"
+    for rank, idx in enumerate(top_k_indices, start=1):
+        row = idx // job_embeddings.shape[0]
+        col = idx % job_embeddings.shape[0]
+        score = sim_matrix[row, col]
+
+        resume_sentence = resume_sents[row]
+        job_sentence = job_sents[col]
+        explanation_html += f"""
+        <p><b>#{rank}:</b><br>
+        <b>Resume:</b> {resume_sentence}<br>
+        <b>Job:</b> {job_sentence}<br>
+        <b>Similarity Score:</b> {score:.4f}</p>
+        """
+
+    return explanation_html
+
+def explain_model_scores(model_name, resume, jobs, selected_job_idx, top_k=3):
+    """
+    For a given model_name, resume, and job descriptions, returns a gr.update object
+    containing HTML that explains which sentence pairs are most similar, making the
+    explanation visible in the Gradio app.
+    """
+    try:
+        model = models[model_name]
+        job_list = jobs.split("\n\n")
 
-@fastapi_app.post("/debug")
-async def debug(request: Request):
-    body = await request.body()
-    return {"body": body.decode(), "headers": dict(request.headers)}
+        # Check valid job index
+        if selected_job_idx < 0 or selected_job_idx >= len(job_list):
+            return gr.update(
+                value=f"<b>Error:</b> Invalid job index {selected_job_idx}.", 
+                visible=True
+            )
 
+        resume_text = resume.strip()
+        job_text = job_list[int(selected_job_idx)].strip()
 
+        if not resume_text:
+            return gr.update(value="<b>No resume text provided.</b>", visible=True)
 
-@fastapi_app.get("/status")
-async def status():
-    return {"model_loaded": model is not None}
+        if not job_text:
+            return gr.update(value=f"<b>Job description #{selected_job_idx+1} is empty.</b>", visible=True)
 
+        explanation_html = explain_scores_by_sentences(model, resume_text, job_text, top_k)
+        return gr.update(value=explanation_html, visible=True)
 
+    except Exception as e:
+        return gr.update(value=f"<b>Error in explanation:</b> {str(e)}", visible=True)
+
+###############################
+#  GRADIO APP
+###############################
+def process_and_display(resume, jobs, request=None):
+    """
+    Main callback to compute similarity, logs the user action, and yields the result.
+    """
+    try:
+        user_ip = "Unknown IP"
+        if request and hasattr(request, 'client'):
+            user_ip = request.client.host
+
+        # Log the event
+        log_action(f"Process and display triggered for IP: {user_ip}")
+
+        # Show a "processing" message first
+        yield gr.update(value="<b>Processing...</b>", visible=True), None, None, gr.update(visible=False)
+
+        log_action(f"Starting similarity computation for IP: {user_ip}")
+        reasoning, table = compute_similarity(resume, jobs)
+
+        if table:
+            log_action(f"Successfully processed and displayed results for IP: {user_ip}")
+            yield (
+                gr.update(value="", visible=False),  # Clear the "processing" message
+                reasoning,  # Recommendation text
+                table,      # Table of similarities
+                gr.update(value="Papa Please Preach More", visible=True),
+            )
+        else:
+            log_action(f"Error: No results to display for IP: {user_ip}")
+            yield (
+                gr.update(value="", visible=False),
+                reasoning,
+                "<p>No results to display.</p>",
+                gr.update(visible=False),
+            )
+    except Exception as e:
+        log_action(f"Error during process for IP {user_ip}: {str(e)}")
+        raise e
+
+def show_details(table):
+    """
+    Callback to reveal the full table upon user request.
+    """
+    return gr.update(value=table, visible=True)
+
+###############################
+#  BUILD THE GRADIO INTERFACE
+###############################
+with gr.Blocks() as app:
+    gr.Markdown("# Second Opinion with Naval v1.1 – “Midnight Tears”")
+    gr.Markdown(
+        "This application matches a resume to job descriptions using SentenceTransformer models, "
+        "provides similarity scores, and can explain which sentences contributed to each model's score."
+    )
+
+    with gr.Row():
+        resume_input = gr.Textbox(label="Paste Resume", lines=5, placeholder="Paste your resume here...")
+        job_input = gr.Textbox(label="Paste Job Descriptions", lines=5,
+                               placeholder="Paste one or more job descriptions here (double line break to separate).")
+
+    with gr.Row():
+        match_button = gr.Button("Match My Resume to Jobs")
+        processing_output = gr.HTML(value="", visible=False)
+
+    with gr.Row():
+        recommendation_output = gr.HTML(label="Recommendation", visible=True)
+    with gr.Row():
+        table_output = gr.HTML(label="Similarity Table", visible=False)
+
+    with gr.Row():
+        nerd_button = gr.Button("Papa Please Preach More", visible=False)
+
+    # "Explain" output component: hidden initially
+    explanation_output = gr.HTML(label="Model Explanation", visible=False)
+
+    # Main match button -> calls process_and_display
+    match_button.click(
+        process_and_display,
+        inputs=[resume_input, job_input],
+        outputs=[processing_output, recommendation_output, table_output, nerd_button]
+    )
+
+    # Button to show the full table
+    nerd_button.click(
+        show_details,
+        inputs=[table_output],
+        outputs=[table_output],
+    )
+
+    # Input for user to pick which job to explain
+    with gr.Row():
+        job_index_to_explain = gr.Number(label="Job Index (0-based)", value=0)
+
+    # Buttons to explain each model's sentence-level similarity
+    with gr.Row():
+        for m_name in models.keys():
+            btn = gr.Button(f"Explain {m_name}")
+            # Each button calls explain_model_scores for that model
+            btn.click(
+                fn=explain_model_scores,
+                inputs=[gr.State(m_name), resume_input, job_input, job_index_to_explain],
+                outputs=[explanation_output],
+            )
+
+# Optional: custom CSS
+app.css = """
+/* Make the entire background a gradient */
+body {
+    background: linear-gradient(120deg, #E0C3FC 0%, #8EC5FC 100%);
+    margin: 0;
+    padding: 0;
+    font-family: 'Open Sans', sans-serif;
+    min-height: 100vh; /* ensure full coverage of viewport */
+}
 
-# === In-memory OTP store ===
-OTP_STORE = {}
+/* Let the gradient show through behind the .gradio-container */
+.gradio-container {
+    background-color: transparent !important;
+    color: #333333;
+}
 
-from pydantic import BaseModel
+/* Your original style for centered recommendation text */
+#centered-recommendation {
+    text-align: center;
+    font-size: 1.2em;
+    margin-top: 20px;
+    margin-bottom: 20px;
+    color: #2c3e50; /* a nice dark teal */
+}
 
-class EmailRequest(BaseModel):
-    email: str
+/* Example button styling to match the gradient vibe */
+button.primary, button.secondary {
+    background-color: #3498db !important;
+    border: 1px solid #2980b9 !important;
+    color: #fff !important;
+    border-radius: 4px !important;
+}
 
-@fastapi_app.post("/send-otp")
-async def send_otp(request: EmailRequest):
-    email = request.email
-    otp = str(random.randint(100000, 999999))
-    expiry = datetime.now() + timedelta(minutes=10)
-    OTP_STORE[email] = (otp, expiry)
+/* Optional: style textboxes or other inputs for a cleaner look */
+textarea, input[type='text'], input[type='number'] {
+    background-color: #FFFFFF;
+    color: #333;
+    border-radius: 6px !important;
+    border: 1px solid #ccc !important;
+    padding: 8px !important;
+}
+/* (Optional) If you have an h1 or h2, you can style them too */
+h1, h2, h3 {
+    color: #2c3e50;
+}
+"""
+app.launch(share=True)
 
-    msg = EmailMessage()
-    msg["Subject"] = "Your ResumePilot Login OTP"
-    msg["From"] = smtp_user
-    msg["To"] = email
-    msg.set_content(f"Your one-time password (OTP) is: {otp}. It will expire in 10 minutes.")
 
-    try:
-        with smtplib.SMTP_SSL("smtp.gmail.com", 465) as smtp:
-            smtp.login(smtp_user, smtp_pass)
-            smtp.send_message(msg)
-        return {"status": "sent"}
-    except Exception as e:
-        return JSONResponse({"status": "error", "error": str(e)}, status_code=500)
 
-from pydantic import BaseModel
-from fastapi.responses import JSONResponse
-from datetime import datetime
-import random
 
-class OTPVerifyRequest(BaseModel):
-    email: str
-    otp: str
 
-@fastapi_app.post("/verify-otp")
-async def verify_otp(request: OTPVerifyRequest):
-    email = request.email
-    otp = request.otp
 
-    stored = OTP_STORE.get(email)
-    if not stored:
-        return JSONResponse({"error": "No OTP found"}, status_code=400)
+import os
+# import io
+# import json
+# import random
+# import tempfile
+# import smtplib
+# from email.message import EmailMessage
+# from datetime import datetime, timedelta, timezone
+# from fastapi import FastAPI, UploadFile, Form, Request
+# from fastapi.responses import JSONResponse
+# from starlette.middleware.cors import CORSMiddleware
+# from sentence_transformers import SentenceTransformer, util
+# from PyPDF2 import PdfReader
+# import gradio as gr
+# import torch
+# import pytz
+# from dropbox_utils import upload_to_dropbox
+# import asyncio
+# os.environ["HF_HOME"] = "/app/cache"
+# os.environ["TRANSFORMERS_CACHE"] = "/app/cache"
+# os.environ["HF_DATASETS_CACHE"] = "/app/cache"
+
+# smtp_user = os.getenv("SMTP_USER")
+# smtp_pass = os.getenv("SMTP_PASS")
+# if not smtp_user or not smtp_pass:
+#     raise EnvironmentError("SMTP credentials are not set in environment variables.")
+
+
+# # Setup model cache path
+# # os.environ["TRANSFORMERS_CACHE"] = os.environ.get("TRANSFORMERS_CACHE", "/app/cache")
+# # os.environ["HF_HOME"] = os.environ.get("HF_HOME", "/app/cache")
+
+# # === Profile Save/Load ===
+# PROFILE_DIR = os.path.join(os.getenv("HF_HOME", "/app/cache"), "user_profiles")
+# os.makedirs(PROFILE_DIR, exist_ok=True)
+
+# def test_writable_dirs():
+#     for path in ["/app/cache", PROFILE_DIR, "/tmp"]:
+#         print(f"🔍 Checking write permission for: {path}")
+#         if os.access(path, os.W_OK):
+#             print("✅ Writable")
+#         else:
+#             print("❌ Not writable")
+
+# test_writable_dirs()
+# # from huggingface_hub import login
+
+# # # Load HF token and login
+# hf_token = os.environ.get("HUGGINGFACE_HUB_TOKEN")
+# # if hf_token:
+# #     login(token=hf_token, add_to_git_credential=False, write_permission=False)
+
+# # === Load Model with CUDA if available and safe cache ===
+# device = "cuda" if torch.cuda.is_available() else "cpu"
+# print(f"🚀 Loading SentenceTransformer on: {device}")
+
+
+
+
+# # === Define Cohorts ===
+# COHORTS = {
+#     "consulting": "Management consulting, strategy, analytics, client interaction",
+#     "bfsi": "Banking, finance, investment analysis, risk, fintech",
+#     "sales": "Sales, business development, GTM strategy, CRM, channel sales",
+#     "it": "Software development, cloud, AI/ML, backend systems",
+#     "hr": "Human resources, L&D, talent acquisition, HRBP",
+#     "legal": "Contracts, litigation, compliance, intellectual property",
+#     "scm": "Logistics, procurement, inventory, operations, manufacturing",
+#     "bpo": "Customer service, support, inbound/outbound calling, operations"
+# }
+
+
+# # === Helper to extract text from PDF ===
+# def extract_text(file):
+#     reader = PdfReader(file)
+#     return "\n".join([page.extract_text() or "" for page in reader.pages])
+
+# # === Gradio UI function for resume match ===
+# def match_resume(resume_pdf, job_description):
+#     text = extract_text(resume_pdf)
+#     resume_emb = model.encode(text, convert_to_tensor=True)
+#     jd_emb = model.encode(job_description, convert_to_tensor=True)
+#     score = util.cos_sim(jd_emb, resume_emb).item() * 100
+#     label = "✅ Strong Match" if score > 70 else "⚠️ Needs Tailoring"
+#     return f"Match Score: {round(score, 2)}%\n\n{label}"
+
+# demo = gr.Interface(
+#     fn=match_resume,
+#     inputs=[
+#         gr.File(label="Upload Resume PDF", file_types=[".pdf"]),
+#         gr.Textbox(label="Paste Job Description", lines=6)
+#     ],
+#     outputs="text",
+#     title="🧠 Resume to JD Matcher",
+#     description="Upload your resume PDF and paste a job description to get a similarity score and feedback!"
+# )
+
+# # === FastAPI App ===
+# fastapi_app = FastAPI()
+# model = None
+# COHORT_EMBEDDINGS = {}
+# # === Load model eagerly before app starts ===
+# print("🕐 Preloading SentenceTransformer model before app declaration...")
+
+# model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2", use_auth_token=hf_token).to(device)
+# COHORT_EMBEDDINGS = {
+#     k: model.encode(v, convert_to_tensor=True) for k, v in COHORTS.items()
+# }
+
+# print("✅ Model and cohort embeddings loaded.")
+
+# fastapi_app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"],
+#     allow_methods=["*"],
+#     allow_headers=["*"]
+# )
+
+# @fastapi_app.post("/debug")
+# async def debug(request: Request):
+#     body = await request.body()
+#     return {"body": body.decode(), "headers": dict(request.headers)}
+
+
+
+# @fastapi_app.get("/status")
+# async def status():
+#     return {"model_loaded": model is not None}
+
+
+
+# # === In-memory OTP store ===
+# OTP_STORE = {}
+
+# from pydantic import BaseModel
+
+# class EmailRequest(BaseModel):
+#     email: str
+
+# @fastapi_app.post("/send-otp")
+# async def send_otp(request: EmailRequest):
+#     email = request.email
+#     otp = str(random.randint(100000, 999999))
+#     expiry = datetime.now() + timedelta(minutes=10)
+#     OTP_STORE[email] = (otp, expiry)
+
+#     msg = EmailMessage()
+#     msg["Subject"] = "Your ResumePilot Login OTP"
+#     msg["From"] = smtp_user
+#     msg["To"] = email
+#     msg.set_content(f"Your one-time password (OTP) is: {otp}. It will expire in 10 minutes.")
+
+#     try:
+#         with smtplib.SMTP_SSL("smtp.gmail.com", 465) as smtp:
+#             smtp.login(smtp_user, smtp_pass)
+#             smtp.send_message(msg)
+#         return {"status": "sent"}
+#     except Exception as e:
+#         return JSONResponse({"status": "error", "error": str(e)}, status_code=500)
+
+# from pydantic import BaseModel
+# from fastapi.responses import JSONResponse
+# from datetime import datetime
+# import random
+
+# class OTPVerifyRequest(BaseModel):
+#     email: str
+#     otp: str
+
+# @fastapi_app.post("/verify-otp")
+# async def verify_otp(request: OTPVerifyRequest):
+#     email = request.email
+#     otp = request.otp
+
+#     stored = OTP_STORE.get(email)
+#     if not stored:
+#         return JSONResponse({"error": "No OTP found"}, status_code=400)
     
-    saved_otp, expiry = stored
-    if datetime.now() > expiry:
-        return JSONResponse({"error": "OTP expired"}, status_code=401)
+#     saved_otp, expiry = stored
+#     if datetime.now() > expiry:
+#         return JSONResponse({"error": "OTP expired"}, status_code=401)
     
-    if otp != saved_otp:
-        return JSONResponse({"error": "Invalid OTP"}, status_code=401)
+#     if otp != saved_otp:
+#         return JSONResponse({"error": "Invalid OTP"}, status_code=401)
     
-    # OTP valid — return a token and email
-    return {"token": f"token_{random.randint(100000, 999999)}", "email": email}
-
-
-from fastapi import Form
-from email.message import EmailMessage
-import smtplib
-import secrets
-import os
-
-MAGIC_TOKENS = {}  # In-memory token storage
-
-@fastapi_app.post("/send_magic_link")
-async def send_magic_link(email: str = Form(...)):
-    username = email.split("@")[0]
-    token = secrets.token_urlsafe(16)
-    MAGIC_TOKENS[username] = token
+#     # OTP valid — return a token and email
+#     return {"token": f"token_{random.randint(100000, 999999)}", "email": email}
 
-    link = f"https://tendermatcher.tech/campus/?token={token}&user={username}"
 
+# from fastapi import Form
+# from email.message import EmailMessage
+# import smtplib
+# import secrets
+# import os
+
+# MAGIC_TOKENS = {}  # In-memory token storage
 
-    msg = EmailMessage()
-    msg["Subject"] = "🔓 Your Magic Login Link"
-    msg["From"] = os.environ["GMAIL_USER"]
-    msg["To"] = email
-    msg.set_content(f"Hi {username},\n\nClick here to log in:\n{link}\n\nCheers,\nResumePilot")
+# @fastapi_app.post("/send_magic_link")
+# async def send_magic_link(email: str = Form(...)):
+#     username = email.split("@")[0]
+#     token = secrets.token_urlsafe(16)
+#     MAGIC_TOKENS[username] = token
 
-    with smtplib.SMTP_SSL("smtp.gmail.com", 465) as smtp:
-        smtp.login(os.environ["GMAIL_USER"], os.environ["GMAIL_APP_PASSWORD"])
-        smtp.send_message(msg)
+#     link = f"https://tendermatcher.tech/campus/?token={token}&user={username}"
+
+
+#     msg = EmailMessage()
+#     msg["Subject"] = "🔓 Your Magic Login Link"
+#     msg["From"] = os.environ["GMAIL_USER"]
+#     msg["To"] = email
+#     msg.set_content(f"Hi {username},\n\nClick here to log in:\n{link}\n\nCheers,\nResumePilot")
 
-    return {"status": "sent", "token": token}
+#     with smtplib.SMTP_SSL("smtp.gmail.com", 465) as smtp:
+#         smtp.login(os.environ["GMAIL_USER"], os.environ["GMAIL_APP_PASSWORD"])
+#         smtp.send_message(msg)
+
+#     return {"status": "sent", "token": token}
 
 
-@fastapi_app.post("/verify_magic_token")
-async def verify_magic_token(user: str = Form(...), token: str = Form(...)):
-    stored_token = MAGIC_TOKENS.get(user)
-    if not stored_token:
-        return JSONResponse({"error": "No token found for user"}, status_code=400)
-    if token != stored_token:
-        return JSONResponse({"error": "Invalid token"}, status_code=401)
+# @fastapi_app.post("/verify_magic_token")
+# async def verify_magic_token(user: str = Form(...), token: str = Form(...)):
+#     stored_token = MAGIC_TOKENS.get(user)
+#     if not stored_token:
+#         return JSONResponse({"error": "No token found for user"}, status_code=400)
+#     if token != stored_token:
+#         return JSONResponse({"error": "Invalid token"}, status_code=401)
+
+#     # ✅ Valid magic link
+#     return {"status": "verified", "user": user}
+
+
+
+
+# # === Resume Matcher endpoint ===
+# @fastapi_app.post("/predict")
+# async def predict(file: UploadFile, jd: str = Form(...), email: str = Form(...)):
+#     try:
+#         content = await file.read()
+#         pdf = io.BytesIO(content)
+#         text = extract_text(pdf)
+#         resume_emb = model.encode(text, convert_to_tensor=True)
+#         jd_emb = model.encode(jd, convert_to_tensor=True)
+#         score = util.cos_sim(jd_emb, resume_emb).item() * 100
+#         label = "Strong Match" if score > 70 else "Needs Tailoring"
+
+#         with tempfile.TemporaryDirectory() as tmpdir:
+#             upload_to_dropbox(content, f"/spc_cohort_data/{email}/resume.pdf")
+#             jd_data = json.dumps({"score": round(score, 2), "feedback": label}).encode("utf-8")
+#             upload_to_dropbox(jd_data, f"/spc_cohort_data/{email}/jd_match.json")
 
-    # ✅ Valid magic link
-    return {"status": "verified", "user": user}
+#         return JSONResponse({"score": round(score, 2), "feedback": label, "device": device})
+#     except Exception as e:
+#         return JSONResponse({"error": str(e)}, status_code=500)
+
+# # === Cohort Predictor endpoint ===
+# @fastapi_app.post("/cohort")
+# async def cohort_predict(name: str = Form(...), email: str = Form(...), summary: str = Form(...), quiz: str = Form(...)):
+#     try:
+#         combined = f"{name}\n{email}\n{summary}"
+#         user_emb = model.encode(combined, convert_to_tensor=True)
+#         scores = {cohort: util.cos_sim(user_emb, emb).item() for cohort, emb in COHORT_EMBEDDINGS.items()}
+#         predicted = max(scores, key=scores.get)
 
+#         with tempfile.TemporaryDirectory() as tmpdir:
+#             quiz_bytes = json.dumps(json.loads(quiz)).encode("utf-8")
+#             upload_to_dropbox(quiz_bytes, f"/spc_cohort_data/{email}/quiz.json")
 
+#             cohort_result = {
+#                 "predicted_cohort": predicted,
+#                 "scores": {k: round(v * 100, 2) for k, v in scores.items()}
+#             }
+#             upload_to_dropbox(json.dumps(cohort_result).encode("utf-8"), f"/spc_cohort_data/{email}/cohort.json")
 
+#         return JSONResponse(cohort_result)
+#     except Exception as e:
+#         return JSONResponse({"error": str(e)}, status_code=500)
 
-# === Resume Matcher endpoint ===
-@fastapi_app.post("/predict")
-async def predict(file: UploadFile, jd: str = Form(...), email: str = Form(...)):
-    try:
-        content = await file.read()
-        pdf = io.BytesIO(content)
-        text = extract_text(pdf)
-        resume_emb = model.encode(text, convert_to_tensor=True)
-        jd_emb = model.encode(jd, convert_to_tensor=True)
-        score = util.cos_sim(jd_emb, resume_emb).item() * 100
-        label = "Strong Match" if score > 70 else "Needs Tailoring"
-
-        with tempfile.TemporaryDirectory() as tmpdir:
-            upload_to_dropbox(content, f"/spc_cohort_data/{email}/resume.pdf")
-            jd_data = json.dumps({"score": round(score, 2), "feedback": label}).encode("utf-8")
-            upload_to_dropbox(jd_data, f"/spc_cohort_data/{email}/jd_match.json")
-
-        return JSONResponse({"score": round(score, 2), "feedback": label, "device": device})
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
-
-# === Cohort Predictor endpoint ===
-@fastapi_app.post("/cohort")
-async def cohort_predict(name: str = Form(...), email: str = Form(...), summary: str = Form(...), quiz: str = Form(...)):
-    try:
-        combined = f"{name}\n{email}\n{summary}"
-        user_emb = model.encode(combined, convert_to_tensor=True)
-        scores = {cohort: util.cos_sim(user_emb, emb).item() for cohort, emb in COHORT_EMBEDDINGS.items()}
-        predicted = max(scores, key=scores.get)
-
-        with tempfile.TemporaryDirectory() as tmpdir:
-            quiz_bytes = json.dumps(json.loads(quiz)).encode("utf-8")
-            upload_to_dropbox(quiz_bytes, f"/spc_cohort_data/{email}/quiz.json")
-
-            cohort_result = {
-                "predicted_cohort": predicted,
-                "scores": {k: round(v * 100, 2) for k, v in scores.items()}
-            }
-            upload_to_dropbox(json.dumps(cohort_result).encode("utf-8"), f"/spc_cohort_data/{email}/cohort.json")
-
-        return JSONResponse(cohort_result)
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
 
+# from dropbox.exceptions import ApiError
+# import dropbox
 
-from dropbox.exceptions import ApiError
-import dropbox
+# DROPBOX_ACCESS_TOKEN = os.getenv("DROPBOX_REFRESH_TOKEN")
+# dbx = dropbox.Dropbox(DROPBOX_ACCESS_TOKEN)
+# @fastapi_app.post("/save_profile")
+# async def save_profile(request: Request):
+#     form = await request.form()
+#     email = form.get("email")
+#     full_name = form.get("full_name")
+#     job_title = form.get("job_title")
+
+#     if not email or not full_name or not job_title:
+#         return JSONResponse({"error": "Missing profile fields"}, status_code=400)
 
-DROPBOX_ACCESS_TOKEN = os.getenv("DROPBOX_REFRESH_TOKEN")
-dbx = dropbox.Dropbox(DROPBOX_ACCESS_TOKEN)
-@fastapi_app.post("/save_profile")
-async def save_profile(request: Request):
-    form = await request.form()
-    email = form.get("email")
-    full_name = form.get("full_name")
-    job_title = form.get("job_title")
+#     path = get_profile_path(email)
 
-    if not email or not full_name or not job_title:
-        return JSONResponse({"error": "Missing profile fields"}, status_code=400)
+#     try:
+#         try:
+#             _, res = dbx.files_download(path)
+#             profile_data = json.loads(res.content)
+#         except ApiError:
+#             profile_data = {}
 
-    path = get_profile_path(email)
+#         profile_data.update({
+#             "full_name": full_name,
+#             "job_title": job_title
+#         })
+
+#         upload_to_dropbox(
+#     json.dumps(profile_data).encode(),
+#     path)
 
-    try:
-        try:
-            _, res = dbx.files_download(path)
-            profile_data = json.loads(res.content)
-        except ApiError:
-            profile_data = {}
-
-        profile_data.update({
-            "full_name": full_name,
-            "job_title": job_title
-        })
-
-        upload_to_dropbox(
-    json.dumps(profile_data).encode(),
-    path)
-
-        return JSONResponse({"success": True})
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
-
-@fastapi_app.get("/load_profile")
-async def load_profile(email: str):
-    path = get_profile_path(email)
+#         return JSONResponse({"success": True})
+#     except Exception as e:
+#         return JSONResponse({"error": str(e)}, status_code=500)
 
-    try:
-        _, res = dbx.files_download(path)
-        profile_data = json.loads(res.content)
-        return JSONResponse({
-            "full_name": profile_data.get("full_name", ""),
-            "job_title": profile_data.get("job_title", "")
-        })
-    except ApiError:
-        return JSONResponse({"full_name": "", "job_title": ""})
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
-
-
-
-
-def get_profile_path(email: str):
-    return f"/spc_cohort_data/{email}/profile.json"
-
-@fastapi_app.post("/save_theme")
-async def save_theme(request: Request):
-    form = await request.form()
-    email = form.get("email")
-    theme = form.get("theme")
-
-    if not email or not theme:
-        return JSONResponse({"error": "Missing email or theme"}, status_code=400)
-
-    path = get_profile_path(email)
-
-    try:
-        try:
-            _, res = dbx.files_download(path)
-            profile_data = json.loads(res.content)
-        except ApiError:
-            profile_data = {}
-
-        profile_data["theme"] = theme
+# @fastapi_app.get("/load_profile")
+# async def load_profile(email: str):
+#     path = get_profile_path(email)
+
+#     try:
+#         _, res = dbx.files_download(path)
+#         profile_data = json.loads(res.content)
+#         return JSONResponse({
+#             "full_name": profile_data.get("full_name", ""),
+#             "job_title": profile_data.get("job_title", "")
+#         })
+#     except ApiError:
+#         return JSONResponse({"full_name": "", "job_title": ""})
+#     except Exception as e:
+#         return JSONResponse({"error": str(e)}, status_code=500)
+
+
+
+
+# def get_profile_path(email: str):
+#     return f"/spc_cohort_data/{email}/profile.json"
+
+# @fastapi_app.post("/save_theme")
+# async def save_theme(request: Request):
+#     form = await request.form()
+#     email = form.get("email")
+#     theme = form.get("theme")
+
+#     if not email or not theme:
+#         return JSONResponse({"error": "Missing email or theme"}, status_code=400)
+
+#     path = get_profile_path(email)
+
+#     try:
+#         try:
+#             _, res = dbx.files_download(path)
+#             profile_data = json.loads(res.content)
+#         except ApiError:
+#             profile_data = {}
+
+#         profile_data["theme"] = theme
 
         
-        upload_to_dropbox(
-    json.dumps(profile_data).encode(),
-    path
-)
-
-        return JSONResponse({"success": True})
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
-
-@fastapi_app.get("/load_theme")
-async def load_theme(email: str):
-    path = get_profile_path(email)
-
-    try:
-        _, res = dbx.files_download(path)
-        profile_data = json.loads(res.content)
-        return JSONResponse({"theme": profile_data.get("theme", "light")})
-    except ApiError:
-        return JSONResponse({"theme": "light"})
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
-
-
-
-
-# === Log Endpoint ===
-@fastapi_app.post("/log")
-async def receive_log(request: Request):
-    try:
-        payload = await request.json()
-        timestamp = datetime.now(timezone.utc).astimezone(pytz.timezone("Asia/Kolkata")).isoformat()
-        payload["logged_at"] = timestamp
-
-        log_line = json.dumps(payload, ensure_ascii=False) + "\n"
-        today = datetime.now().strftime("%Y-%m-%d")
-        log_path = f"/spc_cohort_data/logs/{today}.jsonl"
-        upload_to_dropbox(log_line.encode("utf-8"), log_path, append=True)
-
-        return {"status": "logged"}
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
-
-# === List routes endpoint ===
-@fastapi_app.get("/routes")
-async def list_routes():
-    return [
-        {
-            "path": route.path,
-            "methods": list(route.methods),
-            "name": route.name
-        }
-        for route in fastapi_app.routes
-        if hasattr(route, "methods")
-    ]
-
-@fastapi_app.get("/")
-async def root_redirect():
-    return JSONResponse({"message": "Visit /ui for the resume matcher and API routes"})
-
-@fastapi_app.get("/health")
-async def health():
-    return {"status": "ok"}
+#         upload_to_dropbox(
+#     json.dumps(profile_data).encode(),
+#     path
+# )
+
+#         return JSONResponse({"success": True})
+#     except Exception as e:
+#         return JSONResponse({"error": str(e)}, status_code=500)
+
+# @fastapi_app.get("/load_theme")
+# async def load_theme(email: str):
+#     path = get_profile_path(email)
+
+#     try:
+#         _, res = dbx.files_download(path)
+#         profile_data = json.loads(res.content)
+#         return JSONResponse({"theme": profile_data.get("theme", "light")})
+#     except ApiError:
+#         return JSONResponse({"theme": "light"})
+#     except Exception as e:
+#         return JSONResponse({"error": str(e)}, status_code=500)
+
+
+
+
+# # === Log Endpoint ===
+# @fastapi_app.post("/log")
+# async def receive_log(request: Request):
+#     try:
+#         payload = await request.json()
+#         timestamp = datetime.now(timezone.utc).astimezone(pytz.timezone("Asia/Kolkata")).isoformat()
+#         payload["logged_at"] = timestamp
+
+#         log_line = json.dumps(payload, ensure_ascii=False) + "\n"
+#         today = datetime.now().strftime("%Y-%m-%d")
+#         log_path = f"/spc_cohort_data/logs/{today}.jsonl"
+#         upload_to_dropbox(log_line.encode("utf-8"), log_path, append=True)
+
+#         return {"status": "logged"}
+#     except Exception as e:
+#         return JSONResponse({"error": str(e)}, status_code=500)
+
+# # === List routes endpoint ===
+# @fastapi_app.get("/routes")
+# async def list_routes():
+#     return [
+#         {
+#             "path": route.path,
+#             "methods": list(route.methods),
+#             "name": route.name
+#         }
+#         for route in fastapi_app.routes
+#         if hasattr(route, "methods")
+#     ]
+
+# @fastapi_app.get("/")
+# async def root_redirect():
+#     return JSONResponse({"message": "Visit /ui for the resume matcher and API routes"})
+
+# @fastapi_app.get("/health")
+# async def health():
+#     return {"status": "ok"}
 
     
-# === Gradio UI for listing routes ===
-from fastapi.testclient import TestClient
-
-client = TestClient(fastapi_app)
-
-def get_routes_str():
-    response = client.get("/routes")
-    if response.status_code == 200:
-        return json.dumps(response.json(), indent=2)
-    else:
-        return f"Error fetching routes: {response.status_code}"
-
-
-routes_demo = gr.Interface(
-    fn=get_routes_str,
-    inputs=[],
-    outputs="textbox",
-    title="API Routes",
-    description="List of all API routes exposed by FastAPI backend"
-)
-
-with gr.Blocks() as ui:
-    with gr.Tabs():
-        with gr.TabItem("Resume Matcher"):
-            demo.render()
-        with gr.TabItem("API Routes"):
-            routes_demo.render()
-
-
-# Mount the combined UI at /ui
-app = fastapi_app
-
-if __name__ == "__main__":
-    import os
-    import uvicorn
-    ui.launch(server_name="0.0.0.0", server_port=7860)
+# # === Gradio UI for listing routes ===
+# from fastapi.testclient import TestClient
+
+# client = TestClient(fastapi_app)
+
+# def get_routes_str():
+#     response = client.get("/routes")
+#     if response.status_code == 200:
+#         return json.dumps(response.json(), indent=2)
+#     else:
+#         return f"Error fetching routes: {response.status_code}"
+
+
+# routes_demo = gr.Interface(
+#     fn=get_routes_str,
+#     inputs=[],
+#     outputs="textbox",
+#     title="API Routes",
+#     description="List of all API routes exposed by FastAPI backend"
+# )
+
+# with gr.Blocks() as ui:
+#     with gr.Tabs():
+#         with gr.TabItem("Resume Matcher"):
+#             demo.render()
+#         with gr.TabItem("API Routes"):
+#             routes_demo.render()
+
+
+# # Mount the combined UI at /ui
+# app = fastapi_app
+
+# if __name__ == "__main__":
+#     import os
+#     import uvicorn
+#     ui.launch(server_name="0.0.0.0", server_port=7860)