Update app.py

app.py

@@ -1,109 +1,53 @@
-import os
-import gradio as gr
-import PyPDF2
-import docx
-import requests
-import json
-import re  # Added for regex pattern replacement
-
-# Function to extract text from PDF
-def extract_text_from_pdf(file):
-    pdf_reader = PyPDF2.PdfReader(file)
-    text = ""
-    for page in pdf_reader.pages:
-        text += page.extract_text()
-    return text
-
-# Function to extract text from Word document
-def extract_text_from_docx(file):
-    doc = docx.Document(file)
-    text = "\n".join([para.text for para in doc.paragraphs])
-    return text
-
-# Function to process uploaded file
-def process_uploaded_file(file):
-    filename = file.name.lower()  # Case-insensitive check
-    if filename.endswith(".pdf"):
-        return extract_text_from_pdf(file)
-    elif filename.endswith(".docx"):
-        return extract_text_from_docx(file)
-    else:
-        raise ValueError("Unsupported file format. Please upload a PDF or Word document.")
-
-# Function to clean JSON string with escaped backslashes
-def clean_json_string(json_str):
-    # Replace escaped backslashes with a temporary marker
-    temp_str = json_str.replace('\\_', '__UNDERSCORE__')
-    
-    # Attempt to fix any other common escape sequence issues
-    temp_str = temp_str.replace('\\n', '\n')
-    temp_str = temp_str.replace('\\t', '\t')
-    temp_str = temp_str.replace('\\r', '\r')
-    
-    # Remove any remaining unmatched backslashes
-    temp_str = temp_str.replace('\\', '')
-    
-    # Restore underscores
-    cleaned_str = temp_str.replace('__UNDERSCORE__', '_')
-    
-    return cleaned_str
-
-# Function to call Together API
-def analyze_with_mistral(resume_text, job_description):
-    TOGETHER_API_KEY = os.getenv("HUGGINGFACE_API_KEY")
-    url = "https://api.together.xyz/v1/chat/completions"
-    
-    messages = [
+messages = [
     {
         "role": "system",
-        "content": "You are an AI expert in Applicant Tracking System (ATS) resume analysis. Your task is to evaluate resumes for ATS compatibility based on provided job descriptions and return results in a specific JSON format."
+        "content": "You are an AI expert in ATS resume analysis. Your task is to analyze a resume against a job description for ATS compatibility and return the result in a specific JSON format."
     },
     {
         "role": "user",
         "content": """
-        Analyze the provided resume against the job description for ATS compatibility. Assess how well the resume aligns with ATS requirements and the job description in terms of keywords, formatting, skills, experience relevance, and education. Provide concise, actionable recommendations for improvement.
+        Analyze the provided resume against the job description for ATS compatibility. Assess keywords, formatting, skills, experience relevance, and education. Return the result by filling in the EXACT JSON template below with appropriate values and recommendations. Output ONLY the completed JSON, with no additional text, comments, or explanations. Ensure all fields are populated, even if with empty lists or default scores.
 
-        Return the output in EXACTLY this JSON format, with no deviations, ensuring the full structure is complete:
+        JSON Template to Fill:
         {
           "ATS Parameters": {
             "Keywords": {
-              "Match": <integer score between 0 and 100>,
-              "Recommendation": [<list of 2-5 specific keywords to add or emphasize>]
+              "Match": <integer 0-100>,
+              "Recommendation": [<list of 0-5 strings>]
             },
             "Formatting": {
-              "Match": <integer score between 0 and 100>,
-              "Recommendation": [<list of 2-5 specific formatting suggestions>]
+              "Match": <integer 0-100>,
+              "Recommendation": [<list of 0-5 strings>]
             },
             "Skills Match": {
-              "Match": <integer score between 0 and 100>,
-              "Recommendation": [<list of 2-5 specific skills to include or highlight>]
+              "Match": <integer 0-100>,
+              "Recommendation": [<list of 0-5 strings>]
             },
             "Experience Relevance": {
-              "Match": <integer score between 0 and 100>,
-              "Recommendation": [<list of 2-5 suggestions to improve experience alignment>]
+              "Match": <integer 0-100>,
+              "Recommendation": [<list of 0-5 strings>]
             },
             "Education": {
-              "Match": <integer score between 0 and 100>,
-              "Recommendation": [<list of 2-5 suggestions to improve education section>]
+              "Match": <integer 0-100>,
+              "Recommendation": [<list of 0-5 strings>]
             }
           },
           "Score": {
-            "Keywords": <integer score between 0 and 100>,
-            "Formatting": <integer score between 0 and 100>,
-            "Skills Match": <integer score between 0 and 100>,
-            "Experience Relevance": <integer score between 0 and 100>,
-            "Education": <integer score between 0 and 100>,
-            "Overall": <integer average score between 0 and 100>
+            "Keywords": <integer 0-100>,
+            "Formatting": <integer 0-100>,
+            "Skills Match": <integer 0-100>,
+            "Experience Relevance": <integer 0-100>,
+            "Education": <integer 0-100>,
+            "Overall": <integer 0-100, average of above scores>
           }
         }
 
         Rules:
-        - All "Match" values must be integers between 0 and 100.
-        - All "Recommendation" fields must be lists of strings (2-5 items max), or empty lists ([]) if no suggestions apply.
-        - "Overall" score is the average of the five "Score" values, rounded to the nearest integer.
-        - Base analysis on typical ATS requirements (e.g., keyword density, simple formatting, clear sections) and the job description.
-        - Ensure the ENTIRE JSON structure is returned, even if recommendations are minimal.
-        - Keep recommendations concise to fit within response limits.
+        - Replace <integer 0-100> with an integer score between 0 and 100.
+        - Replace <list of 0-5 strings> with a list of 0 to 5 concise string recommendations (e.g., [] if none).
+        - "Overall" is the rounded average of the five "Score" values.
+        - Base analysis on ATS requirements (keyword density, simple formatting, etc.) and the job description.
+        - Output ONLY the filled JSON template, nothing else.
 
         Resume:
         {resume_text}
@@ -112,104 +56,4 @@ def analyze_with_mistral(resume_text, job_description):
         {job_description}
         """
     }
-]
-    
-    payload = {
-        "model": "mistralai/Mistral-7B-Instruct-v0.3",
-        "messages": messages,
-        "max_tokens": 1500,
-        "temperature": 0.7,
-        "top_p": 0.9,
-        "response_format": {"type": "json_object"}
-    }
-    
-    headers = {
-        "Authorization": f"Bearer {TOGETHER_API_KEY}",
-        "Content-Type": "application/json",
-    }
-    
-    try:
-        response = requests.post(url, json=payload, headers=headers, timeout=30)
-        response.raise_for_status()
-        result = response.json()
-        content = result.get("choices", [{}])[0].get("message", {}).get("content", "{}")
-        
-        # Clean the JSON string before parsing
-        cleaned_content = clean_json_string(content)
-        
-        try:
-            parsed = json.loads(cleaned_content)
-            # Check if the JSON structure is valid for our use case
-            if "ATS_Compatibility" not in parsed or "Overall_Assessment" not in parsed:
-                return {
-                    "error": "API returned unexpected JSON structure",
-                    "raw_content": cleaned_content[:500] + "..." if len(cleaned_content) > 500 else cleaned_content
-                }
-            return parsed
-        except json.JSONDecodeError as e:
-            # Try a more aggressive approach to fix the JSON
-            try:
-                # Sometimes the model might include trailing characters
-                # Try to find the closing bracket of the main JSON object
-                match = re.search(r'(\{.*\})', cleaned_content, re.DOTALL)
-                if match:
-                    extracted_json = match.group(1)
-                    parsed = json.loads(extracted_json)
-                    if "ATS_Compatibility" in parsed and "Overall_Assessment" in parsed:
-                        return parsed
-            except:
-                pass
-                
-            # If all attempts fail, return the error
-            return {
-                "error": f"Failed to parse API response: {str(e)}",
-                "raw_content": cleaned_content[:500] + "..." if len(cleaned_content) > 500 else cleaned_content
-            }
-        
-    except requests.exceptions.RequestException as e:
-        return {"error": f"API request failed: {str(e)}"}
-    except Exception as e:
-        return {"error": f"Unexpected error: {str(e)}"}
-
-# Main function
-def analyze_resume(file, job_description):
-    try:
-        if not file:
-            return json.dumps({"error": "Please upload a resume file"}, indent=2)
-        if not job_description:
-            return json.dumps({"error": "Please enter a job description"}, indent=2)
-        
-        resume_text = process_uploaded_file(file)
-        result = analyze_with_mistral(resume_text, job_description)
-        
-        # Return as formatted JSON string for better display
-        return json.dumps(result, indent=2, ensure_ascii=False)
-        
-    except Exception as e:
-        return json.dumps({"error": f"Error analyzing resume: {str(e)}"}, indent=2)
-
-# Gradio interface
-with gr.Blocks(fill_height=True, title="Smart ATS Resume Analyzer") as demo:
-    with gr.Sidebar():
-        gr.Markdown("# Smart ATS Resume Analyzer")
-        gr.Markdown("Upload your resume (PDF/Word) and enter a job description to get an ATS compatibility score.")
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            resume_upload = gr.File(
-                label="Upload Resume (PDF or Word)", 
-                file_types=[".pdf", ".docx"],
-                type="filepath"
-            )
-            job_desc = gr.Textbox(label="Job Description", lines=10, placeholder="Paste the job description here...")
-            submit_btn = gr.Button("Analyze Resume")
-        with gr.Column(scale=2):
-            output = gr.JSON(label="ATS Analysis Result")
-    
-    submit_btn.click(
-        fn=analyze_resume,
-        inputs=[resume_upload, job_desc],
-        outputs=output
-    )
-
-demo.launch()
+]