Update app.py

app.py

@@ -24,10 +24,28 @@ ACHIEVEMENT_PATTERN = re.compile(r'(increased|reduced|saved|improved)\s+by\s+(\d
 TYPO_PATTERN = re.compile(r'\b(?:responsibilities|accomplishment|experiance)\b', re.I)
 
 def extract_text_from_pdf(pdf_file):
-    """Extract text with memory cleanup"""
+    """Extract text from PDF with robust error handling"""
+    if pdf_file is None:
+        raise ValueError("No PDF file uploaded")
+    
+    # Check if pdf_file is bytes (binary data from Gradio)
+    if not isinstance(pdf_file, bytes):
+        raise TypeError(f"Expected binary data (bytes), got {type(pdf_file)}")
+    
     try:
-        text = PyPDF2.PdfReader(io.BytesIO(pdf_file)).pages[0].extract_text()
+        # Read binary data into PdfReader
+        pdf_reader = PyPDF2.PdfReader(io.BytesIO(pdf_file))
+        if len(pdf_reader.pages) == 0:
+            raise ValueError("PDF has no pages")
+        
+        # Extract text from first page
+        text = pdf_reader.pages[0].extract_text()
+        if text is None or text.strip() == "":
+            raise ValueError("No text extracted from PDF (possibly image-based)")
+        
         return text[:10000]  # Limit to first 10k chars
+    except Exception as e:
+        raise Exception(f"PDF extraction failed: {str(e)}")
     finally:
         gc.collect()
 
@@ -70,36 +88,41 @@ def calculate_scores(resume_text, job_desc=None):
 
 def analyze_resume(pdf_file, job_desc=None, inference_fn=None):
     """Analyze resume using Together AI inference"""
-    resume_text = extract_text_from_pdf(pdf_file)
+    try:
+        # Extract text from the uploaded PDF
+        resume_text = extract_text_from_pdf(pdf_file)
+    except Exception as e:
+        return {"error": f"Text extraction error: {str(e)}", "raw_result": "Not applicable"}
+    
     scores, total_score = calculate_scores(resume_text, job_desc)
     
-    # Stricter prompt to ensure JSON output
-    prompt = f"""Given these scores: {scores}, return a valid JSON object with:
-    - "strengths": list of 2 key strengths referencing the scores,
-    - "improvements": list of 3 specific improvements,
-    - "missing_skills": list of 2 missing skills (use job description if provided: {job_desc or "None"}).
-    Output ONLY a valid JSON string, no extra text or markdown."""
+    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."""
     
     try:
-        # Call Together AI inference
-        result = inference_fn(prompt)
-        # Debug: Log the raw result
-        print(f"Raw inference result: {result}")
+        if inference_fn is None:
+            return {"error": "Inference function not provided", "raw_result": "Not available"}
         
+        # Send prompt to Together AI (no file upload, just text)
+        result = inference_fn(prompt)
         if not result or result.strip() == "":
-            return {"error": "Empty response from inference API"}
+            return {"error": "Empty response from Together AI", "raw_result": result}
         
         # Parse the response as JSON
         parsed_result = json.loads(result)
         return {
             "score": {"total": total_score, "breakdown": scores},
             "analysis": parsed_result,
-            "raw_text": resume_text[:500]
+            "raw_text": resume_text[:500],
+            "raw_result": result  # Debug: Show raw response
         }
     except json.JSONDecodeError as e:
-        return {"error": f"Invalid JSON response: {result}"}
+        return {"error": f"Failed to parse JSON: {str(e)}", "raw_result": result}
     except Exception as e:
-        return {"error": str(e)}
+        return {"error": f"Unexpected error: {str(e)}", "raw_result": result if 'result' in locals() else "Not available"}
 
 # --- Gradio Interface --- #
 with gr.Blocks(theme=gr.themes.Soft(), fill_height=True) as demo: