Update app.py

app.py

@@ -28,19 +28,25 @@ def extract_text_from_pdf(pdf_file):
     if pdf_file is None:
         raise ValueError("No PDF file uploaded")
     
-    if not isinstance(pdf_file, bytes):
-        raise TypeError(f"Expected bytes, got {type(pdf_file)}")
+    # Handle both file path and bytes input
+    if isinstance(pdf_file, str):
+        with open(pdf_file, 'rb') as f:
+            file_bytes = f.read()
+    elif isinstance(pdf_file, bytes):
+        file_bytes = pdf_file
+    else:
+        raise TypeError(f"Expected file path or bytes, got {type(pdf_file)}")
     
     try:
-        pdf_reader = PyPDF2.PdfReader(io.BytesIO(pdf_file))
+        pdf_reader = PyPDF2.PdfReader(io.BytesIO(file_bytes))
         if len(pdf_reader.pages) == 0:
             raise ValueError("PDF has no pages")
         
-        text = pdf_reader.pages[0].extract_text()
+        text = "\n".join(page.extract_text() for page in pdf_reader.pages)
         if text is None or text.strip() == "":
             raise ValueError("No text extracted from PDF (possibly image-based or empty)")
         
-        return text[:10000]
+        return text[:10000]  # Limit to first 10,000 characters
     except PyPDF2.errors.PdfReadError as e:
         raise Exception(f"PDF read error: {str(e)}")
     except Exception as e:
@@ -64,7 +70,7 @@ def calculate_scores(resume_text, job_desc=None):
     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)))
+        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))
 
@@ -83,92 +89,88 @@ def calculate_scores(resume_text, job_desc=None):
     return scores, min(100, sum(scores.values()))
 
 def analyze_resume(pdf_file, job_desc=None, inference_fn=None):
-    """Analyze resume and return extracted text and analysis"""
+    """Analyze resume and return extracted text and analysis as separate outputs"""
     try:
-        print(f"Received pdf_file type: {type(pdf_file)}")  # Debug: Log input type
         resume_text = extract_text_from_pdf(pdf_file)
-        print(f"Extracted text: {resume_text[:100]}")  # Debug: Log first 100 chars
     except Exception as e:
-        return {
-            "extracted_text": f"Extraction failed: {str(e)}",
-            "analysis": {"error": f"Text extraction error: {str(e)}", "raw_prompt": "Not generated", "raw_result": "Not applicable"}
-        }
+        return (
+            f"Extraction failed: {str(e)}",  # First output for textbox
+            {"error": str(e)}  # Second output for JSON
+        )
     
     scores, total_score = calculate_scores(resume_text, job_desc)
     
-    prompt = f"""[Return valid JSON]: Based on these scores: {scores}, provide:
-    - "strengths": 2 key strengths (e.g., "High experience quality" if score is high),
-    - "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."""
+    # 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:
-        if inference_fn is None:
-            return {
-                "extracted_text": resume_text,
-                "analysis": {"error": "Inference function not provided", "raw_prompt": prompt, "raw_result": "Not available"}
-            }
+    # 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."""
         
-        print(f"Prompt sent to Together AI: {prompt}")  # Debug: Log prompt
-        result = inference_fn(prompt)
-        print(f"Raw result from Together AI: {result}")  # Debug: Log response
-        
-        if not result or result.strip() == "":
-            return {
-                "extracted_text": resume_text,
-                "analysis": {"error": "Empty response from Together AI", "raw_prompt": prompt, "raw_result": result}
-            }
-        
-        parsed_result = json.loads(result)
-        return {
-            "extracted_text": resume_text,
-            "analysis": {
-                "score": {"total": total_score, "breakdown": scores},
-                "analysis": parsed_result,
-                "raw_text": resume_text[:500],
-                "raw_prompt": prompt,
-                "raw_result": result
-            }
-        }
-    except json.JSONDecodeError as e:
-        return {
-            "extracted_text": resume_text,
-            "analysis": {"error": f"Failed to parse JSON: {str(e)}", "raw_prompt": prompt, "raw_result": result}
-        }
-    except Exception as e:
-        return {
-            "extracted_text": resume_text,
-            "analysis": {"error": f"Unexpected inference error: {str(e)}", "raw_prompt": prompt, "raw_result": result if 'result' in locals() else "Not available"}
+        try:
+            result = inference_fn(prompt)
+            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
+    
+    return (
+        resume_text[:5000],  # First output for textbox
+        {
+            "score": {"total": total_score, "breakdown": scores},
+            "analysis": basic_analysis,
+            "raw_text_sample": resume_text[:200]
         }
+    )
 
 # --- Gradio Interface --- #
 with gr.Blocks(theme=gr.themes.Soft(), fill_height=True) as demo:
     with gr.Sidebar():
-        gr.Markdown("# Resume Analyzer with Mistral-7B")
-        gr.Markdown("Powered by mistralai/Mistral-7B-Instruct-v0.3 via Together AI API. Sign in to use.")
-        button = gr.LoginButton("Sign in")
-    
-    inference = gr.load(
-        "models/mistralai/Mistral-7B-Instruct-v0.3",
-        accept_token=button,
-        provider="together"
-    )
+        gr.Markdown("# Resume Analyzer")
+        gr.Markdown("Upload your resume in PDF format for analysis")
     
     with gr.Row():
         with gr.Column(scale=1):
-            inputs = [
-                gr.File(label="PDF Resume", type="binary"),
-                gr.Textbox(label="Job Description (Optional)", lines=3)
-            ]
+            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(scale=2):
-            extracted_text_output = gr.Textbox(label="Extracted Text", lines=10, interactive=False)
-            analysis_output = gr.JSON(label="Analysis")
+            extracted_text = gr.Textbox(label="Extracted Text", lines=10, interactive=False)
+            analysis_output = gr.JSON(label="Analysis Results")
     
-    inputs[0].upload(
-        fn=lambda pdf, job_desc: analyze_resume(pdf, job_desc, inference),
-        inputs=inputs,
-        outputs=[extracted_text_output, analysis_output],
-        queue=True
+    submit_btn.click(
+        fn=analyze_resume,
+        inputs=[pdf_input, job_desc_input],
+        outputs=[extracted_text, analysis_output]
     )
 
 demo.launch(share=True)