app.py

import streamlit as st
import groq
from jobspy import scrape_jobs
import pandas as pd
import json
from typing import List, Dict
import numpy as np
import time

def make_clickable(url: str) -> str:
    """
    Convert a URL to a clickable HTML link.
    
    Args:
        url (str): The URL to make clickable
    
    Returns:
        str: HTML anchor tag with the URL
    """
    return f'<a href="{url}" target="_blank" style="color: #4e79a7;">Link</a>'

def convert_prompt_to_parameters(client, prompt: str) -> Dict[str, str]:
    """
    Convert user input prompt to structured job search parameters using AI.
    
    Args:
        client: Groq AI client
        prompt (str): User's job search description
    
    Returns:
        Dict[str, str]: Extracted search parameters with search_term and location
    """
    system_prompt = """
    You are a language decoder. Extract:
    - search_term: job role/keywords (expand abbreviations)
    - location: mentioned place or 'USA'
    Return only: {"search_term": "term", "location": "location"}
    """
    
    response = client.chat.completions.create(
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": f"Extract from: {prompt}"}
        ],
        max_tokens=1024,
        model='llama3-8b-8192',
        temperature=0.2
    )
    
    try:
        return json.loads(response.choices[0].message.content)
    except json.JSONDecodeError:
        return {"search_term": prompt, "location": "USA"}

def analyze_resume(client, resume: str) -> str:
    """
    Generate a comprehensive resume analysis using AI.
    
    Args:
        client: Groq AI client
        resume (str): Full resume text
    
    Returns:
        str: Concise professional overview of the resume
    """
    system_prompt = """Analyze resume comprehensively in 150 words:
    1. Professional Profile Summary
    2. Key Technical Skills
    3. Educational Background
    4. Core Professional Experience Highlights
    5. Unique Strengths/Achievements
    Return a concise, structured professional overview."""
    
    response = client.chat.completions.create(
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": resume}
        ],
        max_tokens=400,
        model='llama3-8b-8192',
        temperature=0.3
    )
    
    return response.choices[0].message.content

@st.cache_data(ttl=3600)
def get_job_data(search_params: Dict[str, str]) -> pd.DataFrame:
    """
    Fetch job listings from multiple sources based on search parameters.
    
    Args:
        search_params (Dict[str, str]): Search parameters including term and location
    
    Returns:
        pd.DataFrame: Scraped job listings
    """
    try:
        return scrape_jobs(
            site_name=["indeed", "linkedin", "zip_recruiter"],
            search_term=search_params["search_term"],
            location=search_params["location"],
            results_wanted=60,
            hours_old=24,
            country_indeed='USA'
        )
    except Exception as e:
        st.warning(f"Error in job scraping: {str(e)}")
        return pd.DataFrame()

def analyze_job_batch(
    client, 
    resume: str, 
    jobs_batch: List[Dict], 
    start_index: int, 
    retry_count: int = 0
) -> pd.DataFrame:
    """
    Analyze a batch of jobs against the resume with retry logic.
    
    Args:
        client: Groq AI client
        resume (str): Resume text
        jobs_batch (List[Dict]): Batch of job listings
        start_index (int): Starting index of the batch
        retry_count (int, optional): Number of retry attempts. Defaults to 0.
    
    Returns:
        pd.DataFrame: Job match analysis results
    """
    if retry_count >= 3:
        return pd.DataFrame()
        
    system_prompt = """Rate resume-job matches. Return only JSON array:
[{"job_index": number, "match_score": 0-100, "reason": "brief reason"}]"""
    
    jobs_info = [
        {
            'index': idx + start_index,
            'title': job['title'],
            'desc': job.get('description', '')[:400],
        }
        for idx, job in enumerate(jobs_batch)
    ]
    
    resume_summary = analyze_resume(client, resume)
    
    analysis_prompt = f"Resume: {resume_summary}\nJobs: {json.dumps(jobs_info)}"
    
    try:
        response = client.chat.completions.create(
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": analysis_prompt}
            ],
            max_tokens=1024,
            model='llama3-70b-8192',
            temperature=0.3
        )
        
        matches = json.loads(response.choices[0].message.content)
        return pd.DataFrame(matches)
    except Exception as e:
        if retry_count < 3:
            time.sleep(2)
            return analyze_job_batch(client, resume, jobs_batch, start_index, retry_count + 1)
        st.warning(f"Batch {start_index} failed after retries: {str(e)}")
        return pd.DataFrame()

def analyze_jobs_in_batches(
    client, 
    resume: str, 
    jobs_df: pd.DataFrame, 
    batch_size: int = 3
) -> pd.DataFrame:
    """
    Process job listings in batches and analyze match with resume.
    
    Args:
        client: Groq AI client
        resume (str): Resume text
        jobs_df (pd.DataFrame): DataFrame of job listings
        batch_size (int, optional): Number of jobs to process in each batch. Defaults to 3.
    
    Returns:
        pd.DataFrame: Sorted job matches by match score
    """
    all_matches = []
    jobs_dict = jobs_df.to_dict('records')
    progress_bar = st.progress(0)
    status_text = st.empty()
    
    for i in range(0, len(jobs_dict), batch_size):
        batch = jobs_dict[i:i + batch_size]
        status_text.text(f"Processing batch {i//batch_size + 1} of {len(jobs_dict)//batch_size + 1}")
        
        batch_matches = analyze_job_batch(client, resume, batch, i)
        if not batch_matches.empty:
            all_matches.append(batch_matches)
            
        progress = min((i + batch_size) / len(jobs_dict), 1.0)
        progress_bar.progress(progress)
        time.sleep(1)  # Rate limiting
    
    progress_bar.empty()
    status_text.empty()
    
    if all_matches:
        final_matches = pd.concat(all_matches, ignore_index=True)
        return final_matches.sort_values('match_score', ascending=False)
    return pd.DataFrame()

def main():
    """
    Main Streamlit application entry point for Smart Job Search.
    Handles user interface, job search, and AI-powered job matching.
    """
    st.set_page_config(
        layout="wide",
        page_title="Multi Agent Job Search and Match",
        initial_sidebar_state="collapsed"
    )

    # Custom CSS with reduced text sizes
    st.markdown("""
        <style>
        .block-container {
            padding-top: 1.5rem;
            padding-bottom: 1.5rem;
            max-width: 1200px;
        }
        .stButton>button {
            background-color: #2563eb;
            color: white;
            border-radius: 0.375rem;
            padding: 0.75rem 1.5rem;
            border: none;
            box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
            margin: 0.5rem;
            min-width: 200px;
            font-size: 0.875rem;
        }
        [data-testid="stFileUploader"] {
            border: 2px dashed #e5e7eb;
            border-radius: 0.5rem;
            padding: 0.875rem;
            min-height: 220px;
            font-size: 0.875rem;
        }
        .stTextArea>div>div {
            border-radius: 0.5rem;
            min-height: 220px !important;
            font-size: 0.875rem;
        }
        .stTextInput>div>div>input {
            border-radius: 0.5rem;
            font-size: 0.875rem;
        }
        .resume-html {
            padding: 1.5rem;
            max-width: 800px;
            margin: 0 auto;
            background: white;
            box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
            border-radius: 0.5rem;
            font-size: 0.875rem;
        }
        h1 {font-size: 3rem !important;  /* Adjust this value to increase the font size */
        } h2 {font-size: 1.5rem !important;  /* Adjust this value to increase the font size */
        h3, h4, h5, h6 {
            font-size: 80% !important;
        }
        p, li {
            font-size: 0.875rem !important;
        }
        </style>
    """, unsafe_allow_html=True)

    # Header with smaller text
    st.markdown("""
        <h1 style='text-align: center; font-size: 2.5rem; font-weight: 800; margin-bottom: 0.875rem;'>
        🚀 Multi Agent Job Search and Match 
        </h1>
    """, unsafe_allow_html=True)

    col1, col2 = st.columns(2)
    
    with col1:
        user_input = st.text_area(
            "Describe the job you're looking for",
            placeholder="E.g., 'Senior Python developer with React experience in San Francisco'",
            height=150
        )
    
    with col2:
        user_resume = st.text_area(
            "Paste your resume here (for AI-powered matching)",
            placeholder="Paste your resume for AI-powered job matching",
            height=150
        )
        
    api_key = st.text_input(
        "Enter your Groq API key",
        type="password",
        help="Your API key will be used to process the job search query"
    )

   # Add this CSS styling right after st.set_page_config()
    

    if st.button("🔍 Search Jobs", disabled=not api_key):
        st.markdown("""
    <style>
    .stTabs [data-baseweb="tab-list"] {
        display: flex;
        justify-content: space-between;
        width: 100%;
    }
    .stTabs [data-baseweb="tab"] {
        flex: 1;
        text-align: center;
    }
    </style>
    """, unsafe_allow_html=True)

    # Modify tab creation to use descriptive names
        tab1, tab2, tab3 = st.tabs([
        "🔍 Job Listings", 
        "📄 Resume Summary", 
        "🤖 AI Job Matching"
    ])
        if user_input and api_key:
            try:
                client = groq.Client(api_key=api_key)
                
                with st.spinner("Processing search parameters..."):
                    processed_params = convert_prompt_to_parameters(client, user_input)
                
                with st.spinner("Searching for jobs..."):
                    jobs_data = get_job_data(processed_params)
                    
                    if not jobs_data.empty:
                        data = pd.DataFrame(jobs_data)
                        data = data[data['description'].notna()].reset_index(drop=True)
                        
                        with tab1:
                            st.success(f"Found {len(data)} jobs!")
                            display_df = data[['site', 'job_url', 'title', 'company', 'location', 'job_type', 'date_posted']]
                            display_df['job_url'] = display_df['job_url'].apply(make_clickable)
                            st.write(display_df.to_html(escape=False), unsafe_allow_html=True)
                        
                        if user_resume:
                            with tab2:
                                st.info("Analyzing resume summary...")
                                resume_summary = analyze_resume(client, user_resume)
                                st.success("Resume summary:")
                                st.write(resume_summary)
                            
                            with tab3:
                                st.info("Analyzing job matches in small batches...")
                                matches_df = analyze_jobs_in_batches(client, resume_summary, data, batch_size=3)
                                
                                if not matches_df.empty:
                                    matched_jobs = data.iloc[matches_df['job_index']].copy()
                                    matched_jobs['match_score'] = matches_df['match_score']
                                    matched_jobs['match_reason'] = matches_df['reason']
                                    
                                    st.success(f"Found {len(matched_jobs)} recommended matches!")
                                    display_cols = ['site', 'job_url', 'title', 'company', 'location', 'match_score', 'match_reason']
                                    display_df = matched_jobs[display_cols].sort_values('match_score', ascending=False)
                                    display_df['job_url'] = display_df['job_url'].apply(make_clickable)
                                    st.write(display_df.to_html(escape=False), unsafe_allow_html=True)
                                else:
                                    st.warning("Could not process job matches. Please try again.")
                    else:
                        st.warning("No jobs found with the given parameters.")
                        
            except Exception as e:
                st.error(f"Error: {str(e)}")
        elif not api_key:
            st.warning("Please enter your API key.")
        else:
            st.warning("Please enter a job description.")

if __name__ == "__main__":
    main()