Update app.py

app.py

@@ -1,204 +1,157 @@
-# app.py
-
 import os
-import io
 import json
-from datetime import datetime
-
-import streamlit as st
 import requests
+import streamlit as st
+from datetime import datetime
 from docx import Document
 from PyPDF2 import PdfReader
 
 # ------------------------------------------------------------------------------
-# Groq API Setup
+# 🚀 CONFIGURATION - API & SETTINGS
 # ------------------------------------------------------------------------------
-
-# Your Groq API key is expected to be saved as a secret in the environment
 GROQ_API_KEY = os.getenv("GROQ_API")
-# Replace the following endpoint with the actual Groq API endpoint if different.
-GROQ_ENDPOINT = "https://api.groq.ai/v1/generate"
+GROQ_ENDPOINT = "https://api.groq.com/openai/v1/chat/completions"
+GROQ_MODEL = "llama-3.3-70b-versatile"
 
-def generate_text(prompt: str, max_length: int = 1024) -> str:
-    """
-    Call the Groq API with a prompt and return the generated text.
-    """
+# ------------------------------------------------------------------------------
+# 🔥 ADVANCED API CALL FUNCTION
+# ------------------------------------------------------------------------------
+def call_groq_api(messages, temperature=0.7):
+    """Handles API calls to Groq for chat-based completions with robust error handling."""
     headers = {
         "Authorization": f"Bearer {GROQ_API_KEY}",
         "Content-Type": "application/json"
     }
     payload = {
-        "prompt": prompt,
-        "max_length": max_length
+        "model": GROQ_MODEL,
+        "messages": messages,
+        "temperature": temperature,
+        "max_tokens": 1024
     }
-    response = requests.post(GROQ_ENDPOINT, headers=headers, json=payload)
-    if response.ok:
-        # Adjust according to the actual API response structure.
-        return response.json().get("generated_text", "").strip()
-    else:
-        st.error(f"Error in Groq API call: {response.text}")
-        return ""
+    try:
+        response = requests.post(GROQ_ENDPOINT, headers=headers, json=payload, timeout=15)
+        response.raise_for_status()
+        return response.json()["choices"][0]["message"]["content"].strip()
+    except requests.exceptions.RequestException as e:
+        st.error(f"❌ API Request Failed: {e}")
+        return None
 
 # ------------------------------------------------------------------------------
-# Helper Functions for File Reading
+# 📄 FILE PROCESSING (PDF / DOCX)
 # ------------------------------------------------------------------------------
-
-def read_docx(file_bytes: bytes) -> str:
-    """Extract text from a DOCX file."""
-    document = Document(io.BytesIO(file_bytes))
-    return "\n".join([para.text for para in document.paragraphs])
-
-def read_pdf(file_bytes: bytes) -> str:
-    """Extract text from a PDF file."""
-    reader = PdfReader(io.BytesIO(file_bytes))
-    text = []
-    for page in reader.pages:
-        extracted = page.extract_text()
-        if extracted:
-            text.append(extracted)
-    return "\n".join(text)
-
-def read_plain(file_bytes: bytes) -> str:
-    """Extract text from a plain text file."""
-    return file_bytes.decode("utf-8", errors="ignore")
-
-def extract_resume_text(file_obj) -> str:
-    """
-    Determine file type and extract text accordingly.
-    Supports PDF, DOCX, and plain text.
-    """
+def extract_resume_text(file_obj):
+    """Extracts text from PDF or DOCX resumes."""
     file_bytes = file_obj.read()
-    file_obj.seek(0)  # Reset pointer for further use if needed
-    filename = file_obj.name if hasattr(file_obj, "name") else "resume.txt"
-    ext = os.path.splitext(filename)[-1].lower()
+    file_obj.seek(0)
+    ext = os.path.splitext(file_obj.name)[-1].lower()
 
     if ext == ".pdf":
-        return read_pdf(file_bytes)
+        return "\n".join(page.extract_text() for page in PdfReader(file_bytes).pages if page.extract_text())
     elif ext in [".docx", ".doc"]:
-        return read_docx(file_bytes)
+        return "\n".join([para.text for para in Document(file_bytes).paragraphs])
     else:
-        return read_plain(file_bytes)
+        return file_bytes.decode("utf-8", errors="ignore")
 
 # ------------------------------------------------------------------------------
-# Core AI Functions Using Groq API
+# 🎯 AI-Powered Resume Parsing
 # ------------------------------------------------------------------------------
+def parse_resume(resume_text):
+    """Extracts structured JSON resume details using Groq's Llama 3.3 model."""
+    messages = [
+        {"role": "system", "content": "You are a resume parsing expert. Extract structured data."},
+        {"role": "user", "content": f"Extract structured data from this resume:\n{resume_text}\n\nOutput as JSON."}
+    ]
+    return call_groq_api(messages, temperature=0.4)
 
-def parse_resume(resume_text: str) -> str:
-    """
-    Extract candidate details from the resume text.
-    The prompt instructs the model to output a JSON with keys:
-    first_name, last_name, location, work_experience, school_experience, and skills.
-    """
-    prompt = (
-        "You are an expert resume parser. Extract the following keys from the resume text: "
-        "first_name, last_name, location, work_experience, school_experience, and skills. "
-        "Return the answer strictly in JSON format with no extra text.\n\n"
-        f"Resume:\n{resume_text}"
-    )
-    return generate_text(prompt, max_length=512)
-
-def generate_cover_letter(candidate_json: str, job_description: str, date_str: str) -> str:
-    """
-    Generate a cover letter using the candidate's JSON profile, the job description,
-    and the current date.
-    """
-    prompt = (
-        "You are a seasoned career advisor and professional cover letter writer. "
-        "Using the candidate information provided in JSON format, craft a persuasive and personalized cover letter "
-        "tailored to the job description. Structure your answer with an introduction, body, and closing, "
-        "and include the date {date}.\n\n"
-        "Candidate JSON:\n{candidate_json}\n\n"
-        "Job Description:\n{job_description}\n\n"
-        "Cover Letter:".format(
-            candidate_json=candidate_json, job_description=job_description, date=date_str
-        )
-    )
-    return generate_text(prompt, max_length=1024)
-
-def generate_resume(first_name: str, last_name: str, location: str,
-                    work_experience: str, school_experience: str, skills: str) -> str:
-    """
-    Generate a professional resume using candidate information provided in a form.
-    """
-    candidate_info = {
+# ------------------------------------------------------------------------------
+# ✍️ AI-Powered Cover Letter Generator
+# ------------------------------------------------------------------------------
+def generate_cover_letter(candidate_json, job_description):
+    """Generates a professional cover letter using structured candidate data."""
+    date_str = datetime.today().strftime("%d - %b - %Y")
+    messages = [
+        {"role": "system", "content": "You are a top-tier career advisor. Write persuasive cover letters."},
+        {"role": "user", "content": f"""
+        Generate a professional cover letter using:
+        - Candidate Profile: {candidate_json}
+        - Job Description: {job_description}
+        - Date: {date_str}
+        
+        The cover letter should be engaging, personalized, and formatted professionally.
+        """}
+    ]
+    return call_groq_api(messages, temperature=0.5)
+
+# ------------------------------------------------------------------------------
+# 📜 AI-Powered Resume Creator
+# ------------------------------------------------------------------------------
+def generate_resume(first_name, last_name, location, work_experience, school_experience, skills):
+    """Generates a well-formatted professional resume."""
+    candidate_data = json.dumps({
         "first_name": first_name,
         "last_name": last_name,
         "location": location,
         "work_experience": work_experience,
         "school_experience": school_experience,
-        "skills": skills,
-    }
-    candidate_str = json.dumps(candidate_info, indent=2)
-    
-    prompt = (
-        "You are a professional resume writer. Using the candidate information provided in JSON, "
-        "create a compelling, well-organized resume in plain text format. Include clear sections for "
-        "personal details, work experience, education, and skills. Ensure the resume is concise and professional.\n\n"
-        "Candidate Information:\n" + candidate_str + "\n\nResume:"
-    )
-    return generate_text(prompt, max_length=1024)
+        "skills": skills
+    }, indent=2)
+
+    messages = [
+        {"role": "system", "content": "You are a professional resume writer."},
+        {"role": "user", "content": f"""
+        Create a structured, ATS-friendly resume using:
+        {candidate_data}
+
+        Ensure:
+        - Clear sections (Personal Info, Experience, Education, Skills)
+        - Professional formatting
+        - A compelling summary if possible.
+        """}
+    ]
+    return call_groq_api(messages, temperature=0.5)
 
 # ------------------------------------------------------------------------------
-# Streamlit UI
+# 🎨 STREAMLIT UI DESIGN
 # ------------------------------------------------------------------------------
+st.set_page_config(page_title="AI-Powered Job Assistant", layout="wide")
+st.title("🚀 AI-Powered Resume & Cover Letter Generator")
+st.markdown("#### Generate a **Resume** or a **Cover Letter** using **Llama 3.3-70B** powered by **Groq AI**.")
 
-st.set_page_config(page_title="AI-Powered Job Application Assistant", layout="wide")
-st.title("AI-Powered Job Application Assistant")
-st.markdown("Generate a **Cover Letter** from your resume or **Create a Resume** from scratch using AI via Groq API.")
+tabs = st.tabs(["📄 Cover Letter Generator", "📑 Resume Creator"])
 
-# Create tabs for the two functionalities
-tabs = st.tabs(["Cover Letter Generator", "Resume Creator"])
-
-# ----- Tab 1: Cover Letter Generator -----
+# ----- COVER LETTER GENERATOR -----
 with tabs[0]:
-    st.header("Cover Letter Generator")
-    st.markdown("Upload your resume (PDF, DOCX, or TXT) and paste the job description below.")
-    
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        resume_file = st.file_uploader("Upload Your Resume", type=["pdf", "docx", "doc", "txt"])
-    
-    with col2:
-        job_description = st.text_area("Job Description", height=200, placeholder="Paste the job description here...")
-    
-    if st.button("Generate Cover Letter"):
-        if resume_file is None or not job_description.strip():
-            st.error("Please upload a resume and enter a job description.")
-        else:
-            with st.spinner("Processing resume..."):
+    st.header("📄 Cover Letter Generator")
+    resume_file = st.file_uploader("Upload Your Resume", type=["pdf", "docx", "txt"])
+    job_description = st.text_area("Paste Job Description", height=200)
+
+    if st.button("🔹 Generate Cover Letter"):
+        if resume_file and job_description.strip():
+            with st.spinner("✨ Processing resume..."):
                 resume_text = extract_resume_text(resume_file)
                 candidate_json = parse_resume(resume_text)
-                current_date = datetime.today().strftime("%d - %b - %Y")
-                cover_letter = generate_cover_letter(candidate_json, job_description, current_date)
-            
-            st.subheader("Extracted Candidate Profile (JSON)")
-            st.code(candidate_json, language="json")
-            
-            st.subheader("Generated Cover Letter")
-            st.text_area("", cover_letter, height=300)
-
-# ----- Tab 2: Resume Creator -----
+                cover_letter = generate_cover_letter(candidate_json, job_description)
+            st.success("✅ Cover Letter Generated!")
+            st.text_area("📜 Your Cover Letter:", cover_letter, height=300)
+        else:
+            st.warning("⚠️ Please upload a resume and paste the job description.")
+
+# ----- RESUME CREATOR -----
 with tabs[1]:
-    st.header("Resume Creator")
-    st.markdown("Fill in your details below to generate a professional resume from scratch.")
-    
+    st.header("📑 Resume Creator")
+
     with st.form("resume_form"):
         col1, col2 = st.columns(2)
-        with col1:
-            first_name = st.text_input("First Name", placeholder="John")
-        with col2:
-            last_name = st.text_input("Last Name", placeholder="Doe")
-        
-        location = st.text_input("Location", placeholder="City, State, Country")
-        work_experience = st.text_area("Work Experience", height=150, placeholder="List your past roles and achievements...")
-        school_experience = st.text_area("Education", height=150, placeholder="List your academic qualifications...")
-        skills = st.text_area("Skills", height=100, placeholder="List your key skills...")
-        
-        submit = st.form_submit_button("Generate Resume")
-    
+        first_name = col1.text_input("First Name")
+        last_name = col2.text_input("Last Name")
+        location = st.text_input("Location")
+        work_experience = st.text_area("Work Experience", height=150)
+        school_experience = st.text_area("Education", height=150)
+        skills = st.text_area("Skills", height=100)
+        submit = st.form_submit_button("📑 Generate Resume")
+
     if submit:
-        with st.spinner("Generating resume..."):
+        with st.spinner("📝 Creating Resume..."):
             resume_text = generate_resume(first_name, last_name, location, work_experience, school_experience, skills)
-        st.subheader("Generated Resume")
-        st.text_area("", resume_text, height=400)
+        st.success("✅ Resume Generated!")
+        st.text_area("📜 Your Resume:", resume_text, height=400)