Upload 10 files

Dockerfile

@@ -0,0 +1,32 @@
+# Use Python 3.8 image as the base image
+FROM python:3.8-buster
+
+# Install the necessary dependencies
+RUN apt-get update && apt-get install -y wget
+
+# Download the wkhtmltopdf package
+RUN wget https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6-1/wkhtmltox_0.12.6-1.buster_amd64.deb
+
+# Install the package
+RUN apt-get install -y --no-install-recommends ./wkhtmltox_0.12.6-1.buster_amd64.deb
+
+# Copy the requirements.txt file
+COPY requirements.txt /app/
+
+# Change the working directory
+WORKDIR /app/
+
+# Install the Python dependencies
+RUN pip install -r requirements.txt
+
+# Copy the rest of the app files
+COPY src/ /app/src/
+COPY app.py /app/
+
+
+# Expose port 7860
+EXPOSE 7860
+
+# Set the command to run when the container starts
+CMD ["python3", "-m" ,"streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0", "--server.enableXsrfProtection=false"]
+

app.py

@@ -0,0 +1,277 @@
+import re
+
+import pdfkit
+import streamlit as st
+
+from src.chatbot.chatgpt import Chatgpt
+from src.utils import parse_pdf, build_html_resume
+
+section_examples = {'summary': 'I have passion for new tech',
+                    'workExperience': 'Tell about my ability to lead projects',
+                    'education': 'Describe my degree type in more details'}
+
+openai_key_info = 'https://platform.openai.com/account/api-keys'
+
+
+def list_section(section_name, section_data):
+    description_key = 'description'
+
+    item_keys = list(section_data[0].keys())
+    item_keys.remove(description_key)
+    for item_id, section_item in enumerate(section_data):
+        cols = st.columns(len(item_keys))
+        for col, key in zip(cols, item_keys):
+            col.text_input(key, section_item[key], key=f'{section_name}_{item_id}_{key}')
+        st.text_area(description_key, section_item[description_key], key=f'{section_name}_{item_id}_{description_key}')
+
+        recruiter_subsection(section_name, section_example=section_examples[section_name], item_id=item_id)
+        st.markdown('***')
+
+
+def skills_section(section_name, skills_data):
+    num_columns = 3
+    for skills_row in range(0, len(skills_data), num_columns):
+        cols = st.columns([3, 1] * num_columns)
+        skills_row_names = skills_data[skills_row: skills_row + num_columns]
+        for item_id, skill in enumerate(skills_row_names):
+            skill_id = skills_row + item_id
+            cols[item_id * 2].text_input(' ', value=skill, key=f'{section_name}_{skill_id}', label_visibility='hidden')
+            cols[item_id * 2 + 1].markdown('## ')
+            if cols[item_id * 2 + 1].button('x', key=f'{section_name}_{skill_id}_remove_skill'):
+                _remove_skill(skill_id, skills_data)
+
+    skill_subsection(section_name)
+    st.markdown('***')
+
+
+def _remove_skill(skill_id, skills_data):
+    del skills_data[skill_id]
+    st.experimental_rerun()
+
+
+def skill_subsection(section_name, item_id=0):
+    key = f'{section_name}_{item_id}_add_skill'
+    cols = st.columns([12, 1])
+    new_skill = cols[0].text_input("Add skill", key=key)
+    cols[1].markdown('##')
+    clicked = cols[1].button("\+")
+    if clicked and new_skill:
+        st.write(new_skill)
+        st.session_state['resume_data'][section_name].append(new_skill)
+        st.write(st.session_state['resume_data'][section_name])
+        st.experimental_rerun()
+
+
+def recruiter_subsection(section_name, section_example, item_id=0):
+    with st.container():
+        cols = st.columns([3, 10], gap='small')
+        cols[0].write('\n')
+        cols[0].write('\n')
+        button_clicked = cols[0].button("Auto Section Improve", key=f'{section_name}_{item_id}_improve_auto')
+        trigger_key = 'Add a special request'
+        user_request_template = f"{trigger_key} to the bot here... e.g. {section_example}."
+
+        user_request = cols[1].text_input("section_example", value=user_request_template,
+                                          key=f'{section_name}_{item_id}_improve_manual', label_visibility='hidden')
+        if button_clicked:
+            user_request = '' if trigger_key in user_request else user_request
+            section_key = get_item_key(section_name, item_id)
+            section_text = st.session_state[section_key]
+            new_section_text = st.session_state['chatbot'].improve_section(section_text, user_request)
+
+            update_resume_data(new_section_text, section_name, item_id)
+            st.experimental_rerun()
+
+
+def get_item_key(section_name, item_id=0):
+    section_key = ''
+    if section_name in ['workExperience', 'education']:
+        key = 'description'
+        section_key = f'{section_name}_{item_id}_{key}'
+    elif section_name == 'summary':
+        section_key = f'{section_name}'
+    return section_key
+
+
+def update_resume_data(text_input, section_name, item_id=0):
+    if section_name in ['workExperience', 'education']:
+        key = 'description'
+        st.session_state['resume_data'][section_name][item_id][key] = text_input
+    elif section_name == 'summary':
+        section_key = f'{section_name}'
+        st.session_state['resume_data'][section_key] = text_input
+
+
+def summary_section(section_name, summary_data):
+    st.text_area(section_name, summary_data, key=f'{section_name}', label_visibility='hidden')
+    recruiter_subsection(section_name, section_examples[section_name])
+
+
+def contact_info_section(section_name, info_data):
+    for key, value in info_data.items():
+        if value:
+            st.text_input(key.title(), value, key=f'{section_name}_{key}')
+    st.markdown('***')
+
+
+def header():
+    st.text_input('name', st.session_state.resume_data['name'], key="name")
+    st.text_input('title', st.session_state.resume_data['title'], key="title")
+
+
+def body():
+    section_dict = {'contactInfo': contact_info_section, 'summary': summary_section, 'workExperience': list_section,
+                    'education': list_section, 'skills': skills_section}
+    tabs_names = [key_to_tab_name(key) for key in section_dict.keys()]
+    tabs = st.tabs(tabs_names)
+    for tab, key in zip(tabs, section_dict):
+        section_func = section_dict[key]
+        with tab:
+            section_func(key, st.session_state['resume_data'][key])
+
+
+def key_to_tab_name(input_string):
+    return re.sub(r'([A-Z])', r' \1', input_string).strip().title()
+
+
+def sidebar():
+    with st.sidebar:
+        uploaded_file = st.file_uploader('Upload PDF Resume', type="PDF")
+        if uploaded_file and _is_new_file(uploaded_file) and is_chatbot_loaded():
+            _init_resume(uploaded_file)
+
+        if is_data_loaded() and is_chatbot_loaded():
+            st.button("Improve More", on_click=_improve_more)
+            st.download_button('Download PDF', file_name='out.pdf', mime="application/json", data=download_pdf())
+
+
+def download_pdf():
+    resume_data = format_resume_data()
+    html_resume = build_html_resume(resume_data)
+    options = {'page-size': 'A4', 'margin-top': '0.75in', 'margin-right': '0.75in', 'margin-bottom': '0.75in',
+               'margin-left': '0.75in', 'encoding': "UTF-8", 'no-outline': None}
+    return pdfkit.from_string(html_resume, options=options, css='src/css/main.css')
+
+
+def _improve_more():
+    print("Improving resume")
+    st.session_state['resume_data'] = st.session_state['chatbot'].improve_resume(st.session_state['resume_data'])
+
+
+def _init_chatbot():
+    cols = st.columns([6, 1, 1])
+    api_key = cols[0].text_input("Enter OpenAI API key")
+    cols[1].markdown("#")
+    api_submit = cols[1].button("Submit")
+
+    cols[2].markdown("#")
+    get_info = cols[2].button("Get key")
+    if get_info:
+        st.info(f"Get your key at: {openai_key_info}")
+    if api_submit:
+        if Chatgpt.validate_api(api_key):
+            st.session_state['chatbot'] = Chatgpt(api_key)
+            st.experimental_rerun()
+
+        else:
+            st.error("Not valid API key - try again...")
+
+
+def is_chatbot_loaded():
+    return st.session_state.get('chatbot')
+
+
+def _is_new_file(uploaded_file):
+    return uploaded_file.id != st.session_state.get('file_id', '')
+
+
+def _init_resume(uploaded_file):
+    resume_data = parse_pdf(uploaded_file)
+    st.session_state['resume_data'] = st.session_state['chatbot'].improve_resume(resume_data)
+    st.session_state['file_id'] = uploaded_file.id
+    st.experimental_rerun()
+
+
+def format_resume_data():
+    current_state = st.session_state
+    resume_data = {}
+    contact_info = {}
+    work_experience = []
+    education = []
+    skills = []
+
+    resume_data['name'] = current_state.get('name', '')
+    resume_data['title'] = current_state.get('title', '')
+
+    contact_info_keys = ['linkedin', 'github', 'email', 'address']
+    for key in contact_info_keys:
+        contact_info[key] = current_state.get(f'contactInfo_{key}', '')
+    resume_data['contactInfo'] = contact_info
+
+    resume_data['summary'] = current_state.get('summary', '')
+
+    work_experience_keys = ['workExperience_{}_title', 'workExperience_{}_company', 'workExperience_{}_dates',
+                            'workExperience_{}_description']
+    education_keys = ['education_{}_degree', 'education_{}_school', 'education_{}_dates', 'education_{}_description']
+
+    total_work_experience = count_entries(st.session_state, 'workExperience')
+    total_education = count_entries(st.session_state, 'education')
+
+    for i in range(total_work_experience):
+        work_experience.append(
+            {key.split('_')[2]: current_state.get(key.format(i), '') for key in work_experience_keys})
+
+    for i in range(total_education):
+        education.append({key.split('_')[2]: current_state.get(key.format(i), '') for key in education_keys})
+
+    resume_data['workExperience'] = work_experience
+    resume_data['education'] = education
+
+    total_skills = count_entries(st.session_state, 'skills')
+
+    for i in range(total_skills):
+        skill_key = f'skills_{i}'
+
+        skills.append(current_state.get(skill_key, ''))
+    resume_data['skills'] = skills
+
+    return resume_data
+
+
+def count_entries(input_dict, entry_type):
+    max_index = max([int(key.split("_")[1]) for key in input_dict.keys() if key.startswith(f"{entry_type}_")],
+                    default=0)
+    return max_index + 1
+
+
+def title():
+    st.title("ChatCV - AI Resume Builder")
+
+
+def upload_resume_header():
+    st.success("Upload PDF Resume - Let the magic begin...")
+
+
+def is_data_loaded():
+    return st.session_state.get('resume_data')
+
+
+def _main():
+    title()
+    if is_chatbot_loaded():
+        sidebar()
+
+        if is_data_loaded():
+            header()
+            body()
+
+        else:
+            upload_resume_header()
+    else:
+        _init_chatbot()
+
+
+if __name__ == '__main__':
+    _main()
+
+    # bootstrap 4 collapse example

requirements.txt

@@ -0,0 +1,5 @@
+revChatGPT==1.1.3
+pypdf2==3.0.1
+Jinja2==3.1.2
+pdfkit==1.0.0
+streamlit==1.15.2

src/__init__.py

@@ -0,0 +1,5 @@
+# from .dependency_downloader import download_spacy_model, download_nltk_corpus
+#
+# download_spacy_model('en_core_web_sm')
+# download_nltk_corpus('words')
+# download_nltk_corpus('stopwords')

src/chatbot/chatgpt.py

@@ -0,0 +1,126 @@
+import ast
+import json
+import re
+from pathlib import Path
+from typing import Dict
+import logging
+
+import requests
+from revChatGPT.Official import Chatbot
+
+from .prompts import get_prompt, data_format
+
+logging.basicConfig(filename='chatgpt.log', level=logging.INFO, format='%(asctime)s %(message)s',
+                    datefmt='%m/%d/%Y %I:%M:%S %p')
+
+
+class Chatgpt:
+    def __init__(self, api_key):
+        self.validate_api(api_key)
+        self.chatbot = Chatbot(api_key)
+        logging.info("API key loaded successfully")
+
+    @staticmethod
+    def validate_api(api_key):
+        if api_key and api_key.startswith("sk-") and len(api_key) > 50:
+            response = requests.get("https://api.openai.com/v1/engines", headers={"Authorization": f"Bearer {api_key}"})
+            return response.status_code == 200
+        return False
+
+    @staticmethod
+    def load_api_key(config_path):
+        """
+        Load api key from config.json
+
+        Returns:
+            Str: session token
+        """
+        config_file = Path(config_path)
+        if not config_file.is_file():
+            raise FileNotFoundError(f"config.json not found at {config_file.resolve()}")
+
+        with open(config_file, 'r') as j_file:
+            session_token = json.load(j_file)
+        return session_token['api_key']
+
+    def improve_resume(self, parsed_resume: str) -> Dict:
+        logging.info("Improving parsed resume")
+        chatgpt_input = get_prompt(parsed_resume, user_request='', output_type='all')
+        response = self._ask(chatgpt_input)
+        new_resume_data = self.parse_json_from_string(response)
+        logging.info("Resume improved successfully")
+        return new_resume_data
+
+    def improve_section(self, section_text, user_request=''):
+        logging.info("Improving section")
+        chatgpt_input = get_prompt(section_text, user_request=user_request, output_type='section')
+        response = self._ask(chatgpt_input)
+        new_section_text = self.clean_section_response(response)
+        logging.info("Section improved successfully")
+        return new_section_text
+
+    def _ask(self, chatgpt_input):
+        logging.info("Asking chatbot for response")
+        response = self.chatbot.ask(chatgpt_input)
+        answer = response['choices'][0]['text']
+        logging.info("Received response from chatbot")
+        logging.info(f"Response: {answer}")
+
+        return answer
+
+    def parse_json_from_string(self, json_string):
+
+        try:
+            return ast.literal_eval(json_string)
+        except Exception:
+            logging.error("Error in parsing JSON string")
+
+        json_string = re.sub('\s+', ' ', json_string)
+        json_string = re.sub('"', "'", json_string)
+        json_string = re.sub(r"(\w)'(\w)", r"\1\'\2", json_string)
+
+        clean_dict = dict()
+        for key, value in data_format.items():
+            pattern = ''
+            if isinstance(value, str):
+                pattern = f"'{key}':" + "\s*'(.*?)'"
+            elif isinstance(value, list):
+                pattern = f"'{key}':\s*(\[[^\[\]]*?\])"
+            elif isinstance(value, dict):
+                pattern = f"'{key}':" + "\s*(\{[^{}]*?\})"
+
+            extracted_value = self.extract_value(pattern, json_string)
+
+            if extracted_value:
+                try:
+                    extracted_value = ast.literal_eval(extracted_value)
+                except Exception:
+                    pass
+
+            if not isinstance(extracted_value, type(value)):
+                extracted_value = data_format[key]
+            clean_dict[key] = extracted_value
+
+        return clean_dict
+
+    def extract_value(self, pattern, string):
+        match = re.search(pattern, string)
+
+        if match:
+            return match.group(1)
+        else:
+            return ''
+
+    def clean_section_response(self, input_string):
+        try:
+            start = input_string.index('"')
+            end = input_string.rindex('"') + 1
+            input_string = input_string[start:end]
+        except ValueError:
+            pass
+        input_string = self.remove_prefix(input_string)
+        return input_string
+
+    @staticmethod
+    def remove_prefix(input_string):
+        return re.sub(r'\w+:\n', '', input_string)

src/chatbot/prompts.py

@@ -0,0 +1,32 @@
+prompt_placeholder = '[$$$]'
+
+data_format = {'name': '', 'title': '',
+               'contactInfo': {'linkedin': '', 'github': '', 'email': '', 'address': '', 'phone': ''}, 'summary': '',
+               'workExperience': [{'title': '', 'company': '', 'dates': '', 'description': ''},
+                                  {'title': '', 'company': '', 'dates': '', 'description': ''}, ],
+               'education': [{'degree': '', 'school': '', 'dates': '', 'description': ''}, ], 'skills': ['', '', '']}
+
+recruiter_prompt = 'You are a recruiter and a professional resume builder.'
+command_prompt = 'Re-write the input as professionally as possible, adding vital, valuable information and skills.'
+user_request_prompt = f'{prompt_placeholder}'
+
+output_commands_prompts = dict()
+output_commands_prompts[
+    'all'] = f'Return the output as dictionary in the next format {str(data_format)}. Return only the keys: {str(list(data_format))}.'
+output_commands_prompts['section'] = f'Return the output as string.'
+
+input_prompt = f'Input: {prompt_placeholder}'
+
+
+def get_prompt(input_data, user_request='', output_type='all'):
+    input_data = str(input_data)
+    valid_output_types = list(output_commands_prompts)
+    assert str(output_type) in valid_output_types, f"Not valid output type, try {valid_output_types}"
+
+    if user_request:
+        user_request += '\n'
+
+    template = '\n'.join(
+        [recruiter_prompt, command_prompt, user_request_prompt.replace(prompt_placeholder, user_request),
+         input_prompt.replace(prompt_placeholder, input_data), output_commands_prompts[output_type], command_prompt])
+    return template

src/css/main.css

@@ -0,0 +1,185 @@
+
+
+
+
+@page {
+  size: A4 portrait;
+
+}
+@media print {
+  header, footer {
+    display: none;
+  }
+}
+*, *:before, *:after {
+  -moz-box-sizing: border-box; -webkit-box-sizing: border-box; box-sizing: border-box;
+ }
+
+html
+{
+
+	font-size:100%;
+}
+
+
+body
+{
+    top: 0px;
+	-webkit-font-smoothing:antialiased;
+	font-family:Lora, serif;
+	font-size:18px;
+	font-weight:500;
+	line-height:1.4;
+	text-rendering:optimizeLegibility;
+}
+
+.parent
+{
+}
+
+.skill-set li:hover
+{
+	background:#3498db;
+}
+
+h1
+{
+	color:rgba(0,0,0,1);
+}
+
+.wrapper
+{
+	height:100%;
+}
+
+
+
+
+.left
+{
+
+left: 0px;
+	height:100%;
+	margin-left:-1px;
+	min-width:256px;
+	width:70%;
+    float:left;
+}
+
+.right
+{
+right: 0px;
+position: absolute;
+	text-align:center;
+	background-color:rgba(200,0,0,.025);
+	border-left:1px solid rgba(230,0,0,.05);
+
+	height:100%;
+	width:30%;
+	padding-left: 30px;
+  padding-top: 70px;
+
+}
+
+
+
+.name-hero
+{
+	background:rgba(0,0,0,.001);
+
+	width:85%;
+}
+
+
+.name-hero h1
+{
+	font-family:Open Sans, sans-serif;
+	font-size:1.5em;
+	text-align:center;
+}
+
+.name-hero h2
+{
+	font-family:Open Sans, sans-serif;
+	font-size:1.5em;
+	text-align:center;
+}
+
+.name-hero h3
+{
+	font-family:Open Sans, sans-serif;
+	font-size:1.5em;
+	text-align:center;
+	margin:0px auto;
+}
+
+.name-hero h1 em
+{
+	color:rgba(0,0,0,1);
+	font-style:normal;
+	font-weight:700;
+}
+
+.name-hero p
+{
+	color:rgba(0,0,0,1);
+	font-size:.75em;
+	line-height:1.5;
+	margin:0 8px 0 0;
+	text-align:center;
+}
+
+.name-hero .name-text
+{
+    font-size:1.5em;
+	margin:0 auto;
+
+	width:85%;
+}
+
+.inner
+{
+	margin:0 auto;
+	max-width:975px;
+	padding:0em;
+}
+
+.inner h1
+{
+	font-size:1.75em;
+}
+
+.inner p
+{
+	color:rgba(0,0,0,1);
+}
+
+.inner p em
+{
+	color:rgba(0,0,0,1);
+	font-style:normal;
+}
+
+.inner section
+{
+	margin:1px auto;
+}
+
+ul
+{
+	list-style-type:none;
+	margin-top:0 px;
+	max-width:570px;
+	padding:1;
+}
+
+.skill-set
+{
+
+	color:rgba(0,0,0,1);
+	list-style:none;
+	margin:1px 1px 0 0;
+	padding:10px;
+	text-align:justify;
+}
+

src/templates/resume.html

@@ -0,0 +1,59 @@
+<html>
+
+    <body>
+<div class='parent'>
+    <div class="left">
+        <div class="inner">
+            <div class="name-hero">
+                <div class="name-text">
+                    <h1>{{name}} </h1>
+                    <h3>{{title}} </h3>
+                </div>
+
+            </div>
+
+
+            <div class="summary">
+                <h1>Summary</h1>
+                <p>{{summary}}</p>
+            </div>
+            <section>
+                <h1>Employment</h1>
+                {% for experience in workExperience %}
+                <p><em>{{experience.dates}} | {{experience.company}} | {{experience.title}}</em></p>
+                <p>{{experience.description}}</p>
+                {% endfor %}
+            </section>
+            <section>
+                <h1>Education</h1>
+                {% for edu in education %}
+                <p><em>{{edu.dates}} | {{edu.school}} | {{edu.degree}}</em></p>
+                <p>{{edu.description}}</p>
+
+                {% endfor %}
+            </section>
+
+
+        </div>
+    </div>
+    <div class="right">
+            <h1>Contact Information</h1>
+            <p>Email: {{email}}</p>
+            <p>Phone: {{phone}}</p>
+            <p>Address: {{address}}</p>
+            <p>LinkedIn: <a href="{{linkedin_url}}">LinkedIn Profile</a></p>
+            <p>Github: <a href="{{github_url}}">GitHub Profile</a></p>
+
+        <section>
+            <h1>Skills</h1>
+            <ul class="skill-set">
+                {% for skill in skills %}
+                <li>{{skill}}</li>
+                {% endfor %}
+            </ul>
+        </section>
+            </div>
+</div>
+</div>
+  </body>
+</html>

src/utils.py

@@ -0,0 +1,38 @@
+import PyPDF2
+from jinja2 import FileSystemLoader, Environment
+
+
+def parse_pdf(pdf_file):
+    if pdf_file is isinstance(pdf_file, str):
+        with open(pdf_file, "rb") as file:
+            return _parse(file)
+    else:
+        return _parse(pdf_file)
+
+
+def _parse(file):
+    reader = PyPDF2.PdfReader(file)
+    pdf_text = []
+    # Iterate over each page
+    for page_number in range(len(reader.pages)):
+        # Get the current page
+        page = reader.pages[page_number]
+
+        # Extract the text from the page
+        page_text = page.extract_text()
+
+        pdf_text.append(page_text)
+    pdf_text = '\n'.join(pdf_text)
+    return pdf_text
+
+
+def build_html_resume(data):
+    env = Environment(loader=FileSystemLoader('src/templates'))
+    template = env.get_template('resume.html')
+    html_resume = template.render(data)
+    return html_resume
+
+
+def export_html(html_resume, output_path):
+    with open(output_path, 'w', encoding='utf8') as f:
+        f.write(html_resume)