Upload app.py

app.py

@@ -60,7 +60,29 @@ class resume_analyzer:
         return chunks
 
 
-    def resume_summary(query_with_chunks):
+    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
+
+
+    def summary_prompt(query_with_chunks):
+
         query = f''' need to detailed summarization of below resume and finally conclude them
 
                     """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
@@ -70,7 +92,51 @@ class resume_analyzer:
         return query
 
 
-    def resume_strength(query_with_chunks):
+    def resume_summary():
+
+        with st.form(key='Summary'):
+
+            # User Upload the Resume
+            add_vertical_space(1)
+            pdf = st.file_uploader(label='Upload Your Resume', type='pdf')
+            add_vertical_space(1)
+
+            # Enter OpenAI API Key
+            col1,col2 = st.columns([0.6,0.4])
+            with col1:
+                openai_api_key = st.text_input(label='Enter OpenAI API Key', type='password')
+            add_vertical_space(2)
+
+            # Click on Submit Button
+            submit = st.form_submit_button(label='Submit')
+            add_vertical_space(1)
+        
+        add_vertical_space(3)
+        if submit:
+            if pdf is not None and openai_api_key != '':
+                try:
+                    with st.spinner('Processing...'):
+
+                        pdf_chunks = resume_analyzer.pdf_to_chunks(pdf)
+
+                        summary_prompt = resume_analyzer.summary_prompt(query_with_chunks=pdf_chunks)
+
+                        summary = resume_analyzer.openai(openai_api_key=openai_api_key, chunks=pdf_chunks, analyze=summary_prompt)
+
+                    st.markdown(f'<h4 style="color: orange;">Summary:</h4>', unsafe_allow_html=True)
+                    st.write(summary)
+
+                except Exception as e:
+                    st.markdown(f'<h5 style="text-align: center;color: orange;">{e}</h5>', unsafe_allow_html=True)
+
+            elif pdf is None:
+                st.markdown(f'<h5 style="text-align: center;color: orange;">Please Upload Your Resume</h5>', unsafe_allow_html=True)
+            
+            elif openai_api_key == '':
+                st.markdown(f'<h5 style="text-align: center;color: orange;">Please Enter OpenAI API Key</h5>', unsafe_allow_html=True)
+
+
+    def strength_prompt(query_with_chunks):
         query = f'''need to detailed analysis and explain of the strength of below resume and finally conclude them
                     """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
                     {query_with_chunks}
@@ -79,7 +145,55 @@ class resume_analyzer:
         return query
 
 
-    def resume_weakness(query_with_chunks):
+    def resume_strength():
+
+        with st.form(key='Strength'):
+
+            # User Upload the Resume
+            add_vertical_space(1)
+            pdf = st.file_uploader(label='Upload Your Resume', type='pdf')
+            add_vertical_space(1)
+
+            # Enter OpenAI API Key
+            col1,col2 = st.columns([0.6,0.4])
+            with col1:
+                openai_api_key = st.text_input(label='Enter OpenAI API Key', type='password')
+            add_vertical_space(2)
+
+            # Click on Submit Button
+            submit = st.form_submit_button(label='Submit')
+            add_vertical_space(1)
+
+        add_vertical_space(3)
+        if submit:
+            if pdf is not None and openai_api_key != '':
+                try:
+                    with st.spinner('Processing...'):
+                    
+                        pdf_chunks = resume_analyzer.pdf_to_chunks(pdf)
+
+                        summary_prompt = resume_analyzer.summary_prompt(query_with_chunks=pdf_chunks)
+
+                        summary = resume_analyzer.openai(openai_api_key=openai_api_key, chunks=pdf_chunks, analyze=summary_prompt)
+                        
+                        strength_prompt = resume_analyzer.strength_prompt(query_with_chunks=summary)
+
+                        strength = resume_analyzer.openai(openai_api_key=openai_api_key, chunks=pdf_chunks, analyze=strength_prompt)
+
+                    st.markdown(f'<h4 style="color: orange;">Strength:</h4>', unsafe_allow_html=True)
+                    st.write(strength)
+
+                except Exception as e:
+                    st.markdown(f'<h5 style="text-align: center;color: orange;">{e}</h5>', unsafe_allow_html=True)
+
+            elif pdf is None:
+                st.markdown(f'<h5 style="text-align: center;color: orange;">Please Upload Your Resume</h5>', unsafe_allow_html=True)
+            
+            elif openai_api_key == '':
+                st.markdown(f'<h5 style="text-align: center;color: orange;">Please Enter OpenAI API Key</h5>', unsafe_allow_html=True)
+
+
+    def weakness_prompt(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.
 
                     """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
@@ -89,7 +203,55 @@ class resume_analyzer:
         return query
 
 
-    def job_title_suggestion(query_with_chunks):
+    def resume_weakness():
+
+        with st.form(key='Weakness'):
+
+            # User Upload the Resume
+            add_vertical_space(1)
+            pdf = st.file_uploader(label='Upload Your Resume', type='pdf')
+            add_vertical_space(1)
+
+            # Enter OpenAI API Key
+            col1,col2 = st.columns([0.6,0.4])
+            with col1:
+                openai_api_key = st.text_input(label='Enter OpenAI API Key', type='password')
+            add_vertical_space(2)
+
+            # Click on Submit Button
+            submit = st.form_submit_button(label='Submit')
+            add_vertical_space(1)
+        
+        add_vertical_space(3)
+        if submit:
+            if pdf is not None and openai_api_key != '':
+                try:
+                    with st.spinner('Processing...'):
+                    
+                        pdf_chunks = resume_analyzer.pdf_to_chunks(pdf)
+
+                        summary_prompt = resume_analyzer.summary_prompt(query_with_chunks=pdf_chunks)
+
+                        summary = resume_analyzer.openai(openai_api_key=openai_api_key, chunks=pdf_chunks, analyze=summary_prompt)
+
+                        weakness_prompt = resume_analyzer.weakness_prompt(query_with_chunks=summary)
+
+                        weakness = resume_analyzer.openai(openai_api_key=openai_api_key, chunks=pdf_chunks, analyze=weakness_prompt)
+
+                    st.markdown(f'<h4 style="color: orange;">Weakness and Suggestions:</h4>', unsafe_allow_html=True)
+                    st.write(weakness)
+
+                except Exception as e:
+                    st.markdown(f'<h5 style="text-align: center;color: orange;">{e}</h5>', unsafe_allow_html=True)
+
+            elif pdf is None:
+                st.markdown(f'<h5 style="text-align: center;color: orange;">Please Upload Your Resume</h5>', unsafe_allow_html=True)
+            
+            elif openai_api_key == '':
+                st.markdown(f'<h5 style="text-align: center;color: orange;">Please Enter OpenAI API Key</h5>', unsafe_allow_html=True)
+
+
+    def job_title_prompt(query_with_chunks):
 
         query = f''' what are the job roles i apply to likedin based on below?
                     
@@ -100,25 +262,53 @@ class resume_analyzer:
         return query
 
 
-    def openai(openai_api_key, chunks, analyze):
+    def job_title_suggestion():
 
-        # Using OpenAI service for embedding
-        embeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)
+        with st.form(key='Job Titles'):
 
-        # Facebook AI Similarity Serach library help us to convert text data to numerical vector
-        vectorstores = FAISS.from_texts(chunks, embedding=embeddings)
+            # User Upload the Resume
+            add_vertical_space(1)
+            pdf = st.file_uploader(label='Upload Your Resume', type='pdf')
+            add_vertical_space(1)
 
-        # 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)
+            # Enter OpenAI API Key
+            col1,col2 = st.columns([0.6,0.4])
+            with col1:
+                openai_api_key = st.text_input(label='Enter OpenAI API Key', type='password')
+            add_vertical_space(2)
 
-        # creates an OpenAI object, using the ChatGPT 3.5 Turbo model
-        llm = ChatOpenAI(model='gpt-3.5-turbo', api_key=openai_api_key)
+            # Click on Submit Button
+            submit = st.form_submit_button(label='Submit')
+            add_vertical_space(1)
 
-        # question-answering (QA) pipeline, making use of the load_qa_chain function
-        chain = load_qa_chain(llm=llm, chain_type='stuff')
+        add_vertical_space(3)
+        if submit:
+            if pdf is not None and openai_api_key != '':
+                try:
+                    with st.spinner('Processing...'):
+                    
+                        pdf_chunks = resume_analyzer.pdf_to_chunks(pdf)
+
+                        summary_prompt = resume_analyzer.summary_prompt(query_with_chunks=pdf_chunks)
+
+                        summary = resume_analyzer.openai(openai_api_key=openai_api_key, chunks=pdf_chunks, analyze=summary_prompt)
+
+                        job_title_prompt = resume_analyzer.job_title_prompt(query_with_chunks=summary)
+
+                        job_title = resume_analyzer.openai(openai_api_key=openai_api_key, chunks=pdf_chunks, analyze=job_title_prompt)
+
+                    st.markdown(f'<h4 style="color: orange;">Job Titles:</h4>', unsafe_allow_html=True)
+                    st.write(job_title)
+
+                except Exception as e:
+                    st.markdown(f'<h5 style="text-align: center;color: orange;">{e}</h5>', unsafe_allow_html=True)
+
+            elif pdf is None:
+                st.markdown(f'<h5 style="text-align: center;color: orange;">Please Upload Your Resume</h5>', unsafe_allow_html=True)
+            
+            elif openai_api_key == '':
+                st.markdown(f'<h5 style="text-align: center;color: orange;">Please Enter OpenAI API Key</h5>', unsafe_allow_html=True)
 
-        response = chain.run(input_documents=docs, question=analyze)
-        return response
 
 
 class linkedin_scraper:
@@ -141,11 +331,13 @@ class linkedin_scraper:
         with st.form(key='linkedin_scarp'):
 
             add_vertical_space(1)
-            col1,col2 = st.columns([0.7,0.3], gap='medium')
+            col1,col2,col3 = st.columns([0.5,0.3,0.2], gap='medium')
             with col1:
-                job_title = st.text_input(label='Job Title')
-                job_title = job_title.split()
+                job_title_input = st.text_input(label='Job Title')
+                job_title_input = job_title_input.split()
             with col2:
+                job_location = st.text_input(label='Job Location', value='India')
+            with col3:
                 job_count = st.number_input(label='Job Count', min_value=1, value=1, step=1)
 
             # Submit Button
@@ -153,10 +345,10 @@ class linkedin_scraper:
             submit = st.form_submit_button(label='Submit')
             add_vertical_space(1)
         
-        return job_title, job_count, submit
+        return job_title_input, job_location, job_count, submit
 
 
-    def build_url(job_title):
+    def build_url(job_title, job_location):
 
         b = []
         for i in job_title:
@@ -165,7 +357,7 @@ class linkedin_scraper:
             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"
+        link = f"https://in.linkedin.com/jobs/search?keywords={job_title}&location={job_location}&locationId=&geoId=102713980&f_TPR=r604800&position=1&pageNum=0"
 
         return link
     
@@ -203,10 +395,14 @@ class linkedin_scraper:
         matched_words = list(set(user_input).intersection(set(scrap_title)))
 
         # Return Job Title if there are more than 1 matched word else return NaN
-        return scrap_job_title if len(matched_words) > 1 else np.nan
+        if len(user_input) > 1:
+            return scrap_job_title if len(matched_words) > 1 else np.nan
+        
+        else:
+            return scrap_job_title if len(matched_words) == 1 else np.nan
 
 
-    def scrap_company_data(driver, job_title_input):
+    def scrap_company_data(driver, job_title_input, job_location):
 
         # scraping the Company Data
         company = driver.find_elements(by=By.CSS_SELECTOR, value='h4[class="base-search-card__subtitle"]')
@@ -230,6 +426,9 @@ class linkedin_scraper:
         # Return Job Title if there are more than 1 matched word else return NaN
         df['Job Title'] = df['Job Title'].apply(lambda x: linkedin_scraper.job_title_filter(x, job_title_input))
 
+        # Return Location if User Job Location in Scraped Location else return NaN
+        df['Location'] = df['Location'].apply(lambda x: x if job_location.lower() in x.lower() else np.nan)
+
         # Drop Null Values and Reset Index
         df = df.dropna()
         df.reset_index(drop=True, inplace=True)
@@ -305,30 +504,32 @@ class linkedin_scraper:
     def main():
         
         # Initially set driver to None
-        # driver = None
+        driver = None
         
-        # try:
-            job_title_input, job_count, submit = linkedin_scraper.get_userinput()
+        try:
+            job_title_input, job_location, job_count, submit = linkedin_scraper.get_userinput()
             add_vertical_space(2)
-
+            
             if submit:
-                if job_title_input != '':
+                if job_title_input != [] and job_location != '':
                     
-                    with st.spinner('Webdriver Setup Initializing...'):
+                    with st.spinner('Chrome Webdriver Setup Initializing...'):
                         driver = linkedin_scraper.webdriver_setup()
                                        
-                    with st.spinner('Build URL and Open Link...'):
+                    with st.spinner('Loading More Job Listings...'):
 
                         # build URL based on User Job Title Input
-                        link = linkedin_scraper.build_url(job_title_input)
+                        link = linkedin_scraper.build_url(job_title_input, job_location)
 
                         # Open the Link in LinkedIn and Scroll Down the Page
                         linkedin_scraper.link_open_scrolldown(driver, link, job_count)
 
-                    with st.spinner('scraping Company Data...'):
-                        df = linkedin_scraper.scrap_company_data(driver, job_title_input)
-                    
-                    with st.spinner('Scraping Job Description Data...'):
+                    with st.spinner('scraping Job Details...'):
+
+                        # Scraping the Company Name, Location, Job Title and URL Data
+                        df = linkedin_scraper.scrap_company_data(driver, job_title_input, job_location)
+
+                        # Scraping the Job Descriptin Data
                         df_final = linkedin_scraper. scrap_job_description(driver, df, job_count)
                     
                     # Display the Data in User Interface
@@ -336,26 +537,30 @@ class linkedin_scraper:
 
                 
                 # If User Click Submit Button and Job Title is Empty
-                elif job_title_input == '':
+                elif job_title_input == []:
                     st.markdown(f'<h5 style="text-align: center;color: orange;">Job Title is Empty</h5>', 
                                 unsafe_allow_html=True)
+                
+                elif job_location == '':
+                    st.markdown(f'<h5 style="text-align: center;color: orange;">Job Location is Empty</h5>', 
+                                unsafe_allow_html=True)
 
-        # except Exception as e:
-        #     add_vertical_space(2)
-        #     st.markdown(f'<h5 style="text-align: center;color: orange;">{e}</h5>', unsafe_allow_html=True)
+        except Exception as e:
+            add_vertical_space(2)
+            st.markdown(f'<h5 style="text-align: center;color: orange;">{e}</h5>', unsafe_allow_html=True)
         
-        # finally:
-        #     if driver:
-        #         driver.quit()
+        finally:
+            if driver:
+                driver.quit()
 
 
 
 # Streamlit Configuration Setup
 streamlit_config()
-add_vertical_space(1)
+add_vertical_space(5)
+
 
 
-# sidebar
 with st.sidebar:
 
     add_vertical_space(3)
@@ -364,113 +569,39 @@ with st.sidebar:
                          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)
+if option == '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)
+    resume_analyzer.resume_summary()
 
-            st.subheader('Summary:')
-            st.write(result_summary)
-
-    except Exception as e:
-        add_vertical_space(2)
-        st.markdown(f'<h5 style="text-align: center;color: orange;">{e}</h5>', unsafe_allow_html=True)
 
 
 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)
+    resume_analyzer.resume_strength()
 
-            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:
-        add_vertical_space(2)
-        st.markdown(f'<h5 style="text-align: center;color: orange;">{e}</h5>', unsafe_allow_html=True)
 
 
 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_analyzer.resume_weakness()
 
-            # 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:
-        add_vertical_space(2)
-        st.markdown(f'<h5 style="text-align: center;color: orange;">{e}</h5>', unsafe_allow_html=True)
 
 
 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')
+    resume_analyzer.job_title_suggestion()
 
-    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:
-        add_vertical_space(2)
-        st.markdown(f'<h5 style="text-align: center;color: orange;">{e}</h5>', unsafe_allow_html=True)
 
 
 elif option == 'Linkedin Jobs':
-
-    add_vertical_space(2)
+    
     linkedin_scraper.main()
 
 
+
 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')