Upload 7 files

app.py

@@ -0,0 +1,34 @@
+import streamlit as st
+from sqlalchemy.orm import Session
+from sqlalchemy import select
+
+from models import Job, ENGINE
+
+
+def post_jobs() -> None:
+    with Session(ENGINE) as session:
+        stmt = select(Job)
+        jobs = session.scalars(stmt).all()
+    if jobs:
+        st.markdown("""<h1 style="font-family: Garamond;text-indent: 20px;color:#008DFE;">Submit your job applications today!</h1>""",unsafe_allow_html=True)
+        st.caption(f"""<p style="color:red;">Create your profile and start applying for jobs today. We eagerly anticipate the opportunity to collaborate with you!<p>""",unsafe_allow_html=True)
+    else:
+        st.caption(f"""<p style="color:red;">There are currently no available job vacancies. Please check back later. We are eagerly anticipating the opportunity to begin working together.<p>""",unsafe_allow_html=True)
+
+    for job in jobs:
+        with st.expander(f"{job.job_id}: {job.post_name}"):
+            st.markdown(f"""<p style="font-family:'Garamond'"><b>Description</b>:
+                            <br>{job.description}<br><br>
+                            <b>Experience</b>:
+                            <br>{job.min_experience} - {job.max_experience} year(s)<br><br>
+                            <b>Responsibilities</b>:
+                            <br>{job.responsibilities}<br><br>
+                            <b>Primary Skills</b>:<br>
+                            {job.primary_skills}</p>""",unsafe_allow_html=True)
+            if job.secondary_skills:
+                st.markdown(f"""<p style="font-family:'Garamond'"><b>Secondary Skills</b>:
+                            <br>{job.secondary_skills}</p>""",unsafe_allow_html=True)
+            st.markdown(f"""<p style="font-family:'Garamond'"><b>Apply before</b>:
+                            <br>{job.expires_at}</p>""",unsafe_allow_html=True)
+
+post_jobs()

llm.py

@@ -0,0 +1,68 @@
+import pathlib
+import ast
+import os
+from pypdf import PdfReader
+import docx2txt
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+import openai
+import cohere
+from models import Job, ENGINE
+openai.api_key = os.environ["OPEN_API_KEY"]
+co = cohere.Client(os.environ["COHERE_API_KEY"])
+def gpt(user_query):
+    response = openai.Completion.create(
+                                        engine="text-davinci-003",
+                                        prompt = user_query,
+                                        max_tokens=1024,
+                                        n=1,
+                                        stop=None,
+                                        temperature=0.5,
+                                    )
+    return response['choices'][0]['text']
+
+
+def parse_pdf(file_name):
+  reader = PdfReader(file_name)
+  page = reader.pages[0]
+  resume_text = page.extract_text()
+
+  
+
+  return resume_text
+
+
+def parse_docx(file_name):
+    file_text = docx2txt.process(file_name)
+    return file_text
+
+# def get_dict(resume_text):
+#     resume_dict = ast.literal_eval(gpt(f"""parse the resume and convert it into a Python string with the headings as "experience," "skills," "certifications," and "education".
+
+#                         resume: "{resume_text}"
+#                         resume_dict: """).strip())
+#     return resume_dict
+
+def parse(filename):
+    resume_file = pathlib.Path(filename)
+    text = parse_pdf(resume_file) if resume_file.suffix == ".pdf" else parse_docx(resume_file)
+    print("parse"+"~"*10,text)
+    # dct = get_dict(text)
+    # print(dct)
+    return text
+
+def rerank(job_id,docs,top_n):
+    with Session(ENGINE) as session:
+        stmt = select(Job).where(Job.job_id == job_id)
+        job = session.scalars(stmt).one()
+    
+    post = job.post_name
+    
+    response = co.rerank(
+    model = 'rerank-english-v2.0',
+    query = f'Which profile suits most for the role of {post}?',
+    documents = docs,
+    top_n = top_n,
+    )
+    print(response)
+    return response

models.py

@@ -0,0 +1,86 @@
+from typing import List
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+from sqlalchemy import ForeignKey, create_engine
+
+
+ENGINE = create_engine('sqlite:///application_dev.db')
+
+class Base(DeclarativeBase):
+    pass
+
+class Employee(Base):
+    __tablename__ = 'employees'
+    employee_id: Mapped[str] = mapped_column(primary_key = True)
+    email_id: Mapped[str] = mapped_column(unique = True,nullable = False)
+    first_name: Mapped[str] = mapped_column(nullable = True)
+    last_name: Mapped[str] = mapped_column(nullable = True)
+    password: Mapped[str]
+    department: Mapped[str]
+    # jobs_posted: Mapped[list["Job"]] = relationship(back_populates="jobs")
+
+    def __repr__(self):
+        return f'Employee({self.employee_id!r},{self.email_id!r},{self.first_name!r},{self.department!r})'
+
+    @property
+    def full_name(self):
+        return f'{self.first_name.title()} {self.last_name.title()}'
+
+
+class Job(Base):
+    __tablename__ = 'jobs'
+    job_id :Mapped[str] = mapped_column(primary_key = True)
+    employee_id :Mapped[str] #= mapped_column(ForeignKey('employees.employee_id'))
+    post_name: Mapped[str] = mapped_column(nullable = False)
+    description: Mapped[str] = mapped_column(nullable= False)
+    responsibilities: Mapped[str]
+    min_experience: Mapped[int] = mapped_column(nullable = False)
+    max_experience: Mapped[int] = mapped_column(nullable = False)
+    primary_skills: Mapped[str] = mapped_column(nullable = False)
+    secondary_skills: Mapped[str] = mapped_column(nullable = True)
+    vacancies: Mapped[int] = mapped_column(nullable=False)
+    # employee: Mapped["Employee"] = relationship(back_populates="employee")
+    # users_applied: Mapped[list["User"]] = relationship(back_populates="users")
+    created_at: Mapped[str] = mapped_column(nullable=False)
+    expires_at: Mapped[str] = mapped_column(nullable = False)
+
+    def __repr__(self):
+        return f"Job({self.job_id!r},{self.post_name!r},{self.min_experience},{self.max_experience})"
+
+
+class User(Base):
+    __tablename__ = "users"
+    email_id: Mapped[str] = mapped_column(primary_key=True)
+    password: Mapped[str] = mapped_column(nullable=False)
+    first_name: Mapped[str] = mapped_column(nullable = False)
+    last_name: Mapped[str] = mapped_column(nullable = False)
+
+    def __repr__(self):
+        return f'User({self.email_id!r},{self.first_name!r},{self.last_name!r})'
+
+    @property
+    def full_name(self):
+        return f'{self.first_name.title()} {self.last_name.title()}'
+
+      
+
+class JobsApplied(Base):
+    __tablename__ = 'jobs_applied'
+    email_id: Mapped[str] = mapped_column(primary_key=True)
+    job_id: Mapped[str] = mapped_column(ForeignKey('jobs.job_id'))
+    rank: Mapped[int] = mapped_column(nullable=False)
+    experience: Mapped[int] = mapped_column(nullable=False)
+    round_number: Mapped[int] = mapped_column(nullable=False)
+    primary_skills: Mapped[int]
+    secondary_skills: Mapped[int]
+    
+
+    def __repr__(self):
+        return f'JobsApplied({self.email_id!r},{self.job_id!r},{self.rank},{self.experience},{self.round_number})'
+
+
+
+
+def __create_tables():
+    Base.metadata.create_all(bind = ENGINE)
+
+

pages/Careers.py

@@ -0,0 +1,259 @@
+import pathlib
+import re
+from typing import Union
+import os
+import ast
+
+import streamlit as st
+import sqlalchemy
+from sqlalchemy.orm import Session
+from sqlalchemy import select
+import openai
+
+from models import User, Job, JobsApplied, ENGINE
+from llm import gpt
+
+openai.api_key = os.environ['OPEN_API_KEY']
+def clear_cache():
+    for k in st.session_state:
+        del st.session_state[k]
+
+def add_user_to_db():
+    col1, col2 = st.columns(2)
+    with col1:
+        first_name = st.text_input(label = "First Name", placeholder="First Name").title().strip()
+    with col2:
+        last_name = st.text_input(label = "Last Name", placeholder="last Name").title().strip()
+    email_id = st.text_input(label = "Email ID", placeholder = "Enter Email ID").strip()
+    new_password = st.text_input(label = "New Password",placeholder="New Password", type = "password").strip()
+    confirm_password = st.text_input(label = "Password",placeholder="New Password", type = "password").strip()
+    col1, col2, col3 = st.columns(3)
+    with col3:
+        if st.button("Back", key="Mistake"):
+            clear_cache()
+    with col1:
+
+        if st.button("Create Profile"):
+                if new_password != confirm_password:
+                    st.error("Passwords do not match")
+                    return 
+                
+                if not(first_name and last_name and email_id and new_password):
+                    st.error("No text fields must be blank!")
+                    return
+                    
+
+
+                if re.search('^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$',email_id) is None:
+                    st.error("Invalid Email ID")
+                    return
+
+                with Session(ENGINE) as session:
+                    stmt = select(User).where(User.email_id == email_id)
+                    result = session.scalars(stmt).one_or_none()
+                    if result is not None:
+                        st.error("User already exists!")
+                    else:
+                        user_object = User(email_id = email_id, password = new_password,
+                                            first_name  = first_name, last_name = last_name)
+                        session.add_all([user_object])
+                        session.commit()
+                        st.success("Successfully Created!")
+                        clear_cache()
+                        return 
+
+        
+        
+    
+    
+    
+def login() -> None:
+    
+    login_container = st.empty()
+    with login_container.container():
+        email_id = st.text_input(label=":email: Email ID", placeholder = "Email ID").lower().strip()
+        password = st.text_input(label = ":lock: Password", placeholder = "Password", type = "password")
+        col1, col2,col3,col4, = st.columns(4)
+        with col4:
+            if st.button("Sign Up"):
+                st.session_state['sign_up_clicked'] = True
+                
+        with col1:
+            sign_in = st.button("Sign In")
+        if sign_in:
+                
+            with Session(ENGINE) as session:
+                stmt = select(User).where(User.email_id == email_id).where(User.password == password)
+                user = session.scalars(stmt).one_or_none()
+                if user is None:
+                    st.error("Invalid email ID/password")
+                else:
+                    st.session_state['user_logged'] = True
+                    st.session_state['user'] = user
+
+    if st.session_state['sign_up_clicked']:
+        login_container.empty()
+        add_user_to_db()
+        return
+               
+    
+    if st.session_state['user'] is not None:
+        login_container.empty()
+
+
+def add_to_db(**job_applied):
+    with Session(ENGINE) as session:
+        obj = JobsApplied(**job_applied)
+        session.add_all([obj])
+        
+        session.commit()
+        
+def apply_for_jobs():
+    
+    with Session(ENGINE) as session:
+        stmt = select(Job)
+        jobs = session.scalars(stmt).all()
+    job_container = st.empty()
+    with job_container.container():
+        col1, col2 = st.columns(2)
+        with col1:
+            job_id = st.selectbox(label="Job ID", options = [job.job_id for job in jobs]) 
+        with col2:
+            post_name = st.text_input(label="Post",value = [job.post_name for job in jobs if job.job_id == job_id][-1], disabled=True) 
+        experience = st.number_input(label = 'Expereince',min_value=0)
+        col1, col2 = st.columns(2)
+        with col1:
+            primary_skills = st.text_input(label="Primary Skills",placeholder="Primary Skills", help="Input your skills delimited by a comma").lower().strip()
+        with col2:
+            secondary_skills =  st.text_input(label="Secondary Skills",placeholder="Secondary Skills", help="Input your skills delimited by a comma").lower().strip()
+        
+        uploded_file = st.file_uploader(label = "Resume Upload", type = ["pdf","docx"])
+        
+        col1, col2 = st.columns(2)
+        with col2:
+            
+            if st.button("Apply"):
+                st.session_state['applied_for_job'] = True
+    
+    if st.session_state['applied_for_job']:
+        if uploded_file is None:
+            st.error("No Resume Uploaded")
+            return False
+        
+        with Session(ENGINE) as session:
+            stmt = select(JobsApplied).where(JobsApplied.email_id == st.session_state['user'].email_id)
+            res = session.scalars(stmt).one_or_none()
+            if res is not None:
+                st.info("You have already applied for job")
+                return False
+            stmt = select(Job).where(Job.job_id == job_id)
+            selected_job = session.scalars(stmt).one()
+        
+        if st.session_state['applied_for_job'] and not(selected_job.min_experience <= experience <= selected_job.max_experience):
+            return False
+        
+        
+        resumes_dir = pathlib.Path(f'resumes/{job_id}')
+        resumes_dir.mkdir(exist_ok = True)
+        resume = resumes_dir / f"{st.session_state['user'].email_id} - {st.session_state['user'].full_name}"
+        resume.touch()
+        resume.write_bytes(uploded_file.read())
+    
+        
+        add_to_db(**{"email_id": st.session_state["user"].email_id,
+                    "job_id": job_id, 'experience': experience,
+                    'primary_skills': primary_skills,
+                    'secondary_skills':secondary_skills,
+                    'round_number': 0, 'rank': -1})
+        return True
+        
+        
+        
+def jobs_applied():
+    with Session(ENGINE) as session:
+        stmt = select(JobsApplied).where(JobsApplied.email_id == st.session_state['user'].email_id)
+        jobs_applied = session.scalars(stmt).all()
+
+    if jobs_applied:
+        for job_applied in jobs_applied:
+            with st.expander(f'Job ID: {job_applied.job_id} Round Number: {job_applied.round_number}'):
+                if job_applied.round_number > 0:
+                    temporary = st.empty()
+                    with temporary.container():
+                        get_interview_questions(job_applied.job_id)
+                    temporary.empty()
+                    st.markdown(f'<p style="font-family:Garamond">You will be notified about the result</p>',unsafe_allow_html=True)
+
+                    if not(st.session_state['rank']) >= 7:
+                        with Session(ENGINE) as session:
+                            session.delete(job_applied)
+                    
+
+
+
+
+
+def get_interview_questions(job_id):
+    with Session(ENGINE) as session:
+        stmt = select(Job).where(Job.job_id == job_id.strip())
+        job = session.scalars(stmt).one_or_none()
+    
+    if job is not None:
+        lst = gpt(f"Generate a set of 10 multiple-choice questions (MCQs) based on the subject of {job.post_name} with experience between {job.min_experience} - {job.max_experience} years.Return it as a list of dictionaries with question as key and optionaand correct answer as kets")
+        st.write(f"{lst!r}")
+        mcqs = ast.literal_eval(lst.strip())
+        rank = 0
+        for index, mcq in enumerate(mcqs,start=1):
+            question = mcq["question"] if 'question' in mcq.keys() else mcq["Question"]
+            options = mcq["options"] if 'options' in mcq.keys() else mcq["Options"]
+            correct_answer = mcq["correct_answer"] if 'correct_answer' in mcq.keys() else mcq["Correct Answer"]
+            answer = st.radio(f'Q{index} {question}',key=mcq,options=answer)
+            if answer.strip() == correct_answer.strip():
+                rank += 1
+        if st.button('Submit'):
+            st.session_state['rank'] = rank
+    return st.session_state['rank']
+
+                       
+        
+
+
+
+    
+    
+
+    
+    
+
+
+
+    
+
+
+
+
+
+if 'sign_up_clicked' not in st.session_state:
+    st.session_state['sign_up_clicked'] = False
+if 'user_logged' not in st.session_state:
+    st.session_state['user_logged'] = False
+if 'user' not in st.session_state:
+    st.session_state['user'] = None
+if 'applied_for_job' not in st.session_state:
+    st.session_state['applied_for_job'] = False
+
+if 'rank' not in st.session_state:
+    st.session_state['rank'] = False
+
+
+
+login()
+if st.session_state['user_logged']:
+    col1, col2 = st.columns(2)
+    with col2:
+        st.button('Log Out',on_click=clear_cache)
+    tab1, tab2= st.tabs(["Apply Jobs","Place Holder"])
+    with tab1:
+        apply_for_jobs()
+    with tab2:
+        jobs_applied()

pages/Employee.py

@@ -0,0 +1,324 @@
+import os
+import random
+from datetime import datetime, timedelta
+from typing import Union
+import pathlib
+import smtplib
+from email.message import EmailMessage
+import streamlit as st
+from sqlalchemy.orm import Session
+from sqlalchemy import select
+
+from models import Employee, Job , JobsApplied,User, ENGINE
+from llm import parse, rerank
+
+
+
+st.markdown("""-
+   <style>
+    
+    .stButton > button{
+    border: black;    
+    box-shadow: 0 12px 16px 0 rgba(0,0,0,0.24), 0 17px 50px 0 rgba(0,0,0,0.19);
+    }
+</style>""",unsafe_allow_html=True)
+
+def clear_cache():
+    for k in st.session_state:
+        del st.session_state[k]
+
+def login() -> Union[Employee,None]:
+    login_container = st.empty()
+    with login_container.container():
+        employee_id = st.text_input(label=":email: User ID", placeholder = "User ID").upper().strip()
+        password = st.text_input(label = ":lock: Password", placeholder = "Password", type = "password")
+        button = st.button('Login', type = "secondary")
+
+        if button:
+            if employee_id and password:
+                with Session(ENGINE) as session:
+                    stmt = select(Employee).where(Employee.employee_id == employee_id).\
+                        where(Employee.password == password)
+                    employee = session.scalars(stmt).one_or_none()
+                    print(employee)
+                    
+                if employee is None:
+                    st.error('Invalid UserID/password')
+                    return
+                
+                st.session_state['employee_logged'] = True
+                st.session_state['employee'] = employee
+                login_container.empty()
+                
+                return employee
+            else:
+                st.error('Empty UserID/Password')
+
+
+def add_to_db(**job) -> None:
+    
+    job_id = ''.join(chr(random.randint(65,90)) for i in range(5))+f'{random.randint(100,1000)}'
+    job['job_id'] = job_id
+    job['employee_id'] = st.session_state["employee"].employee_id
+    job['created_at'] = datetime.now().strftime("%d-%m-%Y %H:%M:%S")
+    job['primary_skills'] = ', '.join(job['primary_skills'])
+    job['secondary_skills'] = ', '.join(job['secondary_skills'])
+    
+    
+    with Session(ENGINE) as session:
+        job_object = Job(**job)
+        session.add_all([job_object])
+        session.commit()
+        st.success(f"Successfully posted job {job['post_name']}!")
+
+
+def add_job() -> None:
+    post_name = st.text_input(label = 'Post Name').strip().title()
+    description = st.text_area(label = 'Job Description').strip()
+    responsibilities = st.text_area(label = "Responsibility").strip()
+    vacancies = st.number_input(label="Number Vacancies",min_value=1)
+    col1, col2 = st.columns(2)
+    with col1:
+        min_experience = st.number_input(label = "Minimum Experience",min_value = 0, )
+    with col2:
+        max_experience = st.number_input(label = "Maximum Experience",min_value = 1, )
+    number_of_primary_skills = st.number_input(label = "How many primary skills?",min_value = 1, )
+    primary_skills = [st.text_input(label = f'Primary Skill {i}',key=f'Primary Skill {i}').strip() for i in range(1,number_of_primary_skills+1)]
+    number_of_secondary_skills = st.number_input(label = "How many secondary skills?",min_value = 0, )
+    secondary_skills = [st.text_input(label = f'Secondary Skill {i}',key=f'Secondary Skill {i}').strip() for i in range(1,number_of_secondary_skills+1)]
+    st.markdown("Expires at")
+    col1, col2 = st.columns(2)
+    with col1:
+        expires_date = st.date_input(label = "expries date",value =datetime.now() + timedelta(days = 1), min_value = datetime.now() + timedelta(days = 1), max_value=None, label_visibility="collapsed")
+        print(expires_date )
+    with col2:
+        expires_time = st.time_input(label = "Time Input", label_visibility="collapsed")
+        print(expires_time)
+    expires_at = f'{expires_date.strftime("%d-%m-%Y")} {expires_time.strftime("%H:%M:%S")}'
+    st.markdown("<p style='color: red'>⚠️ Check before you submit once submitted you cannot make changes</p>", unsafe_allow_html=True)
+    if st.button("Post"):
+        if (post_name and description and responsibilities and primary_skills):
+            if min_experience <= max_experience:
+                job = {
+                    "post_name" : post_name, 'description': description,'min_experience': min_experience,'max_experience': max_experience,
+                    'primary_skills': primary_skills, 'secondary_skills': secondary_skills,'responsibilities':responsibilities,
+                    'expires_at': expires_at, 'vacancies': vacancies
+
+                }
+            
+
+                add_to_db(**job)
+                return True
+            st.error("Minimum Experience must be less than maximum experience")
+            return
+        st.error("Post Name/Description/Responsibility/Primary SKills are required")
+    
+           
+
+def post_job():
+    st.session_state['employee']
+    st.session_state['employee_logged']
+    if st.session_state['employee_logged']:
+        col1, col2 = st.columns([0.001, 0.01])
+        with col2:
+            st.markdown(f'Would you like to include a job vacancy listing. {st.session_state["employee"].full_name}?')
+        with col1:
+            if st.button(':heavy_plus_sign:'):
+                st.session_state['add_job'] = True
+        
+        if st.session_state['add_job']:
+            add_job_container = st.empty()
+            with add_job_container.container():
+                is_job_posted = add_job()
+            if is_job_posted:
+                add_job_container.empty()
+        
+
+def  get_jobs_posted() -> None:
+    with Session(ENGINE) as session:
+        stmt = select(Job).where(Job.employee_id == st.session_state["employee"].employee_id)
+        jobs = session.scalars(stmt).all()
+    print(jobs)
+    for job in jobs:
+        with st.expander(f"{job.job_id}: {job.post_name} posted at: {job.created_at}"):
+            pass
+    
+
+
+def get_users_who_applied_for_jobs():
+    
+    #Get Jobs Posted
+    with Session(ENGINE) as session:
+        stmt = select(Job).where(Job.employee_id == st.session_state["employee"].employee_id)
+        jobs = session.scalars(stmt).all()
+    
+    if not jobs:
+        st.info("No jobs posted!")
+        return
+    
+    job_id = st.selectbox("Filter by job_id",options=[job.job_id for job in jobs])
+    
+
+    
+    with Session(ENGINE) as session:
+        stmt = select(JobsApplied).where(JobsApplied.job_id == job_id)
+        users_applied_for_jobs = session.scalars(stmt).all()
+        
+        if not users_applied_for_jobs:
+            st.info('No users have applied for job')
+            return False
+        
+        re_rank_resumes_container = st.empty()
+        with re_rank_resumes_container.container():
+            st.markdown("""<p style="font-family:Garamond;text-indent: 45vh;font-size:25px">Jobs Application Details</p>""",unsafe_allow_html=True)
+            col1, col2 = st.columns([0.001, 0.01])
+            with col1:
+                round_number = users_applied_for_jobs[0].round_number 
+                st.markdown(f"""<p style="font-size:20px"><span style = "font-family:Garamond;">Round</span><span style="font-family:monospace;padding: 10px 20px">{round_number}</span></p>""", unsafe_allow_html=True)
+            with col2:
+                num_docs = st.number_input(label="Top Resumes",min_value=1, max_value=len(users_applied_for_jobs))
+            for jobs_application in users_applied_for_jobs:
+                st.markdown(f"""<p style="border: 2px solid black;padding: 10px 20px; box-shadow: 10px 10px 5px #aaaaaa"><span style="font-family:Garamond;">User Email ID</span>: <span style="font-family:monospace">{jobs_application.email_id}</span><br><span style="font-family:Garamond">Current Rank: <span style="font-family:monospace">{jobs_application.rank}</span></p>""",unsafe_allow_html=True)
+            col1,col2, col3 = st.columns(3)
+            with col2:
+                if st.button("Rank Resumes"):
+                    st.session_state['rank_resumes'] = True
+        
+        #Ranking Resumes
+        if st.session_state['rank_resumes']:
+            re_rank_resumes_container.empty()
+            docs = get_docs(users_applied_for_jobs,job_id)
+            re_ranked = rerank(job_id,docs,num_docs)
+            candidates = [r.document['text'].split('-'*50)[0].strip() for r in re_ranked.results]
+            st.markdown(f"<p style='font-family:Garamond;text-indent: 45vh;font-size:25px'>Resumes re-ranked:</p>",unsafe_allow_html=True)
+            for candidate in candidates:
+                st.markdown(f"""<p style="border: 2px solid black;padding: 10px 20px; box-shadow: 10px 10px 5px #aaaaaa"><span style="font-family:Garamond;">User Email ID</span>: <span style="font-family:monospace">{candidate}</span></p>""",unsafe_allow_html=True)
+            col1,col2, col3 = st.columns(3)
+            with col2:
+                if st.button("Send Emails"):
+                    st.session_state['send_resumes']  = True
+            if  st.session_state['send_resumes']:
+                    add_job_aplication_details(job_id,round_number,candidates)
+        
+            
+def add_job_aplication_details(job_id,round_number,candidates):
+    def update(job_application):
+        print('----------------------------------------4')
+        job_application.round_number += 1
+        job_application.rank = job_application.round_number
+        return job_application
+   
+    
+
+    with Session(ENGINE) as session:
+        stmt =  select(JobsApplied).where(JobsApplied.job_id == job_id).where(JobsApplied.email_id.not_in(candidates))
+        jobs = session.scalars(stmt).all()
+        for job in jobs: 
+            session.delete(job)
+        session.commit()
+        print('deleted')
+    with Session(ENGINE) as session:
+        stmt =  select(JobsApplied).where(JobsApplied.job_id == job_id).where(JobsApplied.email_id.in_(candidates))
+        jobs = session.scalars(stmt).all()
+        for job in jobs: 
+            update(job)
+        session.commit()
+        print('updated')
+    sending_emails(job_id, candidates)
+        
+def sending_emails(job_id, candidates):
+    email_message = EmailMessage()
+    email_message['From'] = st.session_state['employee'].email_id
+    email_message['To'] = candidates
+    email_message['Subject'] = f'You are selected for Job ID: {job_id}.'
+    email_message.set_content('Hello,\nYou are selected to attend the interview. Please login to your profile and attend.')
+    with smtplib.SMTP_SSL('smtp.gmail.com',465) as smtp:
+        # st.write(os.environ['EMAIL'])
+        smtp.login(st.session_state['employee'].email_id, os.environ['EMAIL'])
+        smtp.send_message(email_message)
+    st.success(f'⚠️Email Sent SUccessfully')
+
+        
+
+            
+def get_docs(jobs_applications,job_id):
+    docs = []
+    print(f'resumes/{job_id}')
+    resumes_dir = pathlib.Path(f'resumes/{job_id}')
+    
+
+    for resume in resumes_dir.iterdir():
+        print(resume)
+        parsed_text = parse(resume)
+        print(parsed_text)
+        print('---------------------------------------------------------------------------')
+        email_id = resume.stem.split('-')[0]
+        text = f"{email_id}"+'-'*50+parsed_text
+        docs.append(text)
+    return docs
+    
+        
+
+
+
+
+        
+
+
+
+print('Before settings')
+
+# Setting Session states
+if 'employee_logged' not in st.session_state:
+    st.session_state['employee_logged'] = False
+if 'employee' not in st.session_state:
+    st.session_state['employee'] = None
+if 'add_job' not in st.session_state:
+    st.session_state['add_job'] = False
+
+if 'add_new_skill' not in st.session_state:
+    st.session_state['add_new_skill'] = False
+
+if 'rank_resumes' not in st.session_state:
+    st.session_state['rank_resumes'] = False
+
+if 'rank_resumes' not in st.session_state:
+    st.session_state['rank_resumes'] = False
+
+if 'send_resumes' not in st.session_state:
+    st.session_state['send_resumes'] = False
+
+
+
+
+
+
+
+
+
+
+
+print('script start')
+
+#Login
+
+
+if not st.session_state['employee_logged']:
+    employee = login()
+
+
+if st.session_state['employee_logged']:
+    col1, col2 = st.columns(2)
+    with col2:
+        st.button('Log Out',on_click=clear_cache)
+            
+
+    tab1, tab2, tab3 = st.tabs(["Post Jobs","Jobs Posted","Get Job Applied Details"])
+    with tab1:
+        post_job()
+    with tab2:
+        get_jobs_posted()
+    with tab3:
+        get_users_who_applied_for_jobs()
+
+

requirements.txt

@@ -0,0 +1,6 @@
+streamlit==1.25.0
+sqlalchemy==2.0.19
+cohere
+openai
+pypdf
+docx2txt