Spaces:
Sleeping
Sleeping
| import os | |
| import openai | |
| import PyPDF2 | |
| import gradio as gr | |
| import docx | |
| import re | |
| class Resume_Overall: | |
| def __init__(self): | |
| pass | |
| def extract_text_from_file(self,file_path): | |
| # Get the file extension | |
| file_extension = os.path.splitext(file_path)[1] | |
| if file_extension == '.pdf': | |
| with open(file_path, 'rb') as file: | |
| # Create a PDF file reader object | |
| reader = PyPDF2.PdfFileReader(file) | |
| # Create an empty string to hold the extracted text | |
| extracted_text = "" | |
| # Loop through each page in the PDF and extract the text | |
| for page_number in range(reader.getNumPages()): | |
| page = reader.getPage(page_number) | |
| extracted_text += page.extractText() | |
| return extracted_text | |
| elif file_extension == '.txt': | |
| with open(file_path, 'r') as file: | |
| # Just read the entire contents of the text file | |
| return file.read() | |
| elif file_extension == '.docx': | |
| doc = docx.Document(file_path) | |
| text = [] | |
| for paragraph in doc.paragraphs: | |
| text.append(paragraph.text) | |
| return '\n'.join(text) | |
| else: | |
| return "Unsupported file type" | |
| def course_response(self,resume_path): | |
| resume_path = resume_path.name | |
| resume = self.extract_text_from_file(resume_path) | |
| # Define the prompt or input for the model | |
| prompt = f"""Analyze the resume to generate online courses with website links to improve skills following resume delimitted by triple backticks. Generate atmost five courses. | |
| result format should be: | |
| course:[course]. | |
| website link:[website link] | |
| ```{resume}``` | |
| """ | |
| # Generate a response from the GPT-3 model | |
| response = openai.Completion.create( | |
| engine='text-davinci-003', | |
| prompt=prompt, | |
| max_tokens=200, | |
| temperature=0, | |
| n=1, | |
| stop=None, | |
| ) | |
| # Extract the generated text from the API response | |
| generated_text = response.choices[0].text.strip() | |
| return generated_text | |
| def summary_response(self,resume_path): | |
| resume_path = resume_path.name | |
| resume = self.extract_text_from_file(resume_path) | |
| # Define the prompt or input for the model | |
| prompt = f"""Analyze the resume to write the summary for following resume delimitted by triple backticks. | |
| ```{resume}``` | |
| """ | |
| # Generate a response from the GPT-3 model | |
| response = openai.Completion.create( | |
| engine='text-davinci-003', | |
| prompt=prompt, | |
| max_tokens=200, | |
| temperature=0, | |
| n=1, | |
| stop=None, | |
| ) | |
| # Extract the generated text from the API response | |
| generated_text = response.choices[0].text.strip() | |
| return generated_text | |
| def skill_response(self,job_description_path): | |
| job_description_path = job_description_path.name | |
| resume = self.extract_text_from_file(job_description_path) | |
| # Define the prompt or input for the model | |
| prompt = f"""Find Education Gaps in given resume. Find Skills in resume. | |
| ```{resume}``` | |
| """ | |
| # Generate a response from the GPT-3 model | |
| response = openai.Completion.create( | |
| engine='text-davinci-003', # Choose the GPT-3 engine you want to use | |
| prompt=prompt, | |
| max_tokens=100, # Set the maximum number of tokens in the generated response | |
| temperature=0, # Controls the randomness of the output. Higher values = more random, lower values = more focused | |
| n=1, # Generate a single response | |
| stop=None, # Specify an optional stop sequence to limit the length of the response | |
| ) | |
| # Extract the generated text from the API response | |
| generated_text = response.choices[0].text.strip() | |
| return generated_text | |
| def _generate_job_list(self, resume: str) -> str: | |
| prompt = f"List out perfect job roles for based on resume informations:{resume}" | |
| response = openai.Completion.create( | |
| engine='text-davinci-003', | |
| prompt=prompt, | |
| max_tokens=100, | |
| temperature=0, | |
| n=1, | |
| stop=None, | |
| ) | |
| generated_text = response.choices[0].text.strip() | |
| return generated_text | |
| def job_list_interface(self, file) -> str: | |
| resume_text = self.extract_text_from_file(file.name) | |
| job_list = self._generate_job_list(resume_text) | |
| return job_list | |
| def generate_job_description(self, role, experience): | |
| # Generate a response from the GPT-3 model | |
| prompt = f"""Your task is generate Job description for this {role} with {experience} years of experience. | |
| Job Description Must have | |
| 1. Job Title | |
| 2. Job Summary : [200 words] | |
| 3. Responsibilities : Five Responsibilities in five lines | |
| 4. Required Skills : Six Skills | |
| 5. Qualifications | |
| These topics must have in that Generated Job Description. | |
| """ | |
| response = openai.Completion.create( | |
| engine='text-davinci-003', # Choose the GPT-3 engine you want to use | |
| prompt=prompt, | |
| max_tokens=500, # Set the maximum number of tokens in the generated response | |
| temperature=0.5, # Controls the randomness of the output. Higher values = more random, lower values = more focused | |
| ) | |
| # Extract the generated text from the API response | |
| generated_text = response.choices[0].text.strip() | |
| return generated_text | |
| def response(self,job_description_path): | |
| job_description_path = job_description_path.name | |
| job_description = self.extract_text_from_file(job_description_path) | |
| # Define the prompt or input for the model | |
| prompt = f"""Generate interview questions for screening following job_description delimitted by triple backticks. Generate atmost ten questions. | |
| ```{job_description}``` | |
| """ | |
| # Generate a response from the GPT-3 model | |
| response = openai.Completion.create( | |
| engine='text-davinci-003', # Choose the GPT-3 engine you want to use | |
| prompt=prompt, | |
| max_tokens=200, # Set the maximum number of tokens in the generated response | |
| temperature=0, # Controls the randomness of the output. Higher values = more random, lower values = more focused | |
| n=1, # Generate a single response | |
| stop=None, # Specify an optional stop sequence to limit the length of the response | |
| ) | |
| # Extract the generated text from the API response | |
| generated_text = response.choices[0].text.strip() | |
| return generated_text | |
| def show_file(self,file_path): | |
| return file_path.name | |
| def launch_gradio_interface(self, share: bool = True): | |
| with gr.Blocks(css="style.css",theme='karthikeyan-adople/hudsonhayes-gray') as app: | |
| with gr.Tab("Resume"): | |
| with gr.Row(): | |
| with gr.Column(elem_id="col-container",scale=0.80): | |
| gr.HTML("""<center><h1>Resume</h1></center>""") | |
| file_output = gr.File(elem_classes="filenameshow") | |
| with gr.Column(elem_id="col-container",scale=0.20): | |
| upload_button = gr.UploadButton( | |
| "Browse File",file_types=[".txt", ".pdf", ".doc", ".docx",".json",".csv"], | |
| elem_classes="uploadbutton") | |
| with gr.TabItem("Designation"): | |
| with gr.Column(elem_id = "col-container",scale=0.80): | |
| btn = gr.Button(value="Submit") | |
| output_text = gr.Textbox(label="Designation List") | |
| with gr.TabItem("Summarized"): | |
| with gr.Column(elem_id = "col-container",scale=0.80): | |
| analyse = gr.Button("Analyze") | |
| summary_result = gr.Textbox(label="Summarized",lines=8) | |
| with gr.TabItem("Skills and Education Gaps"): | |
| with gr.Column(elem_id = "col-container",scale=0.80): | |
| analyse_resume = gr.Button("Analyze Resume") | |
| result = gr.Textbox(label="Skills and Education Gaps",lines=8) | |
| with gr.TabItem("Course"): | |
| with gr.Column(elem_id = "col-container",scale=0.80): | |
| course_analyse = gr.Button("Find Courses") | |
| course_result = gr.Textbox(label="Suggested Cources",lines=8) | |
| upload_button.upload(self.show_file,upload_button,file_output) | |
| course_analyse.click(self.course_response, [upload_button], course_result) | |
| analyse_resume.click(self.skill_response, [upload_button], result) | |
| btn.click(self.job_list_interface, upload_button, output_text) | |
| analyse.click(self.summary_response, [upload_button], summary_result) | |
| with gr.Tab("Job Description"): | |
| with gr.Row(): | |
| with gr.Column(elem_id="col-container"): | |
| gr.HTML("""<center><h1>Resume</h1></center>""") | |
| file_output1 = gr.File(elem_classes="filenameshow") | |
| upload_button1 = gr.UploadButton( | |
| "Browse File",file_types=[".txt", ".pdf", ".doc", ".docx",".json",".csv"], | |
| elem_classes="uploadbutton") | |
| with gr.TabItem("Screening Question"): | |
| with gr.Row(): | |
| jd_btn = gr.Button(value="Submit") | |
| with gr.Row(): | |
| output_text1 = gr.Textbox(label="Screening Question") | |
| with gr.TabItem("Screening Question"): | |
| with gr.Row(): | |
| with gr.Column(): | |
| rolls = gr.Textbox(label="Role") | |
| with gr.Column(): | |
| experience = gr.Textbox(label="Experience") | |
| with gr.Row(): | |
| get_jd_btn = gr.Button("Generate JD") | |
| with gr.Row(): | |
| result_jd = gr.Textbox(label="Job Description",lines=8) | |
| get_jd_btn.click(self.generate_job_description, [rolls,experience], result_jd) | |
| upload_button1.upload(self.show_file,upload_button1,file_output1) | |
| jd_btn.click(self.response,[upload_button1], output_text1) | |
| app.launch(debug=True) | |
| if __name__ == "__main__": | |
| resume_overall = Resume_Overall() | |
| resume_overall.launch_gradio_interface() |