app.py

import time
import numpy as np
import pandas as pd
import streamlit as st
from streamlit_option_menu import option_menu
from streamlit_extras.add_vertical_space import add_vertical_space
from PyPDF2 import PdfReader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.chat_models import ChatOpenAI
from langchain.chains.question_answering import load_qa_chain
from selenium import webdriver
from selenium.webdriver.common.by import By
import warnings
warnings.filterwarnings('ignore')


def streamlit_config():

    # page configuration
    st.set_page_config(page_title='Resume Analyzer AI', layout="wide")

    # page header transparent color
    page_background_color = """
    <style>

    [data-testid="stHeader"] 
    {
    background: rgba(0,0,0,0);
    }

    </style>
    """
    st.markdown(page_background_color, unsafe_allow_html=True)

    # title and position
    st.markdown(f'<h1 style="text-align: center;">AI-Powered Resume Analyzer and <br> LinkedIn Scraper with Selenium</h1>',
                unsafe_allow_html=True)


class resume_analyzer:

    def pdf_to_chunks(pdf):
        # read pdf and it returns memory address
        pdf_reader = PdfReader(pdf)

        # extrat text from each page separately
        text = ""
        for page in pdf_reader.pages:
            text += page.extract_text()

        # Split the long text into small chunks.
        text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=700,
            chunk_overlap=200,
            length_function=len)

        chunks = text_splitter.split_text(text=text)
        return chunks


    def resume_summary(query_with_chunks):
        query = f''' need to detailed summarization of below resume and finally conclude them

                    """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
                    {query_with_chunks}
                    """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
                    '''
        return query


    def resume_strength(query_with_chunks):
        query = f'''need to detailed analysis and explain of the strength of below resume and finally conclude them
                    """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
                    {query_with_chunks}
                    """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
                    '''
        return query


    def resume_weakness(query_with_chunks):
        query = f'''need to detailed analysis and explain of the weakness of below resume and how to improve make a better resume.

                    """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
                    {query_with_chunks}
                    """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
                    '''
        return query


    def job_title_suggestion(query_with_chunks):

        query = f''' what are the job roles i apply to likedin based on below?
                    
                    """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
                    {query_with_chunks}
                    """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
                    '''
        return query


    def openai(openai_api_key, chunks, analyze):

        # Using OpenAI service for embedding
        embeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)

        # Facebook AI Similarity Serach library help us to convert text data to numerical vector
        vectorstores = FAISS.from_texts(chunks, embedding=embeddings)

        # compares the query and chunks, enabling the selection of the top 'K' most similar chunks based on their similarity scores.
        docs = vectorstores.similarity_search(query=analyze, k=3)

        # creates an OpenAI object, using the ChatGPT 3.5 Turbo model
        llm = ChatOpenAI(model='gpt-3.5-turbo', api_key=openai_api_key)

        # question-answering (QA) pipeline, making use of the load_qa_chain function
        chain = load_qa_chain(llm=llm, chain_type='stuff')

        response = chain.run(input_documents=docs, question=analyze)
        return response


class linkedin_scrap:

    def linkedin_open_scrolldown(driver, user_job_title):

        b = []
        for i in user_job_title:
            x = i.split()
            y = '%20'.join(x)
            b.append(y)
        job_title = '%2C%20'.join(b)

        link = f"https://in.linkedin.com/jobs/search?keywords={job_title}&location=India&locationId=&geoId=102713980&f_TPR=r604800&position=1&pageNum=0"

        driver.get(link)
        driver.implicitly_wait(10)

        for i in range(0,3):
            driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
            time.sleep(5)
            try:
                x = driver.find_element(by=By.CSS_SELECTOR, value="button[aria-label='See more jobs']").click()
                time.sleep(3)
            except:
                pass


    def company_name(driver):

        company = driver.find_elements(by=By.CSS_SELECTOR, value='h4[class="base-search-card__subtitle"]')

        company_name = []

        for i in company:
            company_name.append(i.text)

        return company_name


    def company_location(driver):
        
        location = driver.find_elements(by=By.CSS_SELECTOR, value='span[class="job-search-card__location"]')

        company_location = []

        for i in location:
            company_location.append(i.text)
        
        return company_location
    

    def job_title(driver):
                
        title = driver.find_elements(by=By.CSS_SELECTOR, value='h3[class="base-search-card__title"]')

        job_title = []
        
        for i in title:
            job_title.append(i.text)
        
        return job_title


    def job_url(driver):

        url = driver.find_elements(by=By.XPATH, value='//a[contains(@href, "/jobs/")]')
        
        url_list = [i.get_attribute('href') for i in url]
        
        job_url = []
        
        for url in url_list:
                job_url.append(url)
        
        return job_url


    def job_title_filter(x, user_job_title):

        s = [i.lower() for i in user_job_title]
        suggestion = []
        for i in s:
            suggestion.extend(i.split())

        s = x.split()
        a = [i.lower() for i in s]

        intersection = list(set(suggestion).intersection(set(a)))
        return x if len(intersection) > 1 else np.nan


    def get_description(driver, link):

        driver.get(link)
        time.sleep(3)

        driver.find_element(by=By.CSS_SELECTOR, 
                            value='button[data-tracking-control-name="public_jobs_show-more-html-btn"]').click()
        time.sleep(2)

        description = driver.find_elements(by=By.CSS_SELECTOR, 
                                           value='div[class="show-more-less-html__markup relative overflow-hidden"]')
        driver.implicitly_wait(4)
        
        for j in description:
            return j.text


    def data_scrap(driver, user_job_title):

        # combine the all data to single dataframe
        df = pd.DataFrame(linkedin_scrap.company_name(driver), columns=['Company Name'])
        df['Job Title'] = pd.DataFrame(linkedin_scrap.job_title(driver))
        df['Location'] = pd.DataFrame(linkedin_scrap.company_location(driver))
        df['Website URL'] = pd.DataFrame(linkedin_scrap.job_url(driver))

        # job title filter based on user input
        df['Job Title'] = df['Job Title'].apply(lambda x: linkedin_scrap.job_title_filter(x, user_job_title))
        df = df.dropna()
        df.reset_index(drop=True, inplace=True)
        df = df.iloc[:10, :]

        # make a list after filter
        website_url = df['Website URL'].tolist()

        # add job description in df
        job_description = []

        for i in range(0, len(website_url)):
            link = website_url[i]
            data = linkedin_scrap.get_description(driver, link)
            if data is not None and len(data.strip()) > 0:
                job_description.append(data)
            else:
                job_description.append('Description Not Available')

        df['Job Description'] = pd.DataFrame(job_description, columns=['Description'])
        df = df.dropna()
        df.reset_index(drop=True, inplace=True)
        return df


    def main(user_job_title):

        driver = webdriver.Chrome()
        driver.maximize_window()

        linkedin_scrap.linkedin_open_scrolldown(driver, user_job_title)

        final_df = linkedin_scrap.data_scrap(driver, user_job_title)
        driver.quit()

        return final_df


streamlit_config()
add_vertical_space(1)


# sidebar
with st.sidebar:

    add_vertical_space(3)

    option = option_menu(menu_title='', options=['Summary', 'Strength', 'Weakness', 'Job Titles', 'Linkedin Jobs', 'Exit'],
                         icons=['house-fill', 'database-fill', 'pass-fill', 'list-ul', 'linkedin', 'sign-turn-right-fill'])


if option == 'Summary':

    # file upload
    pdf = st.file_uploader(label='', type='pdf')
    openai_api_key = st.text_input(label='OpenAI API Key', type='password')

    try:
        if pdf is not None and openai_api_key is not None:
            pdf_chunks = resume_analyzer.pdf_to_chunks(pdf)

            summary = resume_analyzer.resume_summary(query_with_chunks=pdf_chunks)
            result_summary = resume_analyzer.openai(openai_api_key=openai_api_key, chunks=pdf_chunks, analyze=summary)

            st.subheader('Summary:')
            st.write(result_summary)

    except Exception as e:
        col1, col2 = st.columns(2)
        with col1:
            st.warning(e)


elif option == 'Strength':

    # file upload
    pdf = st.file_uploader(label='', type='pdf')
    openai_api_key = st.text_input(label='OpenAI API Key', type='password')

    try:
        if pdf is not None and openai_api_key is not None:

            pdf_chunks = resume_analyzer.pdf_to_chunks(pdf)

            # Resume summary
            summary = resume_analyzer.resume_summary(query_with_chunks=pdf_chunks)
            result_summary = resume_analyzer.openai(openai_api_key=openai_api_key, chunks=pdf_chunks, analyze=summary)

            strength = resume_analyzer.resume_strength(query_with_chunks=result_summary)
            result_strength = resume_analyzer.openai(openai_api_key=openai_api_key, chunks=pdf_chunks, analyze=strength)

            st.subheader('Strength:')
            st.write(result_strength)

    except Exception as e:
        col1, col2 = st.columns(2)
        with col1:
            st.warning(e)


elif option == 'Weakness':

    # file upload
    pdf = st.file_uploader(label='', type='pdf')
    openai_api_key = st.text_input(label='OpenAI API Key', type='password')

    try:
        if pdf is not None and openai_api_key is not None:

            pdf_chunks = resume_analyzer.pdf_to_chunks(pdf)

            # Resume summary
            summary = resume_analyzer.resume_summary(query_with_chunks=pdf_chunks)
            result_summary = resume_analyzer.openai(openai_api_key=openai_api_key, chunks=pdf_chunks, analyze=summary)

            weakness = resume_analyzer.resume_weakness(query_with_chunks=result_summary)
            result_weakness = resume_analyzer.openai(openai_api_key=openai_api_key, chunks=pdf_chunks, analyze=weakness)

            st.subheader('Weakness:')
            st.write(result_weakness)

    except Exception as e:
        col1, col2 = st.columns(2)
        with col1:
            st.warning(e)


elif option == 'Job Titles':

    # file upload
    pdf = st.file_uploader(label='', type='pdf')
    openai_api_key = st.text_input(label='OpenAI API Key', type='password')

    try:
        if pdf is not None and openai_api_key is not None:
            pdf_chunks = resume_analyzer.pdf_to_chunks(pdf)

            # Resume summary
            summary = resume_analyzer.resume_summary(query_with_chunks=pdf_chunks)
            result_summary = resume_analyzer.openai(openai_api_key=openai_api_key, chunks=pdf_chunks, analyze=summary)

            job_suggestion = resume_analyzer.job_title_suggestion(query_with_chunks=result_summary)
            result_suggestion = resume_analyzer.openai(openai_api_key=openai_api_key, chunks=pdf_chunks, analyze=job_suggestion)

            st.subheader('Suggestion: ')
            st.write(result_suggestion)

    except Exception as e:
        col1, col2 = st.columns(2)
        with col1:
            st.warning(e)


elif option == 'Linkedin Jobs':

    try:        
        # get user input of job title
        user_input_job_title = st.text_input(label='Enter Job Titles (with comma separated):')
        submit = st.button('Submit')

        if submit and len(user_input_job_title) > 0:

            user_job_title = user_input_job_title.split(',')

            df = linkedin_scrap.main(user_job_title)

            l = len(df['Company Name'])
            for i in range(0, l):
                st.write(f"Company Name : {df.iloc[i,0]}")
                st.write(f"Job Title    : {df.iloc[i,1]}")
                st.write(f"Location     : {df.iloc[i,2]}")
                st.write(f"Website URL  : {df.iloc[i,3]}")
                with st.expander(label='Job Desription'):
                    st.write(df.iloc[i, 4])
                st.write('')
                st.write('')

        elif submit and len(user_input_job_title) == 0:
            col1, col2 = st.columns(2)
            with col1:
                st.info('Please Enter the Job Titles')

    except:
        st.write('')
        st.info("This feature is currently not working in the deployed Streamlit application due to a 'selenium.common.exceptions.WebDriverException' error.")
        st.write('')

        st.write(
            "Please use the local Streamlit application for a smooth experience: [http://localhost:8501](http://localhost:8501)")


elif option == 'Exit':

    add_vertical_space(3)
    col1, col2, col3 = st.columns([0.3,0.4,0.3])
    with col2:
        st.success('Thank you for your time. Exiting the application')
        st.balloons()