Update app.py

app.py

@@ -5,143 +5,81 @@ import docx
 import requests
 import json
 
-# Function to extract text from PDF (unchanged)
+# Text extraction functions (unchanged)
 def extract_text_from_pdf(file):
     pdf_reader = PyPDF2.PdfReader(file)
-    text = ""
-    for page in pdf_reader.pages:
-        text += page.extract_text()
-    return text
+    return " ".join(page.extract_text() for page in pdf_reader.pages)
 
-# Function to extract text from Word document (unchanged)
 def extract_text_from_docx(file):
     doc = docx.Document(file)
-    text = "\n".join([para.text for para in doc.paragraphs])
-    return text
+    return "\n".join(para.text for para in doc.paragraphs)
 
-# Function to process uploaded file (only added case-insensitive check)
 def process_uploaded_file(file):
-    filename = file.name.lower()  # Case-insensitive check
-    if filename.endswith(".pdf"):
+    if file.name.lower().endswith(".pdf"):
         return extract_text_from_pdf(file)
-    elif filename.endswith(".docx"):
+    elif file.name.lower().endswith(".docx"):
         return extract_text_from_docx(file)
-    else:
-        raise ValueError("Unsupported file format. Please upload a PDF or Word document.")
+    raise ValueError("Unsupported file format")
 
-# Function to call Together API (unchanged except for timeout)
-
-  
-def analyze_with_huggingface(resume_text, job_description):
-    HF_API_KEY = os.getenv("HUGGINGFACE_API_KEY")
-    API_URL = "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.3"
-    
-    # Truncate inputs to stay within token limits
-    resume_text = resume_text[:3000]  # Limit resume to 3000 chars
-    job_description = job_description[:1000]  # Limit JD to 1000 chars
-    
-    prompt = f"""<s>[INST] <<SYS>>
-You are an AI expert in ATS resume analysis. Return ONLY valid JSON matching this schema:
-{{
-  "ATS Parameters": {{
-    "Keywords": {{"Match": <int>, "Recommendation": [<str>]}},
-    "Formatting": {{"Match": <int>, "Recommendation": [<str>]}},
-    "Skills Match": {{"Match": <int>, "Recommendation": [<str>]}},
-    "Experience Relevance": {{"Match": <int>, "Recommendation": [<str>]}},
-    "Education": {{"Match": <int>, "Recommendation": [<str>]}}
-  }},
-  "Score": {{
-    "Keywords": <int>,
-    "Formatting": <int>,
-    "Skills Match": <int>,
-    "Experience Relevance": <int>,
-    "Education": <int>,
-    "Overall": <int>
-  }}
-}}
-<</SYS>>
-
-Analyze this resume against the job description for ATS compatibility:
-Resume: {resume_text}
-Job Description: {job_description}
-Return ONLY the JSON output with no additional text or explanations.[/INST]"""
-    
-    headers = {
-        "Authorization": f"Bearer {HF_API_KEY}",
-        "Content-Type": "application/json",
-    }
-    
-    payload = {
-        "inputs": prompt,
-        "parameters": {
-            "max_new_tokens": 800,
-            "temperature": 0.7,
-            "do_sample": True,
-            "return_full_text": False
-        }
-    }
-    
+# Updated Hugging Face API function
+def analyze_with_huggingface(file, job_description):
     try:
-        response = requests.post(API_URL, headers=headers, json=payload, timeout=30)
-        response.raise_for_status()
-        
-        # Extract JSON from response
-        result = response.json()
-        if isinstance(result, list):
-            content = result[0].get("generated_text", "{}")
-        else:
-            content = result.get("generated_text", "{}")
-        
-        # Clean the output (sometimes models add extra text)
-        json_start = content.find('{')
-        json_end = content.rfind('}') + 1
-        json_str = content[json_start:json_end]
-        
-        parsed = json.loads(json_str)
-        if not all(k in parsed for k in ["ATS Parameters", "Score"]):
-            raise ValueError("Invalid JSON structure")
-            
-        return parsed
+        resume_text = process_uploaded_file(file)
+        HF_API_KEY = os.getenv("HUGGINGFACE_API_KEY")
+        API_URL = "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.3"
         
-    except Exception as e:
-        return {"error": f"Hugging Face API error: {str(e)}"}
+        prompt = """<s>[INST] <<SYS>>
+You are an ATS resume analyzer. Return ONLY this JSON format:
+{
+  "ATS Parameters": {
+    "Keywords": {"Match": 0-100, "Recommendation": []},
+    "Formatting": {"Match": 0-100, "Recommendation": []},
+    "Skills": {"Match": 0-100, "Recommendation": []},
+    "Experience": {"Match": 0-100, "Recommendation": []},
+    "Education": {"Match": 0-100, "Recommendation": []}
+  },
+  "Score": {
+    "Overall": 0-100,
+    "Details": {"Keywords": 0-100, "Formatting": 0-100, "Skills": 0-100, "Experience": 0-100, "Education": 0-100}
+  }
+}
+<</SYS>>
 
-# Main function (only added JSON validation)
-def analyze_resume(file, job_description):
-    try:
-        resume_text = process_uploaded_file(file)
-        result = analyze_with_mistral(resume_text, job_description)
+Resume: {resume}
+Job Description: {jd}
+[/INST]""".format(resume=resume_text[:3000], jd=job_description[:1000])
+
+        response = requests.post(
+            API_URL,
+            headers={"Authorization": f"Bearer {HF_API_KEY}"},
+            json={
+                "inputs": prompt,
+                "parameters": {"max_new_tokens": 800, "temperature": 0.7}
+            },
+            timeout=30
+        )
         
-        # Ensure the output matches your original format
-        if isinstance(result, dict) and "error" in result:
-            return json.dumps(result, indent=2)
-        return result
+        # Extract JSON from response
+        result = response.json()[0]['generated_text']
+        json_str = result[result.find('{'):result.rfind('}')+1]
+        return json.loads(json_str)
         
     except Exception as e:
-        return json.dumps({"error": str(e)}, indent=2)
+        return {"error": str(e)}
 
-# Gradio interface (only changed file component type)
-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.")
-    
+# Gradio Interface
+with gr.Blocks() as demo:
+    gr.Markdown("## Resume Analyzer")
     with gr.Row():
-        with gr.Column(scale=1):
-            resume_upload = gr.File(
-                label="Upload Resume (PDF or Word)", 
-                file_types=[".pdf", ".docx"],
-                type="filepath"  # Only this line changed
-            )
-            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")
+        file_input = gr.File(label="Upload Resume", file_types=[".pdf", ".docx"])
+        jd_input = gr.Textbox(label="Job Description", lines=10)
+    analyze_btn = gr.Button("Analyze")
+    output = gr.JSON()
     
-    submit_btn.click(
-        fn=analyze_resume,
-        inputs=[resume_upload, job_desc],
+    analyze_btn.click(
+        fn=analyze_with_huggingface,
+        inputs=[file_input, jd_input],
         outputs=output
     )
 
-demo.launch()
+demo.queue().launch(allowed_paths=["*"])