Update app.py

app.py

@@ -3,7 +3,7 @@ import PyPDF2
 import io
 import re
 import json
-import os  # Added missing import
+import os
 import gc
 from huggingface_hub import login
 from dotenv import load_dotenv
@@ -12,6 +12,17 @@ from dotenv import load_dotenv
 load_dotenv()
 login(token=os.getenv("HF_TOKEN"))
 
+# Skills set for faster lookups
+GENERAL_SKILLS = {
+    'communication', 'problem solving', 'project management',
+    'python', 'sql', 'excel', 'teamwork'
+}
+
+# Precompiled regex patterns
+YEAR_PATTERN = re.compile(r'\d{4}\s*[-–]\s*(?:Present|\d{4})')
+ACHIEVEMENT_PATTERN = re.compile(r'(increased|reduced|saved|improved)\s+by\s+(\d+%|\$\d+)', re.I)
+TYPO_PATTERN = re.compile(r'\b(?:responsibilities|accomplishment|experiance)\b', re.I)
+
 def extract_text_from_pdf(pdf_file):
     """Extract text from PDF with detailed error handling"""
     if pdf_file is None:
@@ -43,105 +54,123 @@ def extract_text_from_pdf(pdf_file):
     finally:
         gc.collect()
 
-def generate_ai_prompt(resume_text, job_desc=None):
-    """Generates smart analysis prompt for AI"""
-    job_desc_section = f"\nCompare against this job description: {job_desc[:2000]}" if job_desc else ""
-    missing_keywords_section = ',\n      "missing_keywords": ["important", "missing", "terms"]' if job_desc else ""
+def calculate_scores(resume_text, job_desc=None):
+    """Optimized scoring function"""
+    resume_lower = resume_text.lower()
+    scores = {
+        "relevance_to_job": 0,
+        "experience_quality": 0,
+        "skills_match": 0,
+        "education": 0,
+        "achievements": 0,
+        "clarity": 10 - min(8, len(TYPO_PATTERN.findall(resume_text))),
+        "customization": 0
+    }
     
-    return f"""
-    Analyze this resume comprehensively:
-    {resume_text[:10000]}
-    {job_desc_section}
-    Return JSON with:
-    {{
-      "score": 0-100 (overall quality),
-      "score_breakdown": {{
-        "skills": 0-25 (variety and relevance),
-        "experience": 0-20 (duration and roles),
-        "achievements": 0-20 (quantifiable impact),
-        "education": 0-15,
-        "clarity": 0-10 (readability and structure),
-        "customization": 0-10 (job fit if JD provided)
-      }},
-      "detected_skills": ["list", "of", "skills", "with", "variants"],
-      "strengths": ["list", "of", "2-3", "key", "strengths"],
-      "improvements": ["3-5", "specific", "actionable", "suggestions"]{missing_keywords_section}
-    }}
-    """
+    if job_desc:
+        job_words = set(re.findall(r'\w+', job_desc.lower()))
+        resume_words = set(re.findall(r'\w+', resume_lower))
+        scores["relevance_to_job"] = min(20, int(20 * len(job_words & resume_words) / len(job_words))
+    else:
+        scores["relevance_to_job"] = min(10, sum(1 for skill in GENERAL_SKILLS if skill in resume_lower))
+
+    scores["experience_quality"] = min(10, len(YEAR_PATTERN.findall(resume_text)))
+    scores["experience_quality"] += min(10, len(ACHIEVEMENT_PATTERN.findall(resume_text)) * 2)
+
+    if 'phd' in resume_lower or 'doctorate' in resume_lower:
+        scores["education"] = 8
+    elif 'master' in resume_lower or 'msc' in resume_lower or 'mba' in resume_lower:
+        scores["education"] = 6
+    elif 'bachelor' in resume_lower or ' bs ' in resume_lower or ' ba ' in resume_lower:
+        scores["education"] = 4
+    elif 'high school' in resume_lower:
+        scores["education"] = 2
+
+    return scores, min(100, sum(scores.values()))
 
 def analyze_resume(pdf_file, job_desc=None, inference_fn=None):
-    """Main analysis function with AI integration"""
+    """Analyze resume and return extracted text and analysis as separate outputs"""
     try:
         resume_text = extract_text_from_pdf(pdf_file)
     except Exception as e:
         return (
-            f"Error: {str(e)}", 
-            {"error": str(e)}
+            f"Extraction failed: {str(e)}",  # First output for textbox
+            {"error": str(e)}  # Second output for JSON
         )
-
-    # Generate AI-powered analysis
-    prompt = generate_ai_prompt(resume_text, job_desc)
     
-    try:
-        if inference_fn:
+    scores, total_score = calculate_scores(resume_text, job_desc)
+    
+    # Basic analysis if inference fails
+    basic_analysis = {
+        "score": {
+            "total": total_score,
+            "breakdown": scores
+        },
+        "strengths": [
+            "Good clarity score" if scores["clarity"] > 7 else None,
+            "Relevant skills" if scores["relevance_to_job"] > 5 else None
+        ],
+        "improvements": [
+            "Add more measurable achievements" if scores["achievements"] < 3 else None,
+            "Include more relevant keywords" if scores["relevance_to_job"] < 5 else None,
+            "Check for typos" if scores["clarity"] < 9 else None
+        ],
+        "missing_skills": list(GENERAL_SKILLS - set(re.findall(r'\w+', resume_text.lower())))[:2]
+    }
+    
+    # Try to get enhanced analysis if inference function is available
+    if inference_fn:
+        prompt = f"""[Return valid JSON]: Based on these scores: {scores}, provide:
+        - "strengths": 2 key strengths,
+        - "improvements": 3 specific improvements,
+        - "missing_skills": 2 missing skills (use job description if provided: {job_desc or "None"}).
+        Output a valid JSON string only, no extra text."""
+        
+        try:
             result = inference_fn(prompt)
-            analysis = json.loads(result)
-            
-            # Ensure score calculation
-            if "score" not in analysis:
-                analysis["score"] = min(100, sum(analysis["score_breakdown"].values()))
-            
-            return (
-                resume_text[:5000],
-                {
-                    "analysis": analysis,
-                    "raw_prompt": prompt[:1000] if len(prompt) > 1000 else prompt
-                }
-            )
-    except Exception as e:
-        print(f"AI analysis error: {str(e)}")
+            if result and result.strip():
+                enhanced_analysis = json.loads(result)
+                return (
+                    resume_text[:5000],  # First output for textbox (limited to 5000 chars)
+                    {
+                        "score": {"total": total_score, "breakdown": scores},
+                        "analysis": enhanced_analysis,
+                        "raw_text_sample": resume_text[:200]
+                    }
+                )
+        except Exception as e:
+            print(f"Inference error: {str(e)}")
+            # Fall through to basic analysis
     
-    # Fallback basic analysis
     return (
-        resume_text[:5000],
+        resume_text[:5000],  # First output for textbox
         {
-            "error": "AI analysis unavailable",
-            "raw_text": resume_text[:1000]
+            "score": {"total": total_score, "breakdown": scores},
+            "analysis": basic_analysis,
+            "raw_text_sample": resume_text[:200]
         }
     )
 
-# --- Modern Gradio Interface --- #
-with gr.Blocks(theme=gr.themes.Soft(), title="AI Resume Analyzer") as demo:
+# --- Gradio Interface --- #
+with gr.Blocks(theme=gr.themes.Soft(), fill_height=True) as demo:
+    with gr.Sidebar():
+        gr.Markdown("# Resume Analyzer")
+        gr.Markdown("Upload your resume in PDF format for analysis")
+    
     with gr.Row():
-        with gr.Column():
-            gr.Markdown("## 🚀 Smart Resume Analysis")
-            with gr.Tab("Upload"):
-                pdf_input = gr.File(label="Resume (PDF)", type="binary")
-                job_desc_input = gr.Textbox(label="Job Description (Optional)", lines=5)
-                analyze_btn = gr.Button("Analyze", variant="primary")
-            
-            with gr.Tab("Example"):
-                gr.Examples(
-                    examples=["sample_resume.pdf"],
-                    inputs=pdf_input,
-                    label="Try with sample resume"
-                )
+        with gr.Column(scale=1):
+            pdf_input = gr.File(label="PDF Resume", type="binary")
+            job_desc_input = gr.Textbox(label="Job Description (Optional)", lines=3)
+            submit_btn = gr.Button("Analyze")
         
-        with gr.Column():
-            with gr.Tab("Results"):
-                score_gauge = gr.Gauge(label="Overall Score", minimum=0, maximum=100)
-                gr.Markdown("### 🔍 Analysis Breakdown")
-                analysis_output = gr.JSON(label="Details")
-            
-            with gr.Tab("Text Preview"):
-                extracted_text = gr.Textbox(label="Extracted Content", lines=15)
-
-    analyze_btn.click(
+        with gr.Column(scale=2):
+            extracted_text = gr.Textbox(label="Extracted Text", lines=10, interactive=False)
+            analysis_output = gr.JSON(label="Analysis Results")
+    
+    submit_btn.click(
         fn=analyze_resume,
         inputs=[pdf_input, job_desc_input],
-        outputs=[extracted_text, analysis_output],
-        api_name="analyze"
+        outputs=[extracted_text, analysis_output]
     )
 
-if __name__ == "__main__":
-    demo.launch(server_port=7860, share=True)
+demo.launch(share=True)