Update app.py

app.py

@@ -1,372 +1,487 @@
-import streamlit as st
-import pandas as pd
-import io
+# app.py
+"""
+Quantum Scrutiny Platform | Groq-Powered
+Single-file Streamlit app (refactored & debugged)
+"""
+
+# --- 0. Always set page config as the first Streamlit command ---
 import os
-import fitz
-import docx2txt
-import tempfile
-from groq import Groq
 from dotenv import load_dotenv
-from pydantic import BaseModel, Field, ValidationError
+
+load_dotenv()  # load local .env if present (during local dev)
+
+import io
+import base64
+import traceback
 from typing import Optional, List
 
-# --------------------
-# Config & Secrets
-# --------------------
-# Ensure page config is the very first Streamlit command (done here)
-st.set_page_config(layout="wide", page_title="Quantum Scrutiny Platform | Groq-Powered")
+import streamlit as st
+import pandas as pd
 
-# Load local .env if present (useful for local testing)
-load_dotenv()
+# resume parsing
+import fitz                  # PyMuPDF
+from docx import Document    # python-docx
 
-# Try multiple locations for the API key: environment variables, Streamlit secrets
-GROQ_API_KEY = os.getenv("GROQ_API_KEY") or os.getenv("GROQ_APIKEY")
-if not GROQ_API_KEY:
-    # If deployed on Streamlit Cloud or similar, users might put secrets in st.secrets
-    try:
-        GROQ_API_KEY = st.secrets["GROQ_API_KEY"]
-    except Exception:
-        GROQ_API_KEY = None
+# Groq client (keep same import name as you used)
+from groq import Groq
 
-# Admin password (for demo). In production, store this in secrets.
-ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "admin")
+# Pydantic for schema validation
+from pydantic import BaseModel, Field, ValidationError
+
+# --- Streamlit UI config ---
+st.set_page_config(layout="wide", page_title="Quantum Scrutiny Platform | Groq-Powered")
 
-# Initialize Groq Client (if key present)
+# --- Config / Secrets ---
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")  # set in environment or .env or deploy secrets
+ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "admin")  # optional override via env
+
+# --- Initialize Groq client with safe error messaging ---
 groq_client = None
-if GROQ_API_KEY:
+if not GROQ_API_KEY:
+    st.error("GROQ_API_KEY not found. Please set GROQ_API_KEY as an environment variable or in Hugging Face secrets.")
+    # We won't stop here to allow UI to display, but analysis will error if used.
+else:
     try:
         groq_client = Groq(api_key=GROQ_API_KEY)
     except Exception as e:
-        st.warning(f"Warning: Failed to initialize Groq client: {e}")
+        st.error(f"Failed to initialize Groq client: {e}")
         groq_client = None
-else:
-    st.warning("GROQ_API_KEY not found in environment or Streamlit secrets. The app will run in fallback mode.")
 
-# --------------------
-# Session state init
-# --------------------
+
+# --- Session state defaults ---
 if 'is_admin_logged_in' not in st.session_state:
     st.session_state.is_admin_logged_in = False
-
 if 'analyzed_data' not in st.session_state:
     initial_cols = [
         'Name', 'Job Role', 'Resume Score (100)', 'Email', 'Phone', 'Shortlisted',
-        'Experience Summary', 'Education Summary', 'Communication Rating (1-10)', 
-        'Skills/Technologies', 'Certifications', 'ABA Skills (1-10)', 
+        'Experience Summary', 'Education Summary', 'Communication Rating (1-10)',
+        'Skills/Technologies', 'Certifications', 'ABA Skills (1-10)',
         'RBT/BCBA Cert', 'Autism-Care Exp (1-10)'
     ]
     st.session_state.analyzed_data = pd.DataFrame(columns=initial_cols)
+if 'individual_analysis' not in st.session_state:
+    st.session_state.individual_analysis = []
+if 'run_analysis' not in st.session_state:
+    st.session_state.run_analysis = False
+
 
-# --------------------
-# Pydantic Schema
-# --------------------
+# --- Pydantic schema for Groq output ---
 class ResumeAnalysis(BaseModel):
     name: str = Field(description="Full name of the candidate.")
     email: str = Field(description="Professional email address.")
     phone: str = Field(description="Primary phone number.")
     certifications: List[str] = Field(default_factory=list, description="List of professional certifications.")
-    experience_summary: str = Field(default="", description="A concise summary of the candidate's professional experience.")
-    education_summary: str = Field(default="", description="A concise summary of the candidate's highest education.")
-
-    communication_skills: str = Field(default="N/A", description="A score as a STRING (e.g., '8') or description of communication skills.")
-    technical_skills: List[str] = Field(default_factory=list, description="List of technical skills/technologies mentioned.")
+    experience_summary: str = Field(default="", description="Concise summary of experience.")
+    education_summary: str = Field(default="", description="Concise summary of education.")
+    communication_skills: str = Field(description="Communication score as a STRING ('8') or description.")
+    technical_skills: List[str] = Field(default_factory=list, description="List of skills/technologies.")
+    aba_therapy_skills: Optional[str] = Field(default="N/A", description="ABA Therapy score as STRING or 'N/A'.")
+    rbt_bcba_certification: Optional[str] = Field(default="N/A", description="'Yes'/'No'/'N/A'.")
+    autism_care_experience_score: Optional[str] = Field(default="N/A", description="Autism care experience score as STRING or 'N/A'.")
 
-    aba_therapy_skills: Optional[str] = Field(default="N/A", description="Specific score as a STRING (e.g., '7').")
-    rbt_bcba_certification: Optional[str] = Field(default="N/A", description="Indicate 'Yes' or 'No'.")
-    autism_care_experience_score: Optional[str] = Field(default="N/A", description="A score as a STRING (e.g., '9').")
-
-# --------------------
-# Helpers
-# --------------------
 
+# --- Helper: File text extraction ---
 def extract_text_from_file(uploaded_file) -> str:
-    """Extract text from uploaded file safely by writing to a temp file."""
+    """
+    Accepts a Streamlit UploadedFile object and returns extracted text.
+    Supports PDF and DOCX. Returns empty string on failure.
+    """
     try:
-        suffix = os.path.splitext(uploaded_file.name)[1].lower()
-        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
-            tmp.write(uploaded_file.read())
-            tmp_path = tmp.name
-
-        text = ""
-        if suffix == '.pdf':
+        content = uploaded_file.read()
+        # Reset pointer if needed (Streamlit UploadedFile likely returns bytes; after read it's consumed)
+        # We already consumed it into `content` so use BytesIO for downstream if needed.
+
+        # detect PDF by mime or header bytes
+        name_lower = uploaded_file.name.lower()
+        if name_lower.endswith(".pdf") or content[:5] == b"%PDF-":
+            # use fitz (PyMuPDF)
             try:
-                doc = fitz.open(tmp_path)
-                for page in doc:
-                    text += page.get_text()
-                doc.close()
+                with fitz.open(stream=content, filetype="pdf") as doc:
+                    pages_text = []
+                    for p in doc:
+                        pages_text.append(p.get_text())
+                return "\n".join(pages_text).strip()
             except Exception as e:
-                st.error(f"PDF extraction error for {uploaded_file.name}: {e}")
-                text = ""
-        elif suffix in ['.docx', '.doc']:
+                # fallback: try PyMuPDF alternative reading
+                st.warning(f"PDF extraction issue for {uploaded_file.name}: {e}")
+                return ""
+        elif name_lower.endswith(".docx"):
+            # python-docx can accept a file-like object
             try:
-                text = docx2txt.process(tmp_path) or ""
+                doc = Document(io.BytesIO(content))
+                paragraphs = [p.text for p in doc.paragraphs if p.text and p.text.strip()]
+                return "\n".join(paragraphs).strip()
             except Exception as e:
-                st.error(f"DOCX extraction error for {uploaded_file.name}: {e}")
-                text = ""
+                st.warning(f"DOCX extraction issue for {uploaded_file.name}: {e}")
+                return ""
         else:
-            st.warning(f"Unsupported file type: {suffix}")
-
-        # Clean up temp file
-        try:
-            os.unlink(tmp_path)
-        except Exception:
-            pass
-
-        return text
+            # Try simple decode for text-like files
+            try:
+                return content.decode('utf-8', errors='ignore')
+            except Exception:
+                return ""
     except Exception as e:
-        st.error(f"Failed to extract text: {e}")
+        st.error(f"Unexpected file extraction error: {e}")
         return ""
 
 
-@st.cache_data
-def analyze_resume_with_groq(resume_text: str, job_role: str) -> ResumeAnalysis:
-    """Call Groq to extract structured data. If Groq is not available or returns invalid JSON,
-    fall back to a lightweight heuristic parser.
+# --- Helper: call Groq (safe wrapper) ---
+def call_groq_chat_system(resume_text: str, job_role: str) -> Optional[str]:
+    """
+    Calls Groq chat completion. Returns model text content or None on error.
+    Note: groq_client must be initialized.
     """
-    # If no groq client, skip to fallback
     if not groq_client:
-        return fallback_simple_extraction(resume_text, job_role)
+        st.error("Groq client is not initialized. Set GROQ_API_KEY in environment or secrets.")
+        return None
 
-    # Build role-specific instructions
+    # role-specific instructions
     therapist_instructions = ""
     if job_role == "Therapist":
         therapist_instructions = (
-            "Because the job role is 'Therapist', carefully look for ABA Therapy Skills, RBT/BCBA Certification, "
-            "and Autism-Care Experience. Provide a score from 1-10 as a STRING (e.g., '7') for these fields. "
-            "If not found, return 'N/A'."
+            "Because the job role is 'Therapist', you MUST carefully look for ABA Therapy Skills, "
+            "RBT/BCBA Certification, and Autism-Care Experience. Provide a score from 1-10 as a STRING "
+            "(e.g., '7') for the specialized fields. If any specialized field is not present, return 'N/A'."
         )
     else:
         therapist_instructions = (
-            "Since the role is not 'Therapist', set specialized therapist fields to 'N/A' if not present."
+            "This is NOT a Therapist role. Set 'aba_therapy_skills', 'autism_care_experience_score', "
+            "and 'rbt_bcba_certification' to 'N/A' if not applicable."
         )
 
     system_prompt = (
-        f"You are a professional Resume Analyzer. Extract fields exactly matching the JSON schema: name, email, phone, certifications (list), "
-        f"experience_summary, education_summary, communication_skills (STRING), technical_skills (list), aba_therapy_skills, rbt_bcba_certification, autism_care_experience_score. "
-        f"The candidate is applying for '{job_role}'. {therapist_instructions} Return valid JSON only."
+        "You are a professional Resume Analyzer. Extract the requested fields and return a strict JSON object "
+        "matching the schema: name, email, phone, certifications (array), experience_summary, education_summary, "
+        "communication_skills (AS A STRING, e.g., '8'), technical_skills (array), aba_therapy_skills, "
+        "rbt_bcba_certification, autism_care_experience_score. " + therapist_instructions
     )
 
+    user_prompt = f"Analyze the following resume text and return a JSON object:\n\n---\n{resume_text}\n---\nReturn only valid JSON."
+
     try:
-        chat_completion = groq_client.chat.completions.create(
-            model="mixtral-8x7b-32768",
+        result = groq_client.chat.completions.create(
+            model="mixtral-8x7b-32768",  # keep your original model choice; adapt if needed
             messages=[
                 {"role": "system", "content": system_prompt},
-                {"role": "user", "content": f"Analyze the following resume text:\n\n---\n{resume_text}\n---"}
+                {"role": "user", "content": user_prompt}
             ],
-            response_model={"type": "json_object", "schema": ResumeAnalysis.schema()},
-            temperature=0.0
+            temperature=0.0,
+            max_tokens=2000,
+            # Not all Groq SDK versions support response_model in the same way; we parse manually below.
         )
-
-        # Extract raw content (SDK may vary — keep defensive)
-        raw = None
+        # Depending on SDK, result structure varies; common: result.choices[0].message.content
+        model_text = None
         try:
-            raw = chat_completion.choices[0].message.content
+            model_text = result.choices[0].message.content
         except Exception:
-            raw = str(chat_completion)
+            # try alternate structure
+            try:
+                model_text = result["choices"][0]["message"]["content"]
+            except Exception:
+                model_text = str(result)
 
-        # Parse with Pydantic
-        try:
-            analysis = ResumeAnalysis.parse_raw(raw)
-        except ValidationError as ve:
-            st.warning(f"Groq returned invalid format; falling back to heuristic extraction. Details: {ve}")
-            return fallback_simple_extraction(resume_text, job_role)
+        return model_text
+    except Exception as e:
+        st.error(f"Groq API call failed: {e}")
+        st.exception(e)
+        return None
 
-        # Ensure string coercions
-        analysis.communication_skills = str(analysis.communication_skills or 'N/A')
-        analysis.aba_therapy_skills = str(analysis.aba_therapy_skills or 'N/A')
-        analysis.rbt_bcba_certification = str(analysis.rbt_bcba_certification or 'N/A')
-        analysis.autism_care_experience_score = str(analysis.autism_care_experience_score or 'N/A')
 
-        return analysis
+# --- Cached wrapper for analysis (cache by resume_text + role) ---
+@st.cache_data(show_spinner=False)
+def analyze_resume_with_groq_cached(resume_text: str, job_role: str) -> ResumeAnalysis:
+    """
+    Calls Groq (or fallback) and returns a validated ResumeAnalysis Pydantic object.
+    This function is cached to avoid repeated calls for identical text+role.
+    """
+    raw_response = call_groq_chat_system(resume_text, job_role)
+    if not raw_response:
+        # return safe failure object
+        return ResumeAnalysis(
+            name="Extraction Failed",
+            email="",
+            phone="",
+            certifications=[],
+            experience_summary="",
+            education_summary="",
+            communication_skills="N/A",
+            technical_skills=[],
+            aba_therapy_skills="N/A",
+            rbt_bcba_certification="N/A",
+            autism_care_experience_score="N/A"
+        )
 
+    # Attempt to parse JSON from the model text. The model might include commentary;
+    # so we try to extract the first JSON object in the text.
+    import json
+    import re
+
+    json_text = None
+    try:
+        # Find the first {...} JSON object in the string (greedy to closing brace)
+        match = re.search(r"(\{.*\})", raw_response, re.DOTALL)
+        if match:
+            json_text = match.group(1)
+        else:
+            # if no braces found, maybe the model returned just JSON-like lines
+            json_text = raw_response
+        parsed = json.loads(json_text)
     except Exception as e:
-        st.warning(f"Groq API call failed: {e}. Using fallback extraction.")
-        return fallback_simple_extraction(resume_text, job_role)
+        # Try to be forgiving: if the model returned Python dict-like, attempt eval safely
+        try:
+            parsed = eval(json_text, {"__builtins__": None}, {})  # limited eval fallback
+            if not isinstance(parsed, dict):
+                raise ValueError("Parsed non-dict from model response fallback.")
+        except Exception as ex:
+            # Failed to parse model output -> return failure object and log both
+            st.warning("Failed to parse Groq output as JSON. Returning fallback extraction.")
+            st.text_area("Raw model output (for debugging)", raw_response, height=200)
+            return ResumeAnalysis(
+                name="Extraction Failed",
+                email="",
+                phone="",
+                certifications=[],
+                experience_summary="",
+                education_summary="",
+                communication_skills="N/A",
+                technical_skills=[],
+                aba_therapy_skills="N/A",
+                rbt_bcba_certification="N/A",
+                autism_care_experience_score="N/A"
+            )
+
+    # Validate & coerce to Pydantic model (safe defaults applied)
+    try:
+        # Ensure lists exist
+        parsed.setdefault("certifications", [])
+        parsed.setdefault("technical_skills", [])
+        # Ensure communication_skills is string
+        if "communication_skills" in parsed and parsed["communication_skills"] is not None:
+            parsed["communication_skills"] = str(parsed["communication_skills"])
+        else:
+            parsed["communication_skills"] = "N/A"
 
+        # Safety: set therapist-specific fields default to "N/A" if missing
+        for k in ["aba_therapy_skills", "rbt_bcba_certification", "autism_care_experience_score"]:
+            if k not in parsed or parsed[k] is None:
+                parsed[k] = "N/A"
+            else:
+                parsed[k] = str(parsed[k])
 
-def fallback_simple_extraction(text: str, job_role: str) -> ResumeAnalysis:
-    """A minimal, robust heuristic extractor used when the LLM call fails.
-    It tries to find name/email/phone and picks up some keywords for skills and certifications.
-    """
-    import re
+        analysis = ResumeAnalysis.parse_obj(parsed)
+        # Final coercions to guarantee string types for some fields
+        analysis.communication_skills = str(analysis.communication_skills or "N/A")
+        analysis.aba_therapy_skills = str(analysis.aba_therapy_skills or "N/A")
+        analysis.rbt_bcba_certification = str(analysis.rbt_bcba_certification or "N/A")
+        analysis.autism_care_experience_score = str(analysis.autism_care_experience_score or "N/A")
 
-    # Very simple heuristics (intended as a fallback only)
-    email_match = re.search(r"[\w\.-]+@[\w\.-]+", text)
-    phone_match = re.search(r"(\+?\d[\d\-\s]{7,}\d)", text)
-
-    name = "Unknown"
-    # Heuristic: first line that looks like a name (two words, capitalized)
-    lines = [l.strip() for l in text.splitlines() if l.strip()]
-    if lines:
-        for line in lines[:5]:
-            if len(line.split()) <= 4 and any(ch.isalpha() for ch in line) and line[0].isupper():
-                name = line
-                break
-
-    email = email_match.group(0) if email_match else ""
-    phone = phone_match.group(0) if phone_match else ""
-
-    # Skills: gather common programming / therapy keywords
-    skills_candidates = []
-    certifications = []
-    keywords = ['python','java','c++','machine learning','deep learning','tensorflow','pytorch','rbt','bcba','aba','autism']
-    lower_text = text.lower()
-    for kw in keywords:
-        if kw in lower_text:
-            skills_candidates.append(kw)
-            if kw in ['rbt','bcba']:
-                certifications.append(kw.upper())
-
-    experience_summary = ' '.join(lines[:4]) if lines else ''
-    education_summary = ''
-
-    # Therapist-specific small heuristics
-    aba = 'N/A'
-    rbt_cert = 'Yes' if 'rbt' in lower_text or 'registered behavior technician' in lower_text else 'N/A'
-    autism_score = 'N/A'
-
-    return ResumeAnalysis(
-        name=name,
-        email=email,
-        phone=phone,
-        certifications=certifications,
-        experience_summary=experience_summary,
-        education_summary=education_summary,
-        communication_skills='5',
-        technical_skills=list(set(skills_candidates)),
-        aba_therapy_skills=aba,
-        rbt_bcba_certification=rbt_cert,
-        autism_care_experience_score=autism_score
-    )
+        return analysis
+    except ValidationError as ve:
+        st.error("Model output failed schema validation. Returning fallback object.")
+        st.text_area("Model raw response (for debugging)", raw_response, height=200)
+        st.exception(ve)
+        return ResumeAnalysis(
+            name="Extraction Failed",
+            email="",
+            phone="",
+            certifications=[],
+            experience_summary="",
+            education_summary="",
+            communication_skills="N/A",
+            technical_skills=[],
+            aba_therapy_skills="N/A",
+            rbt_bcba_certification="N/A",
+            autism_care_experience_score="N/A"
+        )
+    except Exception as e:
+        st.error("Unexpected error while validating model output.")
+        st.exception(e)
+        return ResumeAnalysis(
+            name="Extraction Failed",
+            email="",
+            phone="",
+            certifications=[],
+            experience_summary="",
+            education_summary="",
+            communication_skills="N/A",
+            technical_skills=[],
+            aba_therapy_skills="N/A",
+            rbt_bcba_certification="N/A",
+            autism_care_experience_score="N/A"
+        )
 
 
-def calculate_resume_score(analysis: ResumeAnalysis) -> float:
-    """Calculates a weighted score out of 100 based on heuristics and extracted values."""
+# --- Scoring function ---
+def calculate_resume_score(analysis: ResumeAnalysis, role: str) -> float:
     total_score = 0.0
 
-    # 1. Experience Score (Max 40)
+    # Experience summary length -> up to 40 points
     exp_len = len(analysis.experience_summary or "")
-    exp_factor = min(exp_len / 100.0, 1.0)
+    exp_factor = min(exp_len / 100.0, 1.0)  # 100 chars or more -> full points
     total_score += exp_factor * 40.0
 
-    # 2. Skills Score (Max 30)
-    skills_factor = min(len(analysis.technical_skills) / 10.0, 1.0)
+    # Skills count -> up to 30 points
+    skills_count = len(analysis.technical_skills or [])
+    skills_factor = min(skills_count / 10.0, 1.0)
     total_score += skills_factor * 30.0
 
-    # 3. Communication (Max 20)
+    # Communication -> up to 20 points (expects 1-10 in string)
     try:
-        score_str = str(analysis.communication_skills).split('-')[0].strip()
-        comm_rating = float(score_str)
+        comm_raw = str(analysis.communication_skills).strip()
+        # allow '8/10' or '8 - good' forms: extract leading number
+        import re
+        m = re.search(r"(\d+(\.\d+)?)", comm_raw)
+        comm_val = float(m.group(1)) if m else float(comm_raw)
+        comm_val = max(0.0, min(10.0, comm_val))
     except Exception:
-        comm_rating = 5.0
-    total_score += (comm_rating / 10.0) * 20.0
+        comm_val = 5.0
+    total_score += (comm_val / 10.0) * 20.0
 
-    # 4. Certifications (Max 10)
-    total_score += min(len(analysis.certifications), 10) * 1.0
+    # Certifications -> up to 10 points (1 point each up to 10)
+    cert_points = min(len(analysis.certifications or []), 10) * 1.0
+    total_score += cert_points
 
-    # Therapist bonus (max 10)
-    if st.session_state.get('selected_role') == 'Therapist':
+    # Therapist-specific bonus up to 10 points
+    if role == "Therapist":
         try:
-            aba = float(str(analysis.aba_therapy_skills)) if str(analysis.aba_therapy_skills).upper() not in ['N/A', 'NONE', ''] else 0.0
-            autism = float(str(analysis.autism_care_experience_score)) if str(analysis.autism_care_experience_score).upper() not in ['N/A', 'NONE', ''] else 0.0
-            total_score += ((aba + autism) / 20.0) * 10.0
+            def safe_score(x):
+                try:
+                    m = re.search(r"(\d+(\.\d+)?)", str(x))
+                    return float(m.group(1)) if m else 0.0
+                except Exception:
+                    return 0.0
+
+            aba = safe_score(analysis.aba_therapy_skills)
+            autism = safe_score(analysis.autism_care_experience_score)
+            spec_bonus = ((aba + autism) / 20.0) * 10.0  # average scaled to 10
+            total_score += spec_bonus
         except Exception:
             pass
 
-    final_score = round(min(total_score, 100))
-    return float(final_score)
+    final = round(min(total_score, 100))
+    return float(final)
 
 
+# --- Append to session DataFrame helper ---
 def append_analysis_to_dataframe(job_role: str, analysis: ResumeAnalysis, score: float):
     data = analysis.dict()
-    data['Job Role'] = job_role
-    data['Resume Score'] = score
-    data['Shortlisted'] = 'No'
-
-    technical_skills_list = ", ".join(data.get('technical_skills', []))
-    certifications_list = ", ".join(data.get('certifications', []))
+    technical_skills_list = ", ".join(data.get('technical_skills') or [])
+    certifications_list = ", ".join(data.get('certifications') or [])
 
     df_data = {
-        'Name': data.get('name', ''),
+        'Name': data.get('name') or "",
         'Job Role': job_role,
         'Resume Score (100)': score,
-        'Email': data.get('email', ''),
-        'Phone': data.get('phone', ''),
-        'Shortlisted': data.get('Shortlisted', 'No'),
-        'Experience Summary': data.get('experience_summary', ''),
-        'Education Summary': data.get('education_summary', ''),
-        'Communication Rating (1-10)': str(data.get('communication_skills', 'N/A')),
+        'Email': data.get('email') or "",
+        'Phone': data.get('phone') or "",
+        'Shortlisted': 'No',
+        'Experience Summary': data.get('experience_summary') or "",
+        'Education Summary': data.get('education_summary') or "",
+        'Communication Rating (1-10)': str(data.get('communication_skills') or "N/A"),
         'Skills/Technologies': technical_skills_list,
         'Certifications': certifications_list,
-        'ABA Skills (1-10)': str(data.get('aba_therapy_skills', 'N/A')),
-        'RBT/BCBA Cert': str(data.get('rbt_bcba_certification', 'N/A')),
-        'Autism-Care Exp (1-10)': str(data.get('autism_care_experience_score', 'N/A')),
+        'ABA Skills (1-10)': str(data.get('aba_therapy_skills') or "N/A"),
+        'RBT/BCBA Cert': str(data.get('rbt_bcba_certification') or "N/A"),
+        'Autism-Care Exp (1-10)': str(data.get('autism_care_experience_score') or "N/A"),
     }
 
     new_df = pd.DataFrame([df_data])
     st.session_state.analyzed_data = pd.concat([st.session_state.analyzed_data, new_df], ignore_index=True)
 
-# --------------------
-# App layout
-# --------------------
+
+# --- Utility: Excel download as BytesIO for st.download_button ---
+def df_to_excel_bytes(df: pd.DataFrame) -> bytes:
+    output = io.BytesIO()
+    with pd.ExcelWriter(output, engine='openpyxl') as writer:
+        df.to_excel(writer, index=False, sheet_name="Resume Analysis Data")
+    return output.getvalue()
+
+
+# --- App Layout ---
 st.title("🌌 Quantum Scrutiny Platform: AI Resume Analysis")
 
 tab_user, tab_admin = st.tabs(["👤 Resume Uploader (User Panel)", "🔒 Admin Dashboard (Password Protected)"])
 
+# -------------------------
+# User Panel
+# -------------------------
 with tab_user:
     st.header("Upload Resumes for Analysis")
-    st.info("Upload multiple PDF or DOCX files. The Groq AI engine will extract and score key data. If the API key is missing, a fallback heuristic extractor will run.")
+    st.info("Upload multiple PDF or DOCX files. The Groq AI engine will extract and score key fields.")
 
     job_role_options = ["Software Engineer", "ML Engineer", "Therapist", "Data Analyst", "Project Manager"]
-    selected_role = st.selectbox("**1. Select the Target Job Role**", options=job_role_options, key='selected_role')
+    selected_role = st.selectbox("1. Select the Target Job Role", options=job_role_options, key="selected_role")
 
-    uploaded_files = st.file_uploader("**2. Upload Resumes** (PDF or DOCX)", type=["pdf", "docx"], accept_multiple_files=True)
+    uploaded_files = st.file_uploader(
+        "2. Upload Resumes (PDF or DOCX)", type=["pdf", "docx"], accept_multiple_files=True
+    )
 
+    # Analyze button sets a session_state flag and reruns
     if st.button("🚀 Analyze All Uploaded Resumes"):
         if not uploaded_files:
             st.warning("Please upload one or more resume files to begin analysis.")
         else:
-            total_files = len(uploaded_files)
-            progress_bar = st.progress(0.0)
-            st.session_state.individual_analysis = []
+            st.session_state.run_analysis = True
+            st.rerun()
 
+    # If run_analysis flag is set, process uploads
+    if st.session_state.get("run_analysis", False):
+        if not uploaded_files:
+            st.warning("No files found. Upload files and try again.")
+            st.session_state.run_analysis = False
+        else:
+            total = len(uploaded_files)
+            progress = st.progress(0)
+            st.session_state.individual_analysis = []
+            idx = 0
             with st.spinner("Processing resumes..."):
-                for i, file in enumerate(uploaded_files):
-                    file_name = file.name
-                    st.write(f"Analyzing **{file_name}**...")
-
-                    resume_text = extract_text_from_file(file)
-                    if not resume_text:
-                        st.error(f"Could not extract text from {file_name}. Skipping.")
-                        continue
-
-                    analysis = analyze_resume_with_groq(resume_text, selected_role)
-                    if isinstance(analysis, ResumeAnalysis) and analysis.name == "Extraction Failed":
-                        st.error(f"Extraction failed for {file_name}. Skipping.")
-                        continue
-
-                    score = calculate_resume_score(analysis)
-                    append_analysis_to_dataframe(selected_role, analysis, score)
-
-                    st.session_state.individual_analysis.append({
-                        'name': analysis.name,
-                        'score': score,
-                        'role': selected_role,
-                        'file_name': file_name
-                    })
-
-                    progress_bar.progress((i + 1) / total_files)
-
-            st.success(f"**✅ Successfully processed {len(st.session_state.individual_analysis)} / {total_files} resumes.**")
-
-    if 'individual_analysis' in st.session_state and st.session_state.individual_analysis:
+                for f in uploaded_files:
+                    idx += 1
+                    try:
+                        st.write(f"Analyzing **{f.name}**...")
+                        resume_text = extract_text_from_file(f)
+                        if not resume_text:
+                            st.error(f"Could not extract text from {f.name}. Skipping.")
+                            progress.progress(idx / total)
+                            continue
+
+                        # Call cached analyze function
+                        analysis = analyze_resume_with_groq_cached(resume_text, selected_role)
+
+                        if analysis.name == "Extraction Failed":
+                            st.error(f"Extraction failed for {f.name}. See debug output.")
+                            progress.progress(idx / total)
+                            continue
+
+                        score = calculate_resume_score(analysis, selected_role)
+                        append_analysis_to_dataframe(selected_role, analysis, score)
+
+                        st.session_state.individual_analysis.append({
+                            'name': analysis.name,
+                            'score': score,
+                            'role': selected_role,
+                            'file_name': f.name
+                        })
+                    except Exception as e:
+                        st.error(f"Error analyzing {f.name}: {e}")
+                        st.exception(traceback.format_exc())
+                    finally:
+                        progress.progress(idx / total)
+
+            st.success(f"✅ Successfully processed {len(st.session_state.individual_analysis)} of {total} resumes.")
+            st.session_state.run_analysis = False  # reset flag
+
+    # Show last analysis summary
+    if st.session_state.individual_analysis:
         st.subheader("Last Analysis Summary")
         for item in st.session_state.individual_analysis:
             st.markdown(f"**{item['name']}** (for **{item['role']}**) - **Score: {item['score']}/100**")
-
         st.markdown("---")
-        st.caption("All analyzed data is stored in the **Admin Dashboard**.")
+        st.caption("All analyzed data is stored in the Admin Dashboard.")
 
+# -------------------------
+# Admin Panel (Password Protected)
+# -------------------------
 with tab_admin:
     if not st.session_state.is_admin_logged_in:
         st.header("Admin Login")
@@ -374,17 +489,16 @@ with tab_admin:
         if st.button("🔑 Login"):
             if password == ADMIN_PASSWORD:
                 st.session_state.is_admin_logged_in = True
-                st.experimental_rerun()
+                st.rerun()
             else:
                 st.error("Incorrect password.")
+        # stop further admin rendering while not logged in
         st.stop()
 
     st.header("🎯 Recruitment Dashboard")
-    st.markdown("---")
-
     if st.button("🚪 Logout"):
         st.session_state.is_admin_logged_in = False
-        st.experimental_rerun()
+        st.rerun()
 
     if st.session_state.analyzed_data.empty:
         st.warning("No resume data has been analyzed yet. Please upload files in the User Panel.")
@@ -395,6 +509,7 @@ with tab_admin:
 
         display_cols = ['Name', 'Job Role', 'Resume Score (100)', 'Shortlisted', 'Email', 'Skills/Technologies']
 
+        # data_editor with SelectboxColumn for 'Shortlisted'
         edited_df = st.data_editor(
             df[display_cols],
             column_config={
@@ -402,31 +517,33 @@ with tab_admin:
                     "Shortlisted",
                     help="Mark the candidate as Shortlisted or Rejected.",
                     options=["No", "Yes"],
-                    required=True,
+                    required=True
                 )
             },
             key="dashboard_editor",
             hide_index=True
         )
 
-        # Persist shortlist changes back to session state
-        st.session_state.analyzed_data['Shortlisted'] = edited_df['Shortlisted']
+        # propagate the 'Shortlisted' edits back to session dataframe
+        try:
+            st.session_state.analyzed_data.loc[:, 'Shortlisted'] = edited_df['Shortlisted'].values
+        except Exception:
+            # fallback for indexing mismatches
+            for i, val in enumerate(edited_df['Shortlisted'].tolist()):
+                if i < len(st.session_state.analyzed_data):
+                    st.session_state.analyzed_data.at[i, 'Shortlisted'] = val
 
         st.markdown("---")
         st.subheader("📥 Download Data")
-
         df_export = st.session_state.analyzed_data.copy()
-        excel_buffer = io.BytesIO()
-        with pd.ExcelWriter(excel_buffer, engine='openpyxl') as writer:
-            df_export.to_excel(writer, index=False, sheet_name='Resume Analysis Data')
-        excel_buffer.seek(0)
+        excel_bytes = df_to_excel_bytes(df_export)
 
         st.download_button(
             label="💾 Download All Data as Excel (.xlsx)",
-            data=excel_buffer.getvalue(),
+            data=excel_bytes,
             file_name="quantum_scrutiny_report.xlsx",
             mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
             help="Downloads the full table including all extracted fields and shortlist status."
         )
 
-# End of file
+# --- End of app.py ---