Update app.py

app.py

@@ -1,52 +1,49 @@
 # app.py
 """
 Quantum Scrutiny Platform | Groq-Powered
-Single-file Streamlit app (refactored & debugged)
+Single-file Streamlit app (refactored, Groq streaming-compatible)
 """
 
-# --- 0. Always set page config as the first Streamlit command ---
 import os
-from dotenv import load_dotenv
-
-load_dotenv()  # load local .env if present (during local dev)
-
 import io
+import re
+import json
 import base64
 import traceback
 from typing import Optional, List
 
+from dotenv import load_dotenv
+load_dotenv()
+
 import streamlit as st
 import pandas as pd
 
-# resume parsing
-import fitz                  # PyMuPDF
-from docx import Document    # python-docx
+# File parsing
+import fitz                   # PyMuPDF
+from docx import Document     # python-docx
 
-# Groq client (keep same import name as you used)
+# Groq client
 from groq import Groq
 
-# Pydantic for schema validation
+# Validation
 from pydantic import BaseModel, Field, ValidationError
 
-# --- Streamlit UI config ---
+# --- Page config ---
 st.set_page_config(layout="wide", page_title="Quantum Scrutiny Platform | Groq-Powered")
 
 # --- 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
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "admin")
 
-# --- Initialize Groq client with safe error messaging ---
+# Initialize Groq client (no API key -> UI warning but app still loads)
 groq_client = None
-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:
+if GROQ_API_KEY:
     try:
         groq_client = Groq(api_key=GROQ_API_KEY)
     except Exception as e:
         st.error(f"Failed to initialize Groq client: {e}")
-        groq_client = None
-
+else:
+    st.warning("GROQ_API_KEY not found. Set it as an environment variable or in .env for model calls to work.")
 
 # --- Session state defaults ---
 if 'is_admin_logged_in' not in st.session_state:
@@ -64,139 +61,173 @@ if 'individual_analysis' not in st.session_state:
 if 'run_analysis' not in st.session_state:
     st.session_state.run_analysis = False
 
-
-# --- Pydantic schema for Groq output ---
+# --- Pydantic schema ---
 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="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'.")
-
-
-# --- Helper: File text extraction ---
+    name: str = Field(default="Unknown")
+    email: str = Field(default="")
+    phone: str = Field(default="")
+    certifications: List[str] = Field(default_factory=list)
+    experience_summary: str = Field(default="")
+    education_summary: str = Field(default="")
+    communication_skills: str = Field(default="N/A")
+    technical_skills: List[str] = Field(default_factory=list)
+    aba_therapy_skills: Optional[str] = Field(default="N/A")
+    rbt_bcba_certification: Optional[str] = Field(default="N/A")
+    autism_care_experience_score: Optional[str] = Field(default="N/A")
+
+
+# --- Helpers: file text extraction ---
 def extract_text_from_file(uploaded_file) -> str:
-    """
-    Accepts a Streamlit UploadedFile object and returns extracted text.
-    Supports PDF and DOCX. Returns empty string on failure.
-    """
+    """Extract text from PDF or DOCX. Returns empty string on failure."""
     try:
         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)
+        filename = uploaded_file.name.lower()
+        if filename.endswith(".pdf") or content[:5] == b"%PDF-":
             try:
                 with fitz.open(stream=content, filetype="pdf") as doc:
-                    pages_text = []
+                    text = ""
                     for p in doc:
-                        pages_text.append(p.get_text())
-                return "\n".join(pages_text).strip()
-            except Exception as e:
-                # fallback: try PyMuPDF alternative reading
-                st.warning(f"PDF extraction issue for {uploaded_file.name}: {e}")
+                        text += p.get_text()
+                return text.strip()
+            except Exception:
                 return ""
-        elif name_lower.endswith(".docx"):
-            # python-docx can accept a file-like object
+        elif filename.endswith(".docx"):
             try:
                 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.warning(f"DOCX extraction issue for {uploaded_file.name}: {e}")
+            except Exception:
                 return ""
         else:
-            # Try simple decode for text-like files
+            # fallback: decode bytes as text
             try:
                 return content.decode('utf-8', errors='ignore')
             except Exception:
                 return ""
-    except Exception as e:
-        st.error(f"Unexpected file extraction error: {e}")
+    except Exception:
         return ""
 
 
-# --- Helper: call Groq (safe wrapper) ---
-def call_groq_chat_system(resume_text: str, job_role: str) -> Optional[str]:
+# --- Groq call with streaming (collects chunks) ---
+def call_groq_stream_collect(prompt: str, model_name: str = "llama-3.3-70b-versatile", temperature: float = 0.2, max_completion_tokens: int = 2048, top_p: float = 1.0) -> Optional[str]:
     """
-    Calls Groq chat completion. Returns model text content or None on error.
-    Note: groq_client must be initialized.
+    Calls Groq with streaming enabled and collects the textual output.
+    Returns the full model text, or None on failure.
     """
     if not groq_client:
-        st.error("Groq client is not initialized. Set GROQ_API_KEY in environment or secrets.")
+        st.error("Groq client not initialized. Set GROQ_API_KEY in environment/secrets.")
         return None
 
-    # role-specific instructions
-    therapist_instructions = ""
-    if job_role == "Therapist":
-        therapist_instructions = (
-            "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 = (
-            "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 = (
-        "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:
-        result = groq_client.chat.completions.create(
-            model="mixtral-8x7b-32768",  # keep your original model choice; adapt if needed
+        completion = groq_client.chat.completions.create(
+            model=model_name,
             messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_prompt}
+                {"role": "system", "content": "You are a professional Resume Analyzer. Return JSON only when asked."},
+                {"role": "user", "content": prompt}
             ],
-            temperature=0.0,
-            max_tokens=2000,
-            # Not all Groq SDK versions support response_model in the same way; we parse manually below.
+            temperature=temperature,
+            max_completion_tokens=max_completion_tokens,
+            top_p=top_p,
+            stream=True
         )
-        # Depending on SDK, result structure varies; common: result.choices[0].message.content
-        model_text = None
-        try:
-            model_text = result.choices[0].message.content
-        except Exception:
-            # try alternate structure
+
+        # completion is an iterator/streamable object; collect chunks
+        collected = ""
+        # some SDKs yield dict-like chunks, some objects; handle both
+        for chunk in completion:
             try:
-                model_text = result["choices"][0]["message"]["content"]
+                # Common pattern: chunk.choices[0].delta.content
+                delta = getattr(chunk.choices[0].delta, "content", None) if hasattr(chunk, "choices") else None
+                if delta is None:
+                    # fallback for dict-like object
+                    if isinstance(chunk, dict):
+                        delta = chunk.get("choices", [{}])[0].get("delta", {}).get("content")
+                if delta:
+                    collected += delta
+                else:
+                    # Some SDKs return final message in chunk.choices[0].message.content
+                    try:
+                        msg = getattr(chunk.choices[0].message, "content", None)
+                        if msg:
+                            collected += msg
+                    except Exception:
+                        pass
             except Exception:
-                model_text = str(result)
+                # last-resort: append str(chunk)
+                try:
+                    collected += str(chunk)
+                except Exception:
+                    pass
 
-        return model_text
+        return collected.strip()
     except Exception as e:
         st.error(f"Groq API call failed: {e}")
-        st.exception(e)
         return None
 
 
-# --- Cached wrapper for analysis (cache by resume_text + role) ---
+# --- Parsing model output safely to JSON ---
+def extract_first_json(text: str) -> Optional[dict]:
+    """
+    Find the first JSON object in text and parse it; return dict or None.
+    """
+    if not text:
+        return None
+    # find first balanced braces block
+    # quick heuristic regex for {...}
+    try:
+        match = re.search(r"(\{(?:[^{}]|(?R))*\})", text, re.DOTALL)
+    except re.error:
+        # Python's re doesn't support (?R); fallback to simpler greedy
+        match = re.search(r"(\{.*\})", text, re.DOTALL)
+    if match:
+        json_text = match.group(1)
+    else:
+        # maybe the model returned only JSON-like lines -> try to parse full text
+        json_text = text
+
+    try:
+        parsed = json.loads(json_text)
+        return parsed
+    except Exception:
+        # try to clean common issues: single quotes -> double quotes
+        try:
+            json_text_fixed = json_text.replace("'", '"')
+            parsed = json.loads(json_text_fixed)
+            return parsed
+        except Exception:
+            return None
+
+
+# --- Analyze with Groq (cached 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.
+    Calls Groq (streaming) and returns a ResumeAnalysis instance.
+    Uses caching to avoid duplicate calls for same resume_text+role.
     """
-    raw_response = call_groq_chat_system(resume_text, job_role)
-    if not raw_response:
-        # return safe failure object
+    # Build prompt instructing JSON structure
+    therapist_instructions = ""
+    if job_role.lower() == "therapist":
+        therapist_instructions = (
+            "Because the role is 'Therapist', carefully search for ABA Therapy Skills, "
+            "RBT/BCBA Certification, and Autism-Care Experience. Provide scores 1-10 as STRINGS, or 'N/A'."
+        )
+    else:
+        therapist_instructions = "If therapist-specific fields are not relevant, set them to 'N/A'."
+
+    system_user_prompt = (
+        "Return a single JSON object with the following keys exactly: "
+        "name (string), email (string), phone (string), certifications (array of strings), "
+        "experience_summary (string), education_summary (string), communication_skills (STRING, e.g., '8'), "
+        "technical_skills (array of strings), aba_therapy_skills (STRING or 'N/A'), "
+        "rbt_bcba_certification (STRING 'Yes'/'No'/'N/A'), autism_care_experience_score (STRING or 'N/A'). "
+        f"{therapist_instructions}\n\nResume Text:\n\n{resume_text}\n\nReturn only the JSON object."
+    )
+
+    raw = call_groq_stream_collect(system_user_prompt, model_name="llama-3.3-70b-versatile", temperature=0.0, max_completion_tokens=2048)
+
+    if not raw:
+        # fallback empty object
         return ResumeAnalysis(
             name="Extraction Failed",
             email="",
@@ -211,75 +242,11 @@ def analyze_resume_with_groq_cached(resume_text: str, job_role: str) -> ResumeAn
             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:
-        # 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])
-
-        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")
-
-        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)
+    parsed = extract_first_json(raw)
+    if not parsed:
+        # show raw output for debugging when developer runs app locally (admin panel will show too)
+        st.warning("Failed to parse model JSON output. See raw output below for debugging.")
+        st.text_area("Raw model output (debug)", raw, height=200)
         return ResumeAnalysis(
             name="Extraction Failed",
             email="",
@@ -293,9 +260,37 @@ def analyze_resume_with_groq_cached(resume_text: str, job_role: str) -> ResumeAn
             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)
+
+    # Ensure keys exist and coerce types
+    parsed.setdefault("name", "Unknown")
+    parsed.setdefault("email", "")
+    parsed.setdefault("phone", "")
+    parsed.setdefault("certifications", [])
+    parsed.setdefault("experience_summary", "")
+    parsed.setdefault("education_summary", "")
+    parsed.setdefault("communication_skills", "N/A")
+    parsed.setdefault("technical_skills", [])
+    parsed.setdefault("aba_therapy_skills", "N/A")
+    parsed.setdefault("rbt_bcba_certification", "N/A")
+    parsed.setdefault("autism_care_experience_score", "N/A")
+
+    # Ensure string coercions for some fields
+    try:
+        parsed["communication_skills"] = str(parsed.get("communication_skills") or "N/A")
+        parsed["aba_therapy_skills"] = str(parsed.get("aba_therapy_skills") or "N/A")
+        parsed["rbt_bcba_certification"] = str(parsed.get("rbt_bcba_certification") or "N/A")
+        parsed["autism_care_experience_score"] = str(parsed.get("autism_care_experience_score") or "N/A")
+    except Exception:
+        pass
+
+    # Validate via Pydantic
+    try:
+        analysis = ResumeAnalysis.parse_obj(parsed)
+        return analysis
+    except ValidationError as ve:
+        st.error("Model output failed schema validation.")
+        st.text_area("Raw model output (debug)", raw, height=200)
+        st.exception(ve)
         return ResumeAnalysis(
             name="Extraction Failed",
             email="",
@@ -311,112 +306,97 @@ def analyze_resume_with_groq_cached(resume_text: str, job_role: str) -> ResumeAn
         )
 
 
-# --- Scoring function ---
+# --- Scoring logic ---
 def calculate_resume_score(analysis: ResumeAnalysis, role: str) -> float:
     total_score = 0.0
 
-    # Experience summary length -> up to 40 points
+    # Experience summary: up to 40
     exp_len = len(analysis.experience_summary or "")
-    exp_factor = min(exp_len / 100.0, 1.0)  # 100 chars or more -> full points
+    exp_factor = min(exp_len / 100.0, 1.0)
     total_score += exp_factor * 40.0
 
-    # Skills count -> up to 30 points
+    # Skills count: up to 30
     skills_count = len(analysis.technical_skills or [])
     skills_factor = min(skills_count / 10.0, 1.0)
     total_score += skills_factor * 30.0
 
-    # Communication -> up to 20 points (expects 1-10 in string)
+    # Communication: up to 20 (expects 0-10 in string)
     try:
-        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)
+        m = re.search(r"(\d+(\.\d+)?)", str(analysis.communication_skills))
+        comm_val = float(m.group(1)) if m else float(str(analysis.communication_skills))
         comm_val = max(0.0, min(10.0, comm_val))
     except Exception:
         comm_val = 5.0
     total_score += (comm_val / 10.0) * 20.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
+    # Certifications: up to 10
+    total_score += min(len(analysis.certifications or []), 10) * 1.0
 
-    # Therapist-specific bonus up to 10 points
-    if role == "Therapist":
-        try:
-            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
+    # Therapist bonus up to 10
+    if role.lower() == "therapist":
+        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
+        total_score += spec_bonus
 
     final = round(min(total_score, 100))
     return float(final)
 
 
-# --- Append to session DataFrame helper ---
+# --- Append to DataFrame ---
 def append_analysis_to_dataframe(job_role: str, analysis: ResumeAnalysis, score: float):
     data = analysis.dict()
-    technical_skills_list = ", ".join(data.get('technical_skills') or [])
-    certifications_list = ", ".join(data.get('certifications') or [])
-
-    df_data = {
-        'Name': data.get('name') or "",
+    tech = ", ".join(data.get("technical_skills") or [])
+    certs = ", ".join(data.get("certifications") or [])
+    row = {
+        'Name': data.get("name") or "",
         'Job Role': job_role,
         'Resume Score (100)': score,
-        'Email': data.get('email') or "",
-        'Phone': data.get('phone') or "",
+        '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') 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"),
+        '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': tech,
+        'Certifications': certs,
+        '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])
+    new_df = pd.DataFrame([row])
     st.session_state.analyzed_data = pd.concat([st.session_state.analyzed_data, new_df], ignore_index=True)
 
 
-# --- Utility: Excel download as BytesIO for st.download_button ---
+# --- Excel export helper ---
 def df_to_excel_bytes(df: pd.DataFrame) -> bytes:
     output = io.BytesIO()
-    with pd.ExcelWriter(output, engine='openpyxl') as writer:
+    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")
+# --- UI Layout ---
+st.title("🌌 Quantum Scrutiny Platform: AI Resume Analysis (Single-file)")
 
 tab_user, tab_admin = st.tabs(["👤 Resume Uploader (User Panel)", "🔒 Admin Dashboard (Password Protected)"])
 
-# -------------------------
-# User Panel
-# -------------------------
+# --- 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 fields.")
+    st.info("Upload multiple PDF or DOCX files. The Groq AI engine will extract and score 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")
 
-    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.")
@@ -424,7 +404,6 @@ with tab_user:
             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.")
@@ -445,7 +424,6 @@ with tab_user:
                             progress.progress(idx / total)
                             continue
 
-                        # Call cached analyze function
                         analysis = analyze_resume_with_groq_cached(resume_text, selected_role)
 
                         if analysis.name == "Extraction Failed":
@@ -469,9 +447,9 @@ with tab_user:
                         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
+            st.session_state.run_analysis = False
 
-    # Show last analysis summary
+    # Display last results summary
     if st.session_state.individual_analysis:
         st.subheader("Last Analysis Summary")
         for item in st.session_state.individual_analysis:
@@ -479,9 +457,7 @@ with tab_user:
         st.markdown("---")
         st.caption("All analyzed data is stored in the Admin Dashboard.")
 
-# -------------------------
-# Admin Panel (Password Protected)
-# -------------------------
+# --- Admin Panel ---
 with tab_admin:
     if not st.session_state.is_admin_logged_in:
         st.header("Admin Login")
@@ -492,7 +468,6 @@ with tab_admin:
                 st.rerun()
             else:
                 st.error("Incorrect password.")
-        # stop further admin rendering while not logged in
         st.stop()
 
     st.header("🎯 Recruitment Dashboard")
@@ -509,7 +484,6 @@ 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={
@@ -524,11 +498,9 @@ with tab_admin:
             hide_index=True
         )
 
-        # 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
@@ -546,4 +518,4 @@ with tab_admin:
             help="Downloads the full table including all extracted fields and shortlist status."
         )
 
-# --- End of app.py ---
+# --- End of file ---