app.py

# Imports
import requests
from bs4 import BeautifulSoup
import pandas as pd
from time import sleep
import random
from datetime import datetime
import json
import os
from pathlib import Path
import re
from docx import Document
import logging
from typing import List, Dict, Any
from openai import OpenAI
import tiktoken
from dotenv import load_dotenv
import streamlit as st

# OpenAI model
model = "gpt-4o-mini"

class LLMJobAssistant:
    def __init__(self):
        self.headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
        }
        self.jobs = []
        self.setup_logging()
        self.load_config()
        self.client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

        with open('templates/base_resume.txt', 'r') as f:
            self.resume_text = f.read()

    def analyze_job_posting(self, job_description: str) -> Dict[str, Any]:
        """Use LLM to analyze job posting and extract key information"""
        prompt = f""" \
        Analyze this job posting and extract key information: \
        {job_description} \ 
        
        Return a JSON object with:
        1. Required skills
        2. Required experience
        3. Estimated salary range
        4. Key responsibilities
        5. Match score (0-100) with this resume:
        {self.resume_text} \ 

        Also include a boolean 'should_apply' based on match score > 70% \
        """

        response = self.client.chat.completions.create(
            model=model,
            messages=[
                {"role": "user", "content": prompt}
            ],
            response_format={"type": "json_object"}
        )

        return json.loads(response.choices[0].message.content)
    
    def generate_custom_cover_letter(self, job_info: Dict[str, Any], company_name: str) -> str:
        """Generate a customized cover letter using an LLM"""
        prompt = f""" \ 
        Write a professional cover letter for a {job_info['title']} position at {company_name} \ 
        Use these details from my resume:

        {self.resume_text} \ 

        And these job requirements:
        {json.dumps(job_info['requirements'], indent=2)} \ 

        Focus on:
        1. Specific matching experiences
        2. Relevant projects and achievements
        3. Why I'm interested in this role and companhy
        4. My background in languages and AI/ML

        Tone should be professional but conversational.
        """

        response = self.client.chat.completions.create(
            model=model,
            messages= [
                {"role": "user", "content": prompt}
            ]
        )

        return response.choices[0].message.content
    
    def tailor_resume(self, job_info: Dict[str, Any]) -> str:
        """Use LLMs to suggest resume tailoring for a specific job"""
        prompt = f""" \ 
        Suggest specific modifications to this resume for a {job_info['title']} position. \ 

        Current resume:
        {self.resume_text} \ 

        Job requirements: \ 
        {json.dumps(job_info['requirements'], indent=2)} \ 

        Return specific suggestions for:
        1. Skills to emphasize
        2. Experiences to highlight
        3. Projects to feature
        4. Keywords to add
        """

        response = self.client.chat.completions.create(
            model=model,
            messages= [
                {"role": "user", "content": prompt}
            ]
        )

        return response.choices[0].message.content
    
    def scrape_job_description(self, url: str) -> str:
        """Scrape full job description from posting URL"""
        try:
            response = requests.get(url, headers=self.headers)
            soup = BeautifulSoup(response.text, "html.parser")

            # Detect job board from URL
            if 'linkedin.com' in url:
                description = soup.find('div', class_='description__text')
            elif 'indeed.com' in url:
                description = soup.find('div', id='jobDescriptionText')
            elif 'glassdoor.com' in url:
                description = soup.find('div', class_='jobDescriptionContent')
            else:
                # Default fallback - look for common job description containers
                description = (
                    soup.find('div', class_='job-description') or
                    soup.find('div', class_='job_description') or 
                    soup.find('div', {'class': lambda x: x and 'description' in x.lower()})
                )
            return description.text.strip() if description else ""
        except Exception as e:
            logging.error(f"Error scraping job description: {str(e)}")
            return ""
        
    def process_job_posting(self, job: Dict[str, Any]):
        """Process a single job posting with LLM analysis"""
        # Scrape full job description
        full_description = self.scrape_job_description(job['url'])

        if not full_description:
            return None
        
        # Analyze job posting
        analysis = self.analyze_job_posting(full_description)

        # If there is a good match, generate materials
        if analysis.get('should_apply', False):
            cover_letter = self.generate_custom_cover_letter(analysis, job['company'])
            resume_suggestions = self.tailor_resume(analysis)

            return {
                **job,
                'analysis': analysis,
                'cover_letter': cover_letter,
                'resume_suggestions': resume_suggestions,
                'full_description': full_description
            }
        
        return None
    
    def run_enhanced_job_search(self):
        """Run job search with LLM enhancements"""
        # First run basic job search
        jobs_df = self.run_job_search()

        # Process each job with the LLM
        enhanced_jobs = []
        for _, job in jobs_df.iterrows():
            processed_job = self.process_job_posting(job.to_dict())
            if processed_job:
                enhanced_jobs.append(processed_job)
            sleep(random.uniform(1, 2)) # Rate limiting

        # Convert to DataFrame
        enhanced_df = pd.DataFrame(enhanced_jobs)

        # Save detailed results
        enhanced_df.to_pickle('enhanced_jobs.pkl') # Save full data

        return enhanced_df
    
    def generate_application_strategy(self, job_data: Dict[str, Any]) -> str:
        """Generate application strategy using an LLM"""
        prompt = f""" \ 
        Create an application strategy for this job:

        Job Title: {job_data['title']} \ 
        Company: {job_data['company']} \ 
        Match Score: {job_data['analysis']['match_score']} \ 

        Include:
        1. Best approach for application (direct, referral, etc.)
        2. Key points to emphasize in interview
        3. Potential questions to ask
        4. Company research suggestions
        5. Follow-up strategy
        """

        response = self.client.chat.completions.create(
            model=model,
            messages = [
                {"role": "user", "content": prompt}
            ]
        )

        return response.choices[0].message.content
    
    
    
def main():
    # Load environment variables
    os.environ['PATH'] += f':{os.path.expanduser("~/.cargo/bin")}'
    load_dotenv()

    # Initialize assistant
    assistant = LLMJobAssistant()

    st.title("LLM-Enhanced Job Application Assistant")
    st.spinner("Running enhanced job search...")
    jobs_df = assistant.run_enhanced_job_search()

    st.write("Job Search Summary:")
    st.write(f"Total matching jobs found: {len(jobs_df)}")
    st.write("Top matching positions:")
    top_matches = jobs_df.nlargest(5, 'analysis.match_score')
    for _, job in top_matches.iterrows():
        st.write(f"\n{job['title']} at {job['company']}")
        st.write(f"Match Score: {job['analysis']['match_score']}")
        st.write(f"Estimated Salary: {job['analysis']['estimated_salary_range']}")

    # Generate application strategies for top matches
    st.write("Generating application strategies for top matches...")
    for _, job in top_matches.iterrows():
        strategy = assistant.generate_application_strategy(job.to_dict())

        # Save strategy to file
        filename = f"strategies/{job['company']}_{job['title']}.txt".replace(' ', '_')
        os.makedirs('strategies', exist_ok=True)
        with open(filename, 'w') as f:
            f.write(strategy)

    st.dataframe(jobs_df)

if __name__ == 'main':
    main()