together

app.py

@@ -1,26 +1,27 @@
+import io
 import os
+from typing import Union
 
 import gradio as gr
 from gradio_pdf import PDF
 from dotenv import load_dotenv
 load_dotenv()
 
-from resume_parser import ResumeParser, pdf_to_string
+from resume_parser import ResumeParser, StructuredResumeParser, pdf_to_string
 from resume_template import Resume
 from pathlib import Path
 
-
-def parse_resume(resume_file, use_openai=False, openai_key=""):
+def parse_resume(resume_data:Union[bytes, str], use_openai=False, openai_key=""):
     p = ResumeParser(use_openai, openai_key)
-    resume_text = pdf_to_string(resume_file)
+    resume_text = pdf_to_string(resume_data)
     resume = p.extract_resume_fields(resume_text)
     if isinstance(resume, Resume):
         resume = resume.json()
     return resume
 
-def match_resume_job(resume_file, job_text, use_openai=False, openai_key=""):
+def match_resume_job(resume_data:Union[bytes, str], job_text, use_openai=False, openai_key=""):
     p = ResumeParser(use_openai, openai_key)
-    resume_text = pdf_to_string(resume_file)
+    resume_text = pdf_to_string(resume_data)
     res = p.match_resume_with_job_description(resume_text, job_text)
     return res
 
@@ -36,7 +37,8 @@ with gr.Blocks() as demo:
     with gr.Tab(label="Parser"):
         with gr.Row():
             with gr.Column():
-                pdf_file_txt = PDF(label="Resume File (pdf)", interactive=True)
+                #pdf_file_txt = PDF(label="Resume File (pdf)", interactive=True)
+                pdf_file_txt = gr.File(label="Resume File (pdf)", type='binary', interactive=True)
                 use_openai_chk = change_openai_checkbox("")
                 openai_key_txt = gr.Text(label="OpenAI Token", placeholder="openAI token or env[OPENAI_API_KEY]")
                 parse_btn = gr.Button("Parse Resume")

prompts/full_job.prompt

@@ -0,0 +1,81 @@
+You are a hiring expert with three key responsibilities: ResumeParser, JobMatcher, and ResumeBuilder.
+
+ResumeParser Task:
+Given a provided resume, extract and organize information into a structured JSON format. Ensure accurate representation with the correct data types according to defined classes. Utilize the response template for formatting. Omit fields if not applicable or information is unavailable.
+
+Response Template:
+{
+  "personal_details": {
+    "full_name": "str",
+    "contact_info": {
+      "email": "Optional[str]",
+      "phone": "Optional[str]",
+      "linkedin": "Optional[str]"
+    },
+    "professional_summary": "Optional[str]"
+  },
+  "education": [
+    {
+      "institution": "Optional[str]",
+      "degree": "Optional[str]",
+      "field_of_study": "Optional[str]",
+      "graduation_date": "Optional[str]"
+    }
+  ],
+  "work_experience": [
+    {
+      "company": "Optional[str]",
+      "title": "Optional[str]",
+      "duration": "Optional[str]",
+      "description": "Optional[str]",
+      "notable_contributions": "Optional[List[str]]"
+    }
+  ],
+  "projects": [
+    {
+      "name": "Optional[str]",
+      "description": "Optional[str]",
+      "technologies": "Optional[str]",
+      "role": "Optional[str]"
+    }
+  ],
+  "skills": "List[str]",
+  "certifications": [
+    {
+      "title": "Optional[str]",
+      "certifying_body": "Optional[str]",
+      "date": "Optional[str]"
+    }
+  ],
+  "publications": [
+    {
+      "title": "Optional[str]",
+      "co_authors": "List[str]",
+      "date": "Optional[str]"
+    }
+  ],
+  "awards": [
+    {
+      "title": "Optional[str]",
+      "awarding_body": "Optional[str]",
+      "date": "Optional[str]"
+    }
+  ],
+  "additional_sections": {
+    "volunteer_experience": [
+      {
+        "organization": "Optional[str]",
+        "role": "Optional[str]",
+        "duration": "Optional[str]",
+        "description": "Optional[str]"
+      }
+    ],
+    "languages": "Optional[List[str]]",
+    "interests": "Optional[List[str]]"
+  }
+}
+JobMatcher Task:
+Analyze the provided job description to identify key skills and experiences. Create a new profile section in the resume, emphasizing the most relevant skills and experiences matching the job requirements. Keep the profile concise (4-5 sentences), using strong action verbs and quantifiable achievements.
+
+ResumeBuilder Task:
+Given the previously parsed resume information and the newly created profile section, create a new HTML resume. Ensure all information is included, and output a complete HTML file ready for export to PDF. Avoid adding any extra information to the output. Return only the created HTML.

prompts/job_description_matching.prompt

@@ -1,15 +1,12 @@
-Analyze the provided job description and identify the key skills and experiences required for the position.
-Using the identified skills and your understanding of the provided resume, create a new profile section for the resume highlighting the most relevant skills and experiences that directly match the requirements outlined in the job description.
-Ensure the profile section is concise and impactful, using strong action verbs and quantifiable achievements where possible.
-Aim to keep the profile section within 4-5 sentences.
-----
+Your task:
 
-Job Description:
-{job_description}
+Identify key skills and experiences required by the job description.
+Extract relevant skills and achievements from the resume to compile a professional summary.
+Ensure the summary is brief, emphasizing pertinent skills and quantifiable accomplishments with action-oriented language.
+Limit the summary to 4-5 persuasive sentences and avoid mentioning job titles or non-relevant details.
 
-----
+Job Description: {job_description}
 
-resume:
-{resume}
+Resume Information: {resume}
 
-----
+Provide only the professional summary, without any additional elucidation.

prompts/json.schema

@@ -1,70 +1,124 @@
 {
   "personal_details": {
-    "full_name": "str",
-    "contact_info": {
-      "email": "Optional[str]",
-      "phone": "Optional[str]",
-      "linkedin": "Optional[str]"
+    "type": "object",
+    "properties": {
+      "first_name": { "type": "string", "default": "" },
+      "last_name": { "type": "string", "default": "" },
+      "phone_number": { "type": "string", "default": "" },
+      "linkedin_url": { "type": "string", "default": "" },
+      "email_address": { "type": "string", "default": "" },
+      "nationality": { "type": "string", "default": "" },
+      "professional_summary": { "type": "string", "default": "" }
     },
-    "professional_summary": "Optional[str]"
+    "required": ["first_name", "last_name"]
   },
-  "education": [
-    {
-      "institution": "Optional[str]",
-      "degree": "Optional[str]",
-      "field_of_study": "Optional[str]",
-      "graduation_date": "Optional[str]"
+  "education": {
+    "type": "array",
+    "items": {
+      "type": "object",
+      "properties": {
+        "degree": { "type": "string", "default": "" },
+        "institution": { "type": "string", "default": "" },
+        "field_of_study": { "type": "string", "default": "" },
+        "country": { "type": "string", "default": "" },
+        "grade": { "type": "string", "default": "" },
+        "start_date": { "type": "string", "default": "" },
+        "end_date": { "type": "string", "default": "" }
+      },
+      "required": ["degree", "institution", "field_of_study"]
     }
-  ],
-  "work_experience": [
-    {
-      "company": "Optional[str]",
-      "title": "Optional[str]",
-      "duration": "Optional[str]",
-      "description": "Optional[str]",
-      "notable_contributions": "Optional[List[str]]"
+  },
+  "work_experience": {
+    "type": "array",
+    "items": {
+      "type": "object",
+      "properties": {
+        "company": { "type": "string", "default": "" },
+        "job_title": { "type": "string", "default": "" },
+        "description": { "type": "string", "default": "" },
+        "start_date": { "type": "string", "default": "" },
+        "end_date": { "type": "string", "default": "" },
+        "notable_contributions": { "type": "array", "items": { "type": "string" }, "default": [] }
+      },
+      "required": ["company", "job_title"]
     }
-  ],
-  "projects": [
-    {
-      "name": "Optional[str]",
-      "description": "Optional[str]",
-      "technologies": "Optional[str]",
-      "role": "Optional[str]"
+  },
+  "projects": {
+    "type": "array",
+    "items": {
+      "type": "object",
+      "properties": {
+        "name": { "type": "string", "default": "" },
+        "description": { "type": "string", "default": "" },
+        "technologies": { "type": "string", "default": "" },
+        "role": { "type": "string", "default": "" }
+      },
+      "required": ["name"]
     }
-  ],
-  "skills": "List[str]",
-  "certifications": [
-    {
-      "title": "Optional[str]",
-      "certifying_body": "Optional[str]",
-      "date": "Optional[str]"
+  },
+  "certifications": {
+    "type": "array",
+    "items": {
+      "type": "object",
+      "properties": {
+        "title": { "type": "string", "default": "" },
+        "certifying_body": { "type": "string", "default": "" },
+        "date": { "type": "string", "default": "" }
+      },
+      "required": ["title"]
+    }
+  },
+  "publications": {
+    "type": "array",
+    "items": {
+      "type": "object",
+      "properties": {
+        "title": { "type": "string", "default": "" },
+        "co_authors": { "type": "array", "items": { "type": "string" }, "default": [] },
+        "date": { "type": "string", "default": "" }
+      },
+      "required": ["title"]
     }
-  ],
-  "publications": [
-    {
-      "title": "Optional[str]",
-      "co_authors": "List[str]",
-      "date": "Optional[str]"
+  },
+  "awards": {
+    "type": "array",
+    "items": {
+      "type": "object",
+      "properties": {
+        "title": { "type": "string", "default": "" },
+        "awarding_body": { "type": "string", "default": "" },
+        "date": { "type": "string", "default": "" }
+      },
+      "required": ["title"]
     }
-  ],
-  "awards": [
-    {
-      "title": "Optional[str]",
-      "awarding_body": "Optional[str]",
-      "date": "Optional[str]"
+  },
+  "volunteer_experience": {
+    "type": "array",
+    "items": {
+      "type": "object",
+      "properties": {
+        "organization": { "type": "string", "default": "" },
+        "description": { "type": "string", "default": "" },
+        "role": { "type": "string", "default": "" },
+        "start_date": { "type": "string", "default": "" },
+        "end_date": { "type": "string", "default": "" }
+      },
+      "required": ["organization"]
     }
-  ],
-  "additional_sections": {
-    "volunteer_experience": [
-      {
-        "organization": "Optional[str]",
-        "role": "Optional[str]",
-        "duration": "Optional[str]",
-        "description": "Optional[str]"
-      }
-    ],
-    "languages": "Optional[List[str]]",
-    "interests": "Optional[List[str]]"
+  },
+  "languages": {
+    "type": "array",
+    "items": { "type": "string" },
+    "default": []
+  },
+  "interests": {
+    "type": "array",
+    "items": { "type": "string" },
+    "default": []
+  },
+  "skills": {
+    "type": "array",
+    "items": { "type": "string" },
+    "default": []
   }
-}
+}

prompts/json0.schema

@@ -0,0 +1,73 @@
+{
+  "personal_details": {
+    "first_name": "str",
+    "last_name": "str",
+    "phone_number": "Optional[str]",
+    "linkedin_url": "Optional[str]",
+    "email_address": "Optional[str]",
+    "nationality": "Optional[str]",
+    "professional_summary": "Optional[str]"
+  },
+  "education": [
+    {
+      "degree": "str",
+      "institution": "str",
+      "field_of_study": "str",
+      "country": "Optional[str]",
+      "grade": "Optional[str]",
+      "start_date": "Optional[str]",
+      "end_date": "Optional[str]"
+    }
+  ],
+  "work_experience": [
+    {
+      "company": "str",
+      "job_title": "str",
+      "description": "Optional[str]",
+      "start_date": "Optional[str]",
+      "end_date": "Optional[str]",
+      "notable_contributions": "List[str]"
+    }
+  ],
+  "projects": [
+    {
+      "name": "str",
+      "description": "Optional[str]",
+      "technologies": "Optional[str]",
+      "role": "Optional[str]"
+    }
+  ],
+  "skills": "List[str]",
+  "certifications": [
+    {
+      "title": "str",
+      "certifying_body": "Optional[str]",
+      "date": "Optional[str]"
+    }
+  ],
+  "publications": [
+    {
+      "title": "str",
+      "co_authors": "List[str]",
+      "date": "Optional[str]"
+    }
+  ],
+  "awards": [
+    {
+      "title": "str",
+      "awarding_body": "Optional[str]",
+      "date": "Optional[str]"
+    }
+  ],
+  "volunteer_experience": [
+    {
+      "organization": "str",
+      "role": "Optional[str]",
+      "description": "Optional[str]",
+      "start_date": "Optional[str]",
+      "end_date": "Optional[str]"
+    }
+  ],
+  "languages": "List[str]",
+  "interests": "List[str]"
+}

prompts/json2.schema

@@ -0,0 +1,183 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Resume",
+  "type": "object",
+  "properties": {
+    "personal_details": {
+      "$ref": "#/definitions/PersonalDetails"
+    },
+    "education": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/Education"
+      },
+      "default": []
+    },
+    "work_experience": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/WorkExperience"
+      },
+      "default": []
+    },
+    "projects": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/Project"
+      },
+      "default": []
+    },
+    "skills": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "default": []
+    },
+    "certifications": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/Certification"
+      },
+      "default": []
+    },
+    "publications": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/Publication"
+      },
+      "default": []
+    },
+    "awards": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/Award"
+      },
+      "default": []
+    },
+    "volunteer_experience": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/VolunteerExperience"
+      },
+      "default": []
+    },
+    "languages": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "default": []
+    },
+    "interests": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "default": []
+    }
+  },
+  "required": ["personal_details"],
+  "definitions": {
+    "PersonalDetails": {
+      "type": "object",
+      "properties": {
+        "first_name": {"type": "string", "description": "The first name of the person.", "default": ""},
+        "last_name": {"type": "string", "description": "The last name of the person.", "default": ""},
+        "phone_number": {"type": "string", "description": "The phone number of the person.", "default": ""},
+        "linkedin_url": {"type": "string", "description": "The url of the linkedin profile of the person.", "default": ""},
+        "email_address": {"type": "string", "description": "The email address of the person.", "default": ""},
+        "nationality": {"type": "string", "description": "The nationality of the person.", "default": ""},
+        "professional_summary": {"type": "string", "description": "The professional summary or the profile section of resume of the person", "default": ""}
+      },
+      "required": ["first_name", "last_name"]
+    },
+    "Education": {
+      "type": "object",
+      "properties": {
+        "degree": {"type": "string", "description": "The degree obtained or expected.", "default": ""},
+        "institution": {"type": "string", "description": "The university, college, or educational institution visited.", "default": ""},
+        "field_of_study": {"type": "string", "description": "The field of study.", "default": ""},
+        "country": {"type": "string", "description": "The country of the institution.", "default": ""},
+        "grade": {"type": "string", "description": "The grade achieved or expected.", "default": ""},
+        "start_date": {"type": "string", "description": "When the study started.", "default": ""},
+        "end_date": {"type": "string", "description": "When the study ended.", "default": ""}
+      },
+      "required": ["degree", "institution", "field_of_study"]
+    },
+    "WorkExperience": {
+      "type": "object",
+      "properties": {
+        "company": {"type": "string", "description": "The company name of the work experience.", "default": ""},
+        "job_title": {"type": "string", "description": "The job title.", "default": ""},
+        "description": {"type": "string", "description": "The job or role description.", "default": ""},
+        "start_date": {"type": "string", "description": "When the job started.", "default": ""},
+        "end_date": {"type": "string", "description": "When the job ended.", "default": ""},
+        "notable_contributions": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Notable contributions in the work experience.",
+          "default": []
+        }
+      },
+      "required": ["company", "job_title"]
+    },
+    "Project": {
+      "type": "object",
+      "properties": {
+        "name": {"type": "string", "description": "The name of the project", "default": ""},
+        "description": {"type": "string", "description": "The description of the project", "default": ""},
+        "technologies": {"type": "string", "description": "The technologies used in the project", "default": ""},
+        "role": {"type": "string", "description": "The role of the person in the project", "default": ""}
+      },
+      "required": ["name"]
+    },
+    "Certification": {
+      "type": "object",
+      "properties": {
+        "title": {"type": "string", "description": "Title of the certificate", "default": ""},
+        "certifying_body": {"type": "string", "description": "The text or body of the certificate", "default": ""},
+        "date": {"type": "string", "description": "The Date of the certificate", "default": ""}
+      },
+      "required": ["title"]
+    },
+    "Publication": {
+      "type": "object",
+      "properties": {
+        "title": {"type": "string", "description": "The title of the publication", "default": ""},
+        "co_authors": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "The list of other authors of the publication",
+          "default": []
+        },
+        "date": {"type": "string", "description": "The date of publication", "default": ""}
+      },
+      "required": ["title", "co_authors"]
+    },
+    "Award": {
+      "type": "object",
+      "properties": {
+        "title": {"type": "string", "description": "Award Title", "default": ""},
+        "awarding_body": {"type": "string", "description": "The text or body of award", "default": ""},
+        "date": {"type": "string", "description": "The date of award", "default": ""}
+      },
+      "required": ["title"]
+    },
+    "VolunteerExperience": {
+      "type": "object",
+      "properties": {
+        "organization": {"type": "string", "description": "The organization name of volunteer experience", "default": ""},
+        "description": {"type": "string", "description": "The description of volunteer experience", "default": ""},
+        "role": {"type": "string", "description": "Role of the person in the volunteer experience", "default": ""},
+        "start_date": {"type": "string", "description": "The start date of the volunteer experience", "default": ""},
+        "end_date": {"type": "string", "description": "The end date of the volunteer experience", "default": ""}
+      },
+      "required": ["organization"]
+    }
+  }
+}

prompts/resume_extraction.prompt

@@ -1,20 +1,12 @@
-Given the provided resume, extract and organize the following information into a structured JSON format.
-Ensure that each field is accurately represented with the correct data types according to the defined classes.
-If a section is not applicable or the information is unavailable, omit that particular field from the JSON object.
-
-Utilize the provided response template for formatting.
-----
-
-Response Template:
-{response_template}
-
-----
-
-resume:
-{resume}
-
-----
+Your task is to transform the provided resume data into a JSON string, adhering to these rules:
 
+Ensure compliance with the given JSON schema.
+Correctly match data types as per the schema.
+Use default values for unspecified or inapplicable fields according to the schema.
+Omit any fields that would have a value of None.
 
+JSON Schema: {json_schema}
 
+Resume Information: {resume}
 
+Output only the resulting JSON string, with no additional commentary.

prompts/resume_extraction_structured.prompt

@@ -0,0 +1,4 @@
+Your task is to  parse the provided resume data and transfrom it into a structured data
+
+Resume data: {resume}
+

requirements.txt

@@ -7,4 +7,6 @@ huggingface_hub
 langchain
 langchain-community
 langchain-openai
-python-dotenv
+python-dotenv
+fastapi[all]
+

resume_api.py

@@ -0,0 +1,46 @@
+from typing import Annotated, Optional
+
+import pydantic
+import uvicorn
+from fastapi import FastAPI, UploadFile, Body, File
+
+from resume_parser import ResumeParser, pdf_to_string
+from resume_template import Resume
+
+app = FastAPI()
+
+@app.get("/")
+async def root():
+    return "OK"
+
+@app.post("/parse_resume/")
+async def parse_resume(resume_file: UploadFile, use_openai:bool=True):
+    content = await resume_file.read()
+    await resume_file.close()
+    p = ResumeParser(use_openai)
+    resume_text = pdf_to_string(content)
+    resume = p.extract_resume_fields(resume_text)
+    return resume
+
+@app.post("/match_resume_job/")
+async def match_resume_job(resume_file: UploadFile, job_description:Annotated[str, Body(embed=True)], use_openai:bool=True):
+    content = await resume_file.read()
+    await resume_file.close()
+    p = ResumeParser(use_openai)
+    resume_text = pdf_to_string(content)
+    res = p.match_resume_with_job_description(resume_text, job_description)
+    return res
+
+@app.post("/match_resume_job_file/")
+async def match_resume_job(resume_file: UploadFile, job_description_file:UploadFile, use_openai:bool=True):
+    content = await resume_file.read()
+    await resume_file.close()
+    p = ResumeParser(use_openai)
+    resume_text = pdf_to_string(content)
+    job_description_text = await job_description_file.read()
+    await job_description_file.close()
+    res = p.match_resume_with_job_description(resume_text, job_description_text)
+    return res
+
+if __name__ == '__main__':
+    uvicorn.run(app, host="0.0.0.0", port=8000)

resume_builder.py

@@ -0,0 +1,85 @@
+import io
+from typing import List
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, ListFlowable, ListItem
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.enums import TA_LEFT, TA_CENTER
+
+from reportlab.lib.units import inch
+
+from resume_template import Resume
+# The Class definitions (PersonalDetails, Education, etc.) should be imported or defined above this line.
+# Now assuming those classes are defined and imported if they're in another module.
+
+class ResumeGenerator:
+    def __init__(self, resume: Resume):
+        self.resume: Resume = resume
+        self.buffer = io.BytesIO()
+        self.styles = getSampleStyleSheet()
+        self.custom_styles()
+
+    def custom_styles(self):
+        self.styles.add(ParagraphStyle(name='CustomTitle', parent=self.styles['Title'], fontSize=18, leading=22,
+                                       alignment=TA_CENTER))
+        #self.styles.add(ParagraphStyle(name='Heading1', parent=self.styles['Heading1'], spaceAfter=10, fontSize=14))
+        self.styles.add(ParagraphStyle(name='NormalIndent', parent=self.styles['Normal'], leftIndent=15))
+
+    def generate_pdf(self, filename):
+        doc = SimpleDocTemplate(self.buffer, pagesize=letter)
+        flowables = []
+
+        self.add_personal_details(flowables)
+        self.add_section_title(flowables, "Education")
+        self.add_education(flowables)
+        self.add_section_title(flowables, "Work Experience")
+        self.add_work_experience(flowables)
+        self.add_section_title(flowables, "Projects")
+        self.add_projects(flowables)
+        # Additional sections following the same pattern...
+
+        doc.build(flowables)
+        pdf = self.buffer.getvalue()
+        self.buffer.close()
+
+        with open(filename, 'wb') as f:
+            f.write(pdf)
+
+    def add_personal_details(self, flowables):
+        pd = self.resume.personal_details
+        flowables.append(Paragraph(f"{pd.first_name} {pd.last_name}", self.styles['CustomTitle']))
+        # Include additional personal details as needed...
+        flowables.append(Spacer(1, 0.2 * inch))
+
+    def add_education(self, flowables):
+        for edu in self.resume.education:
+            flowables.append(Paragraph(
+                f"{edu.degree} in {edu.field_of_study}, {edu.institution} ({edu.start_date} - {edu.end_date})",
+                self.styles['NormalIndent']))
+            flowables.append(Spacer(1, 0.1 * inch))
+
+    def add_work_experience(self, flowables):
+        for work in self.resume.work_experience:
+            flowables.append(Paragraph(f"{work.job_title}, {work.company} ({work.start_date} - {work.end_date})",
+                                       self.styles['NormalIndent']))
+            flowables.append(Spacer(1, 0.05 * inch))
+            contributions = ListFlowable([ListItem(Paragraph(contribution, self.styles['Bullet'])) for contribution in
+                                          (work.notable_contributions or [])], bulletType='bullet', leftIndent=35)
+            if work.notable_contributions:
+                flowables.append(contributions)
+                flowables.append(Spacer(1, 0.1 * inch))
+
+    # Methods for Projects, Skills, Certifications, etc...
+
+    def add_projects(self, flowables):
+        for project in self.resume.projects:
+            flowables.append(Paragraph(f"{project.name}: {project.description}", self.styles['NormalIndent']))
+            flowables.append(Spacer(1, 0.1 * inch))
+
+    def add_section_title(self, flowables, title):
+        flowables.append(Spacer(1, 0.2 * inch))
+        flowables.append(Paragraph(title, self.styles['Heading1']))
+        flowables.append(Spacer(1, 0.1 * inch))
+
+# Assuming you have a populated resume_obj of type Resume...
+# resume_generator = ResumeGenerator(resume_obj)
+# resume_generator.generate_pdf('My_Resume.pdf')

resume_parser.py

@@ -1,57 +1,83 @@
+import io
 import os
 from json import JSONDecodeError
+from typing import Union
 
 import PyPDF2
 from dotenv import load_dotenv
 from langchain.output_parsers import PydanticOutputParser
 from langchain.prompts import PromptTemplate
 from langchain_community.callbacks import get_openai_callback
+from langchain_community.llms.huggingface_pipeline import HuggingFacePipeline
 from langchain_openai import ChatOpenAI
 from langchain_community.llms import HuggingFaceEndpoint
 from langchain_core.messages import BaseMessage
 from pydantic import ValidationError
 
+from resume_builder import ResumeGenerator
 from resume_template import Resume
 
 load_dotenv()
 
 
-def pdf_to_string(file):
+def pdf_to_string(file:Union[io.BytesIO, str, bytes]):
     """
     Convert a PDF file to a string.
 
     Parameters:
-    file (io.BytesIO): A file-like object representing the PDF file. or file Path
+    file: A file-like object representing the PDF file (io.BytesIO, or file Path, or bytes)
 
     Returns:
     str: The extracted text from the PDF.
     """
-    pdf_reader = PyPDF2.PdfReader(file)
+    f = io.BytesIO(file) if isinstance(file, bytes) else file
+    pdf_reader = PyPDF2.PdfReader(f)
     num_pages = len(pdf_reader.pages)
     text = ''
     for i in range(num_pages):
         page = pdf_reader.pages[i]
         text += page.extract_text()
+    if isinstance(f, io.BytesIO):
+        f.close()
     return text
 
+
 class ResumeParser:
+    list_llm = [
+        "mistralai/mistral-7b-instruct-v0.2",
+        "mistralai/Mixtral-8x7B-Instruct-v0.1",
+        "microsoft/phi-2",
+        "google/gemma-7b-it",
+        "HuggingFaceH4/zephyr-7b-beta",
+        "HuggingFaceH4/zephyr-7b-gemma-v0.1",
+        ]
     def __init__(self, use_openai=False, openai_key=""):
         self.use_openai = use_openai
-        self.openai_key = openai_key
+        self.openai_key = ""
         self.model = None
-        self.set_key()
+        self.hf_model_name = self.list_llm[0]
+        self.openai_model_name = "gpt-3.5-turbo" #"gpt-4-1106-preview"
+        self.set_key(openai_key)
         self.set_model()
 
-    def set_key(self):
+    def set_key(self, openai_key=""):
+        self.openai_key = openai_key
         if len(self.openai_key) == 0 and "OPENAI_API_KEY" in os.environ:
             self.openai_key = os.environ["OPENAI_API_KEY"]
 
-    def set_model(self):
+    def set_model(self, hf_model_name=""):
         if self.use_openai:
-            self.model = ChatOpenAI(temperature=0, model="gpt-3.5-turbo", max_tokens=2500, openai_api_key=self.openai_key)
+            print(f"using OpenAI Model {self.openai_model_name}")
+            self.model = ChatOpenAI(temperature=0, model=self.openai_model_name, max_tokens=2500, openai_api_key=self.openai_key)
         else:
-            self.model = HuggingFaceEndpoint(repo_id="mistralai/Mixtral-8x7B-Instruct-v0.1", temperature=0.001,
-                                        max_new_tokens=4000)
+            if hf_model_name != "" and hf_model_name in self.list_llm:
+                self.hf_model_name = hf_model_name
+            print(f"using HF Model {self.hf_model_name}")
+            self.model = HuggingFaceEndpoint(repo_id=self.hf_model_name, temperature=0.001, max_new_tokens=4000)
+            #self.model = HuggingFacePipeline.from_model_id(model_id=self.hf_model_name, task="text-generation",
+            #                device=0,
+            #                pipeline_kwargs={"max_new_tokens": 4000},
+            #                model_kwargs={"temperature": 0.001, "max_length": 8000})
 
     def extract_resume_fields(self, full_text):
         """
@@ -77,7 +103,7 @@ class ResumeParser:
         prompt_template = PromptTemplate(
             template=template,
             input_variables=["resume"],
-            partial_variables={"response_template": json_schema},
+            partial_variables={"json_schema": json_schema},
         )
         # Invoke the language model and process the resume
         formatted_input = prompt_template.format_prompt(resume=full_text)
@@ -87,7 +113,7 @@ class ResumeParser:
             output = llm.invoke(formatted_input.to_string())
             print(cb)
 
-        # print(output)  # Print the output object for debugging
+        #print(output)  # Print the output object for debugging
         if isinstance(output, BaseMessage):
             output = output.content
         try:
@@ -112,11 +138,6 @@ class ResumeParser:
             return output
 
 
-    def run(self, pdf_file_path):
-        text = pdf_to_string(pdf_file_path)
-        extracted_fields = self.extract_resume_fields(text)
-        return extracted_fields
-
     def match_resume_with_job_description(self, resume_txt, job_description):
         with open("prompts/job_description_matching.prompt", "r") as f:
             template = f.read()
@@ -138,10 +159,120 @@ class ResumeParser:
             output = output.content
         return output
 
+class StructuredResumeParser:
+    list_llm = [
+        "mistralai/Mixtral-8x7B-Instruct-v0.1",
+        "mistralai/mistral-7b-instruct-v0.2",
+        "microsoft/phi-2",
+        "google/gemma-7b-it",
+        "HuggingFaceH4/zephyr-7b-beta",
+        "HuggingFaceH4/zephyr-7b-gemma-v0.1",
+        ]
+    def __init__(self, use_openai=False, openai_key=""):
+        self.use_openai = use_openai
+        self.openai_key = ""
+        self.model = None
+        self.hf_model_name = self.list_llm[0]
+        self.openai_model_name = "gpt-3.5-turbo" #"gpt-4-1106-preview"
+        self.set_key(openai_key)
+        self.set_model()
+
+    def set_key(self, openai_key=""):
+        self.openai_key = openai_key
+        if len(self.openai_key) == 0 and "OPENAI_API_KEY" in os.environ:
+            self.openai_key = os.environ["OPENAI_API_KEY"]
+
+    def set_model(self, hf_model_name=""):
+        if self.use_openai:
+            print(f"using OpenAI Model {self.openai_model_name}")
+            self.model = ChatOpenAI(temperature=0, model=self.openai_model_name, max_tokens=2500, openai_api_key=self.openai_key)
+        else:
+            if hf_model_name != "" and hf_model_name in self.list_llm:
+                self.hf_model_name = hf_model_name
+            print(f"using Together Model {self.hf_model_name}")
+            self.model = ChatOpenAI(
+                base_url="https://api.together.xyz/v1",
+                api_key=os.environ["TOGETHER_API_KEY"],
+                model=self.hf_model_name,
+            )
+
+    def extract_resume_fields(self, full_text):
+        """
+        Analyze a resume text and extract structured information using a specified language model.
 
+        Parameters:
+        full_text (str): The text content of the resume.
+        model (str): The language model object to use for processing the text.
+
+        Returns:
+        dict: A dictionary containing structured information extracted from the resume.
+        """
+        # The Resume object is imported from the local resume_template file
+
+        with open("prompts/resume_extraction_structured.prompt", "r") as f:
+            template = f.read()
+
+        prompt_template = PromptTemplate(
+            template=template,
+            input_variables=["resume"]
+        )
+        # Invoke the language model and process the resume
+        formatted_input = prompt_template.format_prompt(resume=full_text)
+        llm = self.model.with_structured_output(Resume)
+        with get_openai_callback() as cb:
+            output = llm.invoke(formatted_input.to_string())
+            print(cb)
+
+        return output
+
+
+    def match_resume_with_job_description(self, resume_txt, job_description):
+        with open("prompts/job_description_matching.prompt", "r") as f:
+            template = f.read()
+
+        prompt_template = PromptTemplate(
+            template=template,
+            input_variables=["resume", "job_description"],
+        )
+        # Invoke the language model and process the resume
+        formatted_input = prompt_template.format_prompt(resume=resume_txt, job_description=job_description)
+        llm = self.model
+        # print("llm", llm)
+        with get_openai_callback() as cb:
+            output = llm.invoke(formatted_input.to_string())
+            print(cb)
+
+        # print(output)  # Print the output object for debugging
+        if isinstance(output, BaseMessage):
+            output = output.content
+        return output
 
 
 if __name__ == "__main__":
-    p = ResumeParser(use_openai=False)
-    res = p.run("samples/0.pdf")
-    print(res)
+    resume_file = "samples/0.pdf"
+    text = pdf_to_string(resume_file)
+    p = StructuredResumeParser(use_openai=False)
+    resume_data = p.extract_resume_fields(text)
+
+    '''
+    model = ChatOpenAI(
+        base_url="https://api.together.xyz/v1",
+        api_key=os.environ["TOGETHER_API_KEY"],
+        model="mistralai/Mixtral-8x7B-Instruct-v0.1",
+    )
+    model_with_structure = model.with_structured_output(Resume)
+
+    with open("prompts/resume_extraction_structured.prompt", "r") as f:
+        template = f.read()
+    prompt_template = PromptTemplate(
+        template=template,
+        input_variables=["resume"]
+    )
+    formatted_input = prompt_template.format_prompt(resume=text)
+    with get_openai_callback() as cb:
+        resume_data = model_with_structure.invoke(formatted_input.to_string())
+        print(cb)
+    '''
+    print(resume_data)
+
+

resume_template.py

@@ -1,62 +1,63 @@
 from pydantic.v1 import BaseModel, Field, ValidationError
 from typing import List, Optional, Dict
 
-# The following classes are for the resume template
-
-class ContactInfo(BaseModel):
-    email: Optional[str] = None
-    phone: Optional[str] = None
-    linkedin: Optional[str] = None
 
 class PersonalDetails(BaseModel):
-    full_name: str
-    contact_info: ContactInfo
-    professional_summary: Optional[str] = None
+    first_name: str = Field(default="", description="The first name of the person.")
+    last_name: str = Field(default="", description="The last name of the person.")
+    phone_number: Optional[str] = Field(default=None, description="The phone number of the person.")
+    linkedin_url: Optional[str] = Field(default=None, description="The url of the linkedin profile of the person.")
+    email_address: Optional[str] = Field(default=None, description="The email address of the person.")
+    nationality: Optional[str] = Field(default=None, description="The nationality of the person.")
+    professional_summary: Optional[str] = Field(default=None, description="The professional summary or the profile section of resume of the person")
+
 
 class Education(BaseModel):
-    institution: Optional[str] = None
-    degree: Optional[str] = None
-    field_of_study: Optional[str] = None
-    graduation_date: Optional[str] = None
+    degree: str = Field(default="", description="The degree obtained or expected.")
+    institution: str = Field(default="", description="The university, college, or educational institution visited.")
+    field_of_study: str = Field(default="", description="The field of study.")
+    country: Optional[str] = Field(default=None, description="The country of the institution.")
+    grade: Optional[str] = Field(default=None, description="The grade achieved or expected.")
+    start_date: Optional[str] = Field(default=None, description="When the study started.")
+    end_date: Optional[str] = Field(default=None, description="When the study ended.")
+
 
 class WorkExperience(BaseModel):
-    company: Optional[str] = None
-    title: Optional[str] = None
-    duration: Optional[str] = None
-    description: Optional[str] = None
-    notable_contributions: Optional[List[str]] = None
+    company: str = Field(default="", description="The company name of the work experience.")
+    job_title: str = Field(default="", description="The job title.")
+    description: Optional[str] = Field(default=None, description="The job or role description.")
+    start_date: Optional[str] = Field(default=None, description="When the job started.")
+    end_date: Optional[str] = Field(default=None, description="When the job ended.")
+    notable_contributions: List[str] = Field(default=[], description="notable contributions in the work experience")
+
 
 class Project(BaseModel):
-    name: Optional[str] = None
-    description: Optional[str] = None
-    technologies: Optional[str] = None
-    role: Optional[str] = None
+    name: str = Field(default="", description="The name of the project")
+    description: Optional[str] = Field(default=None, description="The description of the project")
+    technologies: Optional[str] = Field(default=None, description="the technologies used in the project")
+    role: Optional[str] = Field(default=None, description="The role of the person in the project")
 
 class Certification(BaseModel):
-    title: Optional[str] = None
-    certifying_body: Optional[str] = None
-    date: Optional[str] = None
+    title: str = Field(default="", description="Title of the certificate")
+    certifying_body: Optional[str] = Field(default=None, description="The text or body of the certificate")
+    date: Optional[str] = Field(default=None, description="The Date of the certificate")
 
 class Publication(BaseModel):
-    title: Optional[str] = None
-    co_authors: List[str] = []
-    date: Optional[str] = None
+    title: str = Field(default="", description="The title of the publication")
+    co_authors: List[str] = Field(default=[], description="The list of other authors of the publication")
+    date: Optional[str] = Field(default=None, description="the date of publication")
 
 class Award(BaseModel):
-    title: Optional[str] = None
-    awarding_body: Optional[str] = None
-    date: Optional[str] = None
+    title: str = Field(default="", description="Award Title")
+    awarding_body: Optional[str] = Field(default=None, description="the text or body of award")
+    date: Optional[str] = Field(default=None, description="the date of award")
 
 class VolunteerExperience(BaseModel):
-    organization: Optional[str] = None
-    role: Optional[str] = None
-    duration: Optional[str] = None
-    description: Optional[str] = None
-
-class AdditionalSections(BaseModel):
-    volunteer_experience: Optional[List[VolunteerExperience]] = []
-    languages: Optional[List[str]] = []
-    interests: Optional[List[str]] = []
+    organization: str = Field(default="", description="the organization name of volunteer experience")
+    description: Optional[str] = Field(default=None, description="the description of volunteer experience")
+    role: Optional[str] = Field(default=None, description="role of the person in the volunteer experience")
+    start_date: Optional[str] = Field(default=None, description="the start date of the volunteer experience")
+    end_date: Optional[str] = Field(default=None, description="the end date of the volunteer experience")
 
 class Resume(BaseModel):
     personal_details: PersonalDetails
@@ -67,4 +68,6 @@ class Resume(BaseModel):
     certifications: List[Certification] = []
     publications: List[Publication] = []
     awards: List[Award] = []
-    additional_sections: Optional[AdditionalSections] = None
+    volunteer_experience: List[VolunteerExperience] = []
+    languages: List[str] = []
+    interests: List[str] = []

samples/jobs/0.txt

@@ -1 +0,0 @@
-Job brief. We are looking for a Software Developer to build and implement functional programs. You will work with other Developers and Product Managers throughout the software development life cycle. In this role, you should be a team player with a keen eye for detail and problem-solving skills.

samples/jobs/1.txt

@@ -1,26 +0,0 @@
-We are looking for a Software Developer to build and implement functional programs. You will work with other Developers and Product Managers throughout the software development life cycle.
-
-In this role, you should be a team player with a keen eye for detail and problem-solving skills. If you also have experience in Agile frameworks and popular coding languages (e.g. JavaScript), we’d like to meet you.
-
-Your goal will be to build efficient programs and systems that serve user needs.
-
-Responsibilities
-Work with developers to design algorithms and flowcharts
-Produce clean, efficient code based on specifications
-Integrate software components and third-party programs
-Verify and deploy programs and systems
-Troubleshoot, debug and upgrade existing software
-Gather and evaluate user feedback
-Recommend and execute improvements
-Create technical documentation for reference and reporting
-Requirements and skills
-Proven experience as a Software Developer, Software Engineer or similar role
-Familiarity with Agile development methodologies
-Experience with software design and development in a test-driven environment
-Knowledge of coding languages (e.g. C++, Java, JavaScript) and frameworks/systems (e.g. AngularJS, Git)
-Experience with databases and Object-Relational Mapping (ORM) frameworks (e.g. Hibernate)
-Ability to learn new languages and technologies
-Excellent communication skills
-Resourcefulness and troubleshooting aptitude
-Attention to detail
-BSc/BA in Computer Science, Engineering or a related field

samples/jobs/application support engineer.txt

@@ -0,0 +1,24 @@
+We are seeking a knowledgeable Application Support Engineer to monitor and maintain the efficiency of our software applications. In this role, your duties will include reporting to our senior software engineering team, collaborating with colleagues, and performing successful code migration. You will also be required to provide IT support to our clients.
+
+To ensure success as an Application Support Engineer, you should possess extensive experience in providing application support in a fast-paced environment. Top-Notch Application Support Engineers distinguish themselves by being proactive in providing application support.
+
+Application Support Engineer Responsibilities:
+Providing software application support under the supervision of the Senior Engineer.
+Performing analyses on software application functionality and suggesting improvements.
+Ensuring effective front end and back end functionality of applications.
+Consulting with the software development team, internal users, and clients to improve application performance.
+Managing code migration across environments to ensure continued and synchronized functionality.
+Establishing the root causes of application errors, and escalating serious concerns to the Senior Engineer.
+Keeping record of configuration changes and scheduling application updates.
+Documenting processes and monitoring application performance metrics.
+Providing front end support to clients and colleagues in other departments.
+Application Support Engineer Requirements:
+A Bachelor's Degree in Software Engineering, Computer Science, Information Technology, Information Systems, Computer Engineering, or similar.
+Demonstrable experience as an Application Support Engineer in a related field.
+Advanced knowledge of front end and back end programming languages, such as C++, Javascript, Python, and Ruby.
+Ability to manage code migration, document configuration changes, and monitor performance.
+Exceptional ability to provide front end support to internal departments and web-based clients.
+Advanced proficiency in determining the causes of application errors and repairing them.
+Knowledge of Advanced Encryption Standards (AES).
+Ability to keep up with innovation in application design.
+Exceptional communication skills.

samples/jobs/backend developer.txt

@@ -0,0 +1,21 @@
+We are looking for an analytical, results-driven Back-end Developer who will work with team members to troubleshoot and improve current back-end applications and processes. The Back-end Developer will use his or her understanding of programming languages and tools to analyze current codes and industry developments, formulate more efficient processes, solve problems, and create a more seamless experience for users. You should have excellent communication, computer, and project management skills.
+
+To succeed as a Backend Developer, you should be focused on building a better, more efficient program and creating a better end-user experience. You should be knowledgeable, collaborative, and motivated.
+
+Back-end Developer Responsibilities:
+Compile and analyze data, processes, and codes to troubleshoot problems and identify areas for improvement.
+Collaborating with the front-end developers and other team members to establish objectives and design more functional, cohesive codes to enhance the user experience.
+Developing ideas for new programs, products, or features by monitoring industry developments and trends.
+Recording data and reporting it to proper parties, such as clients or leadership.
+Participating in continuing education and training to remain current on best practices, learn new programming languages, and better assist other team members.
+Taking lead on projects, as needed.
+Back-end Developer Requirements:
+Bachelor?s degree in computer programming, computer science, or a related field.
+More education or experience may be required.
+Fluency or understanding of specific languages, such as Java, PHP, or Python, and operating systems may be required.
+Strong understanding of the web development cycle and programming techniques and tools.
+Focus on efficiency, user experience, and process improvement.
+Excellent project and time management skills.
+Strong problem solving and verbal and written communication skills.
+Ability to work independently or with a group.
+Willingness to sit at desk for extended periods.

samples/jobs/big data engineer.txt

@@ -0,0 +1,24 @@
+We are looking to hire a talented Big Data Engineer to develop and manage our company?s Big Data solutions. In this role, you will be required to design and implement Big Data tools and frameworks, implement ELT processes, collaborate with development teams, build cloud platforms, and maintain the production system.
+
+To ensure success as a Big Data Engineer, you should have in-depth knowledge of Hadoop technologies, excellent project management skills, and high-level problem-solving skills. A top-notch Big Data Engineer understands the needs of the company and institutes scalable data solutions for its current and future needs.
+
+Big Data Engineer Responsibilities:
+Meeting with managers to determine the company?s Big Data needs.
+Developing Hadoop systems.
+Loading disparate data sets and conducting pre-processing services using Hive or Pig.
+Finalizing the scope of the system and delivering Big Data solutions.
+Managing the communications between the internal system and the survey vendor.
+Collaborating with the software research and development teams.
+Building cloud platforms for the development of company applications.
+Maintaining production systems.
+Training staff on data resource management.
+Big Data Engineer Requirements:
+Bachelor?s degree in Computer Engineering or Computer Science.
+Previous experience as a Big Data Engineer.
+In-depth knowledge of Hadoop, Spark, and similar frameworks.
+Knowledge of scripting languages including Java, C++, Linux, Ruby, PHP, Python, and R.
+Knowledge of NoSQL and RDBMS databases including Redis and MongoDB.
+Familiarity with Mesos, AWS, and Docker tools.
+Excellent project management skills.
+Good communication skills.
+Ability to solve complex networking, data, and software issues.

samples/jobs/c developer.txt

@@ -0,0 +1,23 @@
+We are looking to hire a skilled C Developer to join our dynamic IT team. Your primary responsibility will be to develop and code C modules and embedded systems for high-level languages that are reliable and easy to maintain. You may also be required to implement performance modules, identify bottlenecks, and fix bugs.
+
+To ensure success as a C Developer, you should be proficient in C and C++ languages, exhibit strong problem-solving skills, and have a good understanding of code versioning tools. Ultimately, a top-notch C Developer can create clean, reusable code that perfectly integrates with other higher-level languages such as Java, Go, Node.js, and Python.
+
+C Developer Responsibilities:
+Meeting with the IT and design team to discuss application requirements.
+Designing and building reliable and clean C code.
+Developing kernel modules, libraries, and embedded systems for other high-level languages.
+Implementing quality and performance modules.
+Identifying bottlenecks or bugs and troubleshooting integration issues.
+Testing code quality and durability.
+Maintaining the automation and quality of the code.
+C Developer Requirements:
+Bachelor?s degree in Computer Science, Mathematics or related field.
+Proven work experience as a C Developer.
+Proficiency in C and C++.
+Knowledge of high-level leagues including Java, Python, Go and Node.js.
+Familiarity with language tools such as Valgrind and Lint.
+Good understanding of code versioning tools such as SVN, Mercurial, and Git.
+Knowledge of systems design and low-level hardware interactions.
+In-depth knowledge of STL and BOOST.
+Good problem-solving skills.
+Ability to project manage.

samples/jobs/computer engineer.txt

@@ -0,0 +1,21 @@
+We are searching for a talented and experienced Computer Engineer to join our dynamic team. As the Computer Engineer, you will play a vital role in our Information Technology (IT) department, performing a range of duties including designing, testing, and inspecting all software used within the company.
+
+The successful candidate will have in-depth knowledge of design analytics, algorithms, analysis tools, and object orientated modeling. To excel in this position, all candidates should be critical and creative thinkers, with excellent communication and problem-solving skills.
+
+Responsibilities:
+Perform periodic hardware analysis of computer hardware and software using available technology and testing tools.
+Respond to all computer-related issues and provide technical support to all staff members.
+Oversee the company?s cloud storage accounts to guarantee they?re protected and secure.
+Conduct validation testing for new and renovated motherboards.
+Ensure existing computer equipment are up-to-date.
+Stay up-to-date with the latest technologies and incorporate new technology into existing units.
+Draft new computer equipment blueprints and present them to management.
+Plan and manage the production of computer hardware equipment.
+Develop and install software systems.
+Requirements:
+Bachelor?s degree in Computer Engineering, Computer Science or a relevant field.
+A minimum of 3 years? experience in a similar role.
+Strong knowledge of design analytics, algorithms, and measuring tools.
+Excellent verbal and written communication skills.
+A creative thinker with good analytical abilities.
+Proficient in problem-solving.

samples/jobs/data engineer.txt

@@ -0,0 +1,23 @@
+We are searching for an accountable, multitalented Data Engineer to facilitate the operations of our Data Scientists. The Data Engineer will be responsible for employing machine learning techniques to create and sustain structures that allow for the analysis of data, while remaining familiar with dominant programming and deployment strategies in the field. During various aspects of this process, you should collaborate with coworkers to ensure that your approach meets the needs of each project.
+
+To ensure success as a Data Engineer, you should demonstrate flexibility, creativity, and the capacity to receive and utilize constructive criticism. A formidable Data Engineer will demonstrate unsatiated curiosity and outstanding interpersonal skills.
+
+Data Engineer Responsibilities:
+Liaising with coworkers and clients to elucidate the requirements for each task.
+Conceptualizing and generating infrastructure that allows big data to be accessed and analyzed.
+Reformulating existing frameworks to optimize their functioning.
+Testing such structures to ensure that they are fit for use.
+Preparing raw data for manipulation by Data Scientists.
+Detecting and correcting errors in your work.
+Ensuring that your work remains backed up and readily accessible to relevant coworkers.
+Remaining up-to-date with industry standards and technological advancements that will improve the quality of your outputs.
+Data Engineer Requirements:
+Bachelor's degree in Data Engineering, Big Data Analytics, Computer Engineering, or related field.
+Master's degree in a relevant field is advantageous.
+Proven experience as a Data Engineer, Software Developer, or similar.
+Expert proficiency in Python, C++, Java, R, and SQL.
+Familiarity with Hadoop or suitable equivalent.
+Excellent analytical and problem-solving skills.
+A knack for independent and group work.
+Scrupulous approach to duties.
+Capacity to successfully manage a pipeline of duties with minimal supervision.

samples/jobs/full stack developer.txt

@@ -0,0 +1,26 @@
+We are looking for a highly skilled computer programmer who is comfortable with both front and back end programming. Full Stack Developers are responsible for developing and designing front end web architecture, ensuring the responsiveness of applications and working alongside graphic designers for web design features, among other duties.
+
+Full Stack Developers will be required to see out a project from conception to final product, requiring good organizational skills and attention to detail.
+
+Full Stack Developer Responsibilities:
+Developing front end website architecture.
+Designing user interactions on web pages.
+Developing back end website applications.
+Creating servers and databases for functionality.
+Ensuring cross-platform optimization for mobile phones.
+Ensuring responsiveness of applications.
+Working alongside graphic designers for web design features.
+Seeing through a project from conception to finished product.
+Designing and developing APIs.
+Meeting both technical and consumer needs.
+Staying abreast of developments in web applications and programming languages.
+Full Stack Developer Requirements:
+Degree in Computer Science.
+Strong organizational and project management skills.
+Proficiency with fundamental front end languages such as HTML, CSS and JavaScript.
+Familiarity with JavaScript frameworks such as Angular JS, React and Amber.
+Proficiency with server side languages such as Python, Ruby, Java, PHP and .Net.
+Familiarity with database technology such as MySQL, Oracle and MongoDB.
+Excellent verbal communication skills.
+Good problem solving skills.
+Attention to detail.

samples/jobs/full stack engineer.txt

@@ -0,0 +1,25 @@
+We are looking for an experienced Full Stack Engineer to join our development team. In this role, you will be responsible for the overall development and implementation of front and back-end software applications. Your responsibilities will extend from designing system architecture to high-level programming, performance testing, and systems integration.
+
+To ensure success as a Full Stack Engineer, you should have advanced programming skills, experience with application development, and excellent troubleshooting skills. Top-rated Full Stack Engineers create and implement advanced software systems that perfectly meet the needs of the company.
+
+Full Stack Engineer Responsibilities:
+Meeting with the software development team to define the scope and scale of software projects.
+Designing software system architecture.
+Completing data structures and design patterns.
+Designing and implementing scalable web services, applications, and APIs.
+Developing and maintaining internal software tools.
+Writing low-level and high-level code.
+Troubleshooting and bug fixing.
+Identifying bottlenecks and improving software efficiency.
+Collaborating with the design team on developing micro-services.
+Writing technical documents.
+Full Stack Engineer Requirements:
+Bachelor?s degree in Computer Engineering or Computer Science.
+Previous experience as a Full Stack Engineer.
+Advanced knowledge of front-end languages including HTML5, CSS, JavaScript, C++, and JQuery.
+Proficient in back-end languages including Java, Python, Rails, Ruby, .NET, and PHP.
+Knowledge of database systems and SQL.
+Advanced troubleshooting skills.
+Familiarity with JavaScript frameworks.
+Good communication skills.
+High-level project management skills.

samples/jobs/hadoop developer.txt

@@ -0,0 +1,25 @@
+We are looking to hire a skilled Hadoop Developer to help build Big Data infrastructure and storage software. Your primary responsibility will be to design, build, and maintain Hadoop infrastructure. You may also be required to evaluate existing data solutions, write scalable ETLs, develop documentation, and train staff.
+
+To ensure success as a Hadoop Developer, you should have in-depth knowledge of Hadoop API, high-level programming skills, and the ability to project manage. Ultimately, a top-class Hadoop developer designs and implements bespoke Hadoop applications to manage current and future Big Data infrastructures.
+
+Hadoop Developer Responsibilities:
+Meeting with the development team to assess the company?s Big Data infrastructure.
+Designing and coding Hadoop applications to analyze data collections.
+Creating data processing frameworks.
+Extracting data and isolating data clusters.
+Testing scripts and analyzing results.
+Troubleshooting application bugs.
+Maintaining the security of company data.
+Creating data tracking programs.
+Producing Hadoop development documentation.
+Training staff on application use.
+Hadoop Developer Requirements:
+Bachelor?s degree in Software Engineering or Computer Science.
+Previous experience as a Hadoop Developer or Big Data Engineer.
+Advanced knowledge of the Hadoop ecosystem and its components.
+In-depth knowledge of Hive, HBase, and Pig.
+Familiarity with MapReduce and Pig Latin Scripts.
+Knowledge of back-end programming languages including JavaScript, Node.js, and OOAD.
+Familiarity with data loading tools including Squoop and Flume.
+High-level analytical and problem-solving skills.
+Good project management and communication skills.

samples/jobs/sales application engineer.txt

@@ -0,0 +1,26 @@
+We are seeking a knowledgeable Sales Applications Engineer to create high-end applications that will increase our company's sales. In this role, your duties will include developing software applications, tracking consumer trends, and training our sales department on the technical specifications of applications. You will also be required to provide support to our clients.
+
+To ensure success as a Sales Applications Engineer, you should demonstrate extensive experience in application engineering, as well as in-depth knowledge of a sales environment. Outstanding Sales Applications Engineers ensure that their application expertise translates to product innovation and increased sales.
+
+Sales Applications Engineer Responsibilities:
+Performing analyses on software applications and services.
+Ensuring that product offerings and functionalities are aligned with consumer trends.
+Consulting with management and sales teams on product development.
+Performing application installations, updates, and maintenance.
+Training salespeople on product specifications and service offerings.
+Evaluating system performance metrics and improving front end functionality.
+Supporting clients with application installations, system optimization, and troubleshooting.
+Improving application functionality by incorporating client feedback.
+Reviewing product specifications and analyzing competitor behavior.
+Performing diagnostic tests and resolving logged errors.
+Sales Applications Engineer Requirements:
+A Bachelor's Degree in Software Engineering, Computer Engineering, Computer Science, Information Technology, or similar.
+Extensive experience in application engineering in a sales environment.
+Advanced proficiency in coding and scripting languages, such as C#, Python, Ruby, or JavaScript.
+Advanced knowledge of software application development, installation, and maintenance.
+Ability to liaise with management and the sales department on application development.
+Proficiency in training sales staff on product specifications and application functionalities.
+Exceptional ability to drive application innovation by analyzing consumer and competitor trends.
+Ability to evaluate client feedback and improve front end application functionality.
+Advanced ability to document processes, run diagnostic tests, and repair errors.
+Proficiency in providing clients with technical product and services support.