Update app.py

app.py

@@ -24,28 +24,27 @@ 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 from PDF with robust error handling"""
+    """Extract text from PDF with detailed 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)}")
+        raise TypeError(f"Expected bytes, got {type(pdf_file)}")
     
     try:
-        # 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)")
+            raise ValueError("No text extracted from PDF (possibly image-based or empty)")
         
-        return text[:10000]  # Limit to first 10k chars
+        return text[:10000]
+    except PyPDF2.errors.PdfReadError as e:
+        raise Exception(f"PDF read error: {str(e)}")
     except Exception as e:
-        raise Exception(f"PDF extraction failed: {str(e)}")
+        raise Exception(f"Extraction error: {str(e)}")
     finally:
         gc.collect()
 
@@ -62,7 +61,6 @@ def calculate_scores(resume_text, job_desc=None):
         "customization": 0
     }
     
-    # Relevance calculation
     if job_desc:
         job_words = set(re.findall(r'\w+', job_desc.lower()))
         resume_words = set(re.findall(r'\w+', resume_lower))
@@ -70,11 +68,9 @@ def calculate_scores(resume_text, job_desc=None):
     else:
         scores["relevance_to_job"] = min(10, sum(1 for skill in GENERAL_SKILLS if skill in resume_lower))
 
-    # Experience calculation
     scores["experience_quality"] = min(10, len(YEAR_PATTERN.findall(resume_text)))
     scores["experience_quality"] += min(10, len(ACHIEVEMENT_PATTERN.findall(resume_text)) * 2)
 
-    # Education detection
     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:
@@ -87,12 +83,16 @@ 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 using Together AI inference"""
+    """Analyze resume and return extracted text and analysis"""
     try:
-        # Extract text from the uploaded PDF
+        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 {"error": f"Text extraction error: {str(e)}", "raw_result": "Not applicable"}
+        return {
+            "extracted_text": f"Extraction failed: {str(e)}",
+            "analysis": {"error": f"Text extraction error: {str(e)}", "raw_prompt": "Not generated", "raw_result": "Not applicable"}
+        }
     
     scores, total_score = calculate_scores(resume_text, job_desc)
     
@@ -104,25 +104,42 @@ def analyze_resume(pdf_file, job_desc=None, inference_fn=None):
     
     try:
         if inference_fn is None:
-            return {"error": "Inference function not provided", "raw_result": "Not available"}
+            return {
+                "extracted_text": resume_text,
+                "analysis": {"error": "Inference function not provided", "raw_prompt": prompt, "raw_result": "Not available"}
+            }
         
-        # Send prompt to Together AI (no file upload, just 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 {"error": "Empty response from Together AI", "raw_result": result}
+            return {
+                "extracted_text": resume_text,
+                "analysis": {"error": "Empty response from Together AI", "raw_prompt": prompt, "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_result": result  # Debug: Show raw response
+            "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 {"error": f"Failed to parse JSON: {str(e)}", "raw_result": result}
+        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 {"error": f"Unexpected error: {str(e)}", "raw_result": result if 'result' in locals() else "Not available"}
+        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"}
+        }
 
 # --- Gradio Interface --- #
 with gr.Blocks(theme=gr.themes.Soft(), fill_height=True) as demo:
@@ -131,7 +148,6 @@ with gr.Blocks(theme=gr.themes.Soft(), fill_height=True) as demo:
         gr.Markdown("Powered by mistralai/Mistral-7B-Instruct-v0.3 via Together AI API. Sign in to use.")
         button = gr.LoginButton("Sign in")
     
-    # Load Mistral-7B from Together AI
     inference = gr.load(
         "models/mistralai/Mistral-7B-Instruct-v0.3",
         accept_token=button,
@@ -145,12 +161,13 @@ with gr.Blocks(theme=gr.themes.Soft(), fill_height=True) as demo:
                 gr.Textbox(label="Job Description (Optional)", lines=3)
             ]
         with gr.Column(scale=2):
-            output = gr.JSON(label="Analysis")
+            extracted_text_output = gr.Textbox(label="Extracted Text", lines=10, interactive=False)
+            analysis_output = gr.JSON(label="Analysis")
     
     inputs[0].upload(
         fn=lambda pdf, job_desc: analyze_resume(pdf, job_desc, inference),
         inputs=inputs,
-        outputs=output,
+        outputs=[extracted_text_output, analysis_output],
         queue=True
     )