main code

src/streamlit_app.py

@@ -1,13 +1,536 @@
 import os
-import time
 import json
+import time
 import pytz
 import PyPDF2
 import requests
 import streamlit as st
+
 from agno.agent import Agent
+from phi.utils.log import logger
 from phi.tools.zoom import ZoomTool
 from agno.tools.email import EmailTools
 from datetime import datetime, timedelta
 from agno.models.openai import OpenAIChat
-from typing import Literal, Tuple, Dict, Optional
+from streamlit_pdf_viewer import pdf_viewer
+from typing import Literal, Tuple, Dict, Optional
+
+# Class for controlling zoom access
+class CustomZoomTool(ZoomTool):
+    def __init__(self, *, account_id: Optional[str] = None, client_id: Optional[str] = None,
+             client_secret: Optional[str] = None, name: str = "zoom_tool"):
+        super().__init__(account_id=account_id, client_id=client_id, client_secret=client_secret, name=name)
+        self.token_url = "https://zoom.us/oauth/token"
+        self.access_token = None
+        self.token_expires_at = 0
+        
+# This method fetches and returns a valid Zoom access token, either from cache or by making an API call.
+    def get_access_token(self) -> str:
+        # If token exists and hasn't expired, return it (avoids unnecessary API calls).
+        if self.access_token and time.time() < self.token_expires_at:
+            return str(self.access_token)
+        # Sets up headers and payload for the Zoom OAuth token request.
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+        data = {
+            "grant_type": "account_credentials", 
+            "account_id": self.account_id
+            }
+        # Makes a POST request to Zoom's token endpoint using the client secret for authentication.
+        try:
+            resp = requests.post(
+                self.token_url, 
+                headers= headers, 
+                data = data, 
+                auth = (self.client_secret)
+            )
+            
+            resp.raise_for_status()
+            
+            token_info = resp.json()
+            
+            self.access_token = token_info["access_token"]
+            expires_in = token_info["expires_in"]
+            self.token_expires_at = time.time() + expires_in + 60
+            
+            self._set_parent_token(str(self.access_token))
+            return str(self.access_token)
+        # Logs and safely handles any network or response issues.
+        except requests.RequestException as e:
+            logger.error(f"Error Fetching access token: {e}")
+            return ""
+    
+    def _set_parent_token(self, token: str) -> None:
+        """
+        Helper Function to set the token in parent ZoomTool class
+        """
+        if token:
+            self._ZoomTool_access_token = token
+            
+# ROLE Requirements as a constant dictionary
+
+ROLE_REQUIREMENTS: Dict[str, str] = {
+    "ai_ml_engineer": """
+        Required Skills:
+        - Python, Pytorch/Tensorflow
+        - Machine Learning Algorithms and Frameworks
+        - Deep Learning and Neural Networks
+        - Data Preprocessing and Analysis
+        - MLOps and Model Deployment
+        - RAG, LLMs, Finetuning and Prompt Engineering
+    """,
+    "frontend_engineer":"""
+        Required Skills:
+        - React/Vue.js/Angular
+        - HTML5, CSS3, JavaScript/TypeScript
+        - Responsive Design
+        - State Management
+        - Frontend Testing
+    """,
+    "backend_engineer": """
+        Required Skills:
+        - Python/Java/Node.js
+        - REST APIs
+        - Database Design and Management
+        - System Architecture
+        - Cloud Services (AWS/GCP/Azure)
+        - Kubernetes, Docker, CI/CD
+    """
+}
+
+#  safely initialize only the required keys in st.session_state with default values, preventing errors during use in a Streamlit app.
+def init_session_state() -> None:
+    """Initialize only the necessary session state variables."""
+    defaults = {
+        "candidate_email": "",
+        "openai_api_key" : "",
+        "resume_text": "",
+        "analysis_complete": False,
+        "is_selected": False,
+        "zoom_account_id": "",
+        "zoom_client_id": "",
+        "zoom_client_secret": "",
+        "email_sender": "",
+        "email_passkey": "",
+        "company_name": "",
+        "current_pdf": None
+    }
+    
+    for key, value in defaults.items():
+        if key not in st.session_state:
+            st.session_state[key] = value
+            
+# This function returns a function if the API is already initialized
+def create_resume_analyzer() -> Agent:
+    """Creates and returns a resume analysis agent"""
+    if not st.session_state.openai_api_key:
+        st.error("Please enter your OpenAI API Key before procedding!")
+        return None
+    return Agent(
+        model = OpenAIChat(id="gpt-4.1-nano", api_key = st.session_state.openai_api_key),
+        description = "You are a expert Technical Recruiter who analyzes resumes",
+        instructions=[
+            "Analyze the resume against the provided job requirements",
+            "Be linient with AI/ML candidates who show strong potential",
+            "Consider project experience as valid experience",
+            "Value hands-on-experience with key technologies",
+            "Return the result in a JSON response with selection decision and feedback"
+        ],
+        markdown=True
+    )
+    
+def create_email_agent() -> Agent:
+    return Agent(
+        model = OpenAIChat(
+            id = "gpt-4.1-nano",
+            api_key=st.session_state.openai_api_key
+        ),
+        description="You are a expert technical recruiter coordinator handling email communications.",
+        instructions=[
+            "Draft and send professional recruitment emails",
+            "Act like a huma writing an email and eliminate unnecessary capital letters",
+            "Maintain a friendly yet professional tone",
+            f"Always end the mail with exactly: 'Best Regards\nTeam HR at {st.session_state.company_name}",
+            "Never include the sender's or receiver's name in the signature",
+            f"The name of the company is {st.session_state.company_name}"
+        ],
+        markdown=True, 
+        show_tool_calls=True
+    )
+
+def create_scheduler_agent() -> Agent:
+    zoom_tools = CustomZoomTool(
+        account_id = st.session_state.zoom_account_id,
+        client_id = st.session_state.zoom_client_id,
+        client_secret = st.session_state.zoom_client_secret
+    )
+    
+    return Agent(
+        name = "Interview Scheduler",
+        model = OpenAIChat(
+            id = "gpt-4o-mini",
+            api_key = st.session_state.openai_api_key
+        ),
+        tools = [zoom_tools],
+        description = "You are an interview scheduling coordinator",
+        instructions = [
+            "You are an expert at scheduling technical interviews using zoom",
+            "Schedule interviews during business hours (9AM - 5PM IST)",
+            "Create meetings with proper titles and descriptions",
+            "Ensure all meeting details are included in responses",
+            "Use ISO 8601 format for dates",
+            "Handle scheduling errors gracefully"
+        ],
+        markdown=True,
+        show_tool_calls=True
+    )
+    
+def extract_text_from_pdf(pdf_file) -> str:
+    try:
+        pdf_reader = PyPDF2.PdfReader(pdf_file)
+        text = ""  # Initialize the variable here
+        for page in pdf_reader.pages:
+            page_text = page.extract_text()
+            if page_text:  # Some pages may return None
+                text += page_text
+        return text
+    except Exception as e:
+        st.error(f"Error while parsing PDF File: {str(e)}")
+        return ""
+
+
+def analyze_resume(resume_text: str, 
+                   role: Literal["ai_ml_engineer", "frontend_engineer", "backend_engineer"],
+                   analyzer: Agent) -> Tuple[bool, str]:
+    try:
+        resp = analyzer.run(
+            f"""Please analyze this resume against the following requirements and provide your response in valid JSON format:
+            Role Requirements:
+            {ROLE_REQUIREMENTS[role]}
+            Resume Text:
+            {resume_text}
+            
+            Your response must be a valid JSON object, just like this:
+            {{
+                "selected": true,
+                "feedback": "The resume shows strong alignment with the AI/ML Engineer role, particularly in TensorFlow and Python.",
+                "matching_skills": ["Python", "TensorFlow", "Scikit-learn"],
+                "missing_skills": ["Kubernetes", "Docker"],
+                "experience_level": "mid"
+            }}
+            
+            Evaluation Criteria:
+            1. Match at least 70% of required skills.
+            2. Consider both theoritical knowledge and pratical knowledge.
+            3. Value project experience and real-world applications.
+            4. Consider transferrable skills from similar technologies.
+            5. Look for evidence for continuous learning and adaptability.
+            Important: Return ONLY the JSON object without any formatting or backticks.
+            """
+        )
+        
+        assistant_message = next((msg.content for msg in resp.messages if msg.role == "assistant"), None)
+        
+        if not assistant_message:
+            raise ValueError("No assistant message found in the response")
+        result = json.loads(assistant_message.strip())
+        if not isinstance(result, dict) or not all(k in result for k in ["selected", "feedback"]):
+            raise ValueError("Invalid Response Format")
+        return result["selected"], result["feedback"]
+    except (json.JSONDecodeError, ValueError) as e:
+        st.error(f"Error, while decoding JSON or due to format: {str(e)}")
+        return False, f"Error while analyzing resume: {str(e)}"
+
+def send_selection_email(email_agent: Agent, to_email: str, role: str) -> None:
+    """
+    Send a selection email with a congratuations.
+    """
+    email_agent.run(
+        f"""
+        Send an email to {to_email} regarding their selection for the {role} position.
+        The email should:
+        1. Congratulate them on being selected.
+        2. Explain the next steps in the process.
+        3. Mention that they will receive interview details shortly.
+        4. The name of the company is {st.session_state.company_name}.
+        """
+    )
+
+def send_rejection_email(email_agent: Agent, to_email : str, role : str, feedback : str) -> None:
+    """
+    Send a rejection mail with constructive feedback
+    """
+    email_agent.run(
+        f"""
+        Send an email to {to_email} regarding their application for the {role} position.
+        Use this specific style:
+        1. Avoid unnecessary capital letters.
+        2. Be empathetic and human
+        3. Mention specific feedback from: {feedback}
+        4. Encourage them to upskill and try again
+        5. Suggest some learning resources based on missing skills.
+        6. End the email with exactly:
+            Best Regards,
+            Team HR at {st.session_state.company_name}
+        Do not include any name in the signature.
+        The tone should be like a human writing a quick but thoughtful email.
+        """
+    )
+    
+def schedule_interview(scheduler: Agent, candidate_email: str, email_agent: Agent, role: str) -> None:
+    """
+    Schedule interview during business hours (9 AM - 5 PM IST)
+    """
+    try:
+        # getting the current time
+        ist_tz = pytz.timezone("Asia/Kolkata")
+        current_time_ist = datetime.now(ist_tz)
+        
+        tomorrow_ist = current_time_ist + timedelta(days=1)
+        interview_time = tomorrow_ist.replace(hour=11, minute=0, second=0, microsecond=0)
+        formatted_time = interview_time.strftime("%Y-%m-%dT%H:%M:%S")
+        
+        meeting_resp = scheduler.run(
+            f"""Schedule a 60-minute technical interview with these specifications:
+                - Title: '{role} Technical Interview'
+                - Date: {formatted_time}
+                - Timezone: IST (Indian Standard Time)
+                - Attendee: {candidate_email}
+                
+            Important Notes:
+                - The meeting must be between 9 AM - 5 PM IST
+                - Use IST (UTC+5:30) timezone for all communications
+                - Include timezone information in the meeting details
+                - Ask him to be confident and not so nervous and prepare well for the interview
+                - Also, include a small joke or sarcasm to make him relax.
+            """
+        )
+        
+        st.success("Interview Scheduled Successfully! Check your email for details.")
+    except Exception as e:
+        logger.error(f"Error scheduling Interview: {str(e)}")
+        st.error("Unable to schedule interview. Please try again")
+        
+def main() -> None:
+    st.title("HeyHR Aide 🏢")
+    
+    init_session_state()
+    
+    with st.sidebar:
+        st.header("Configurations")
+        
+        # OpenAI configurations
+        st.subheader("OpenAI Configurations")
+        api_key = st.text_input("OpenAI API Key", placeholder="API key here", type="password", value=st.session_state.openai_api_key, help="Get your OpenAI API Key from platform.openai.com")
+        if api_key: st.session_state.openai_api_key = api_key
+        
+        # Zoom Settings
+        st.subheader("Zoom Configurations")
+        zoom_account_id = st.text_input("Zoom Account ID", type="password", value=st.session_state.zoom_account_id)
+        
+        zoom_client_id = st.text_input("Zoom Client ID", type="password", value=st.session_state.zoom_client_id)
+        
+        zoom_client_secret = st.text_input("Zoom Client Secret", type="password", value=st.session_state.zoom_client_secret)
+        
+        # Email Settings
+        email_sender = st.text_input("Sender Email", value=st.session_state.email_sender, help="Email address to send from")
+        
+        email_passkey = st.text_input("Enter Email App Password", value=st.session_state.email_passkey, type="password", help="App-specific password for email")
+        
+        company_name = st.text_input("Company Name", value=st.session_state.company_name, help = "Name to use in email communications")
+        
+        if zoom_account_id: st.session_state.zoom_account_id = zoom_account_id
+        if zoom_client_id: st.session_state.zoom_client_id = zoom_client_id
+        if zoom_client_secret: st.session_state.zoom_client_secret = zoom_client_secret
+        
+        if email_sender: st.session_state.email_sender = email_sender
+        if email_passkey: st.session_state.email_passkey = email_passkey
+        if company_name: st.session_state.company_name = company_name
+        
+        required_configs = {
+            "OpenAI API Key": st.session_state.openai_api_key, 
+            "Zoom Account ID": st.session_state.zoom_account_id,
+            "Zoom Client ID": st.session_state.zoom_client_id,
+            "Zoom Client Secret": st.session_state.zoom_client_secret,
+            "Email Sender": st.session_state.email_sender, 
+            "Email Password": st.session_state.email_passkey,
+            "Company Name": st.session_state.company_name
+        }
+        
+    missing_config = [k for k, v in required_configs.items() if not v]
+    if missing_config:
+        st.warning(f"Pleas configure the following in the sidebar: {', '.join(missing_config)}")
+        return
+    if not st.session_state.openai_api_key:
+        st.warning("Please enter your OpenAI API Key in the sidebar to continue")
+        return
+    
+    role = st.selectbox("Select the role you're applying for: ", ["ai_ml_engineer", "frontend_engineer", "backend_engineer"])
+    
+    with st.expander("View Required Skills", expanded = True): st.markdown(ROLE_REQUIREMENTS[role])
+    
+    # Add a "New Application" button before the resume upload
+    if st.button("New Application 🔍"):
+        # Clear all the application related status
+        keys_to_clear = ["resume_text", "analysis_complete", "is_selected", "candidate_email", "current_pdf"]
+        
+        for key in keys_to_clear:
+            if key in st.session_state:
+                st.session_state[key] = None if key == "current_pdf" else ""
+        st.rerun()
+    
+    resume_file = st.file_uploader("Upload your resume (PDF)", type = ["pdf"], key = "resume_uploaded")
+    
+    if resume_file is not None and resume_file != st.session_state.get("current_pdf"):
+        st.session_state.current_pdf = resume_file
+        st.session_state.resume_text = ""
+        st.session_state.analysis_complete = False
+        st.session_state.is_selected = False
+        st.rerun()
+    
+    if resume_file:
+        st.subheader("Uploaded Resume")
+        col1, col2 = st.columns([4, 1])
+        
+        with col1:
+            import tempfile, os
+            with tempfile.NamedTemporaryFile(delete = False, suffix=".pdf") as tmp_file:
+                tmp_file.write(resume_file.read())
+                tmp_file_path = tmp_file.name
+            resume_file.seek(0)
+            try:
+                pdf_viewer(tmp_file_path)
+            finally:
+                os.unlink(tmp_file_path)
+        with col2:
+            st.download_button(label="Download", 
+                               data = resume_file,
+                               file_name=resume_file.name, 
+                               mime="application/pdf")
+        # Process the resume text
+        if not st.session_state.resume_text:
+            with st.spinner("Processing your resume..."):
+                resume_text = extract_text_from_pdf(resume_file)
+                if resume_text:
+                    st.session_state.resume_text = resume_text
+                    st.success("Resume Processed Successfully!")
+                else:
+                    st.error("Could not process the PDF. Please try again")
+    
+    # Email input with session state
+    email = st.text_input(
+        "Candidate's Email Address",
+        value=st.session_state.candidate_email,
+        key = "email_input"
+    )           
+    
+    st.session_state.candidate_email = email    
+    
+    # Analysis and next steps
+    if st.session_state.resume_text and email and not st.session_state.analysis_complete:
+        if st.button("Analyze Resume"):
+            with st.spinner("Analyzing the resume..."):
+                resume_analyzer = create_resume_analyzer()
+                email_agent = create_email_agent()
+                
+                if resume_analyzer and email_agent:
+                    print("DEBUG: Starting Resume Analysis")
+                    is_selected, feedback = analyze_resume(
+                        st.session_state.resume_text,
+                        role, 
+                        resume_analyzer
+                    )
+                print(f"DEBUG: Analysis Complete\n----------\nSelected: {is_selected}\nFeedback: {feedback}")
+                
+                if is_selected:
+                    st.success("Congratulations! Your skills match our requirements.")
+                    st.session_state.analysis_complete = True
+                    st.session_state.is_selected = True
+                    st.rerun()
+                else:
+                    st.warning("Your skillset are amazing, but unfortunately we have to move forward with other candidates as it doesn't match our requirements")
+                    st.write(f"Feedback: {feedback}")
+                    
+                    # Send Rejection mail
+                    with st.spinner("Sending Feedback Mail.."):
+                        try:
+                            send_rejection_email(
+                            email_agent = email_agent,
+                            to_email = email,
+                            role = role, 
+                            feedback = feedback
+                            )
+                            st.info("We've sent you a email with detailed feedback.")
+                        except Exception as e:
+                            logger.error(f"Error sending rejection mail: {str(e)}")
+                            st.error("Could not send the email. Please try again.")
+    
+    if st.session_state.get('analysis_complete') and st.session_state.get('is_selected', False):
+        st.success("Congratulations! Your skills match our requirements.")
+        st.info("Click 'Proceed with Application' to continue with the interview process.")
+        
+        if st.button("Proceed with Application", key="proceed_button"):
+            print("DEBUG: Proceed button clicked")  # Debug
+            with st.spinner("🔄 Processing your application..."):
+                try:
+                    print("DEBUG: Creating email agent")  # Debug
+                    email_agent = create_email_agent()
+                    print(f"DEBUG: Email agent created: {email_agent}")  # Debug
+                    
+                    print("DEBUG: Creating scheduler agent")  # Debug
+                    scheduler_agent = create_scheduler_agent()
+                    print(f"DEBUG: Scheduler agent created: {scheduler_agent}")  # Debug
+
+                    # 3. Send selection email
+                    with st.status("📧 Sending confirmation email...", expanded=True) as status:
+                        print(f"DEBUG: Attempting to send email to {st.session_state.candidate_email}")  # Debug
+                        send_selection_email(
+                            email_agent,
+                            st.session_state.candidate_email,
+                            role
+                        )
+                        print("DEBUG: Email sent successfully")  # Debug
+                        status.update(label="✅ Confirmation email sent!")
+
+                    # 4. Schedule interview
+                    with st.status("📅 Scheduling interview...", expanded=True) as status:
+                        print("DEBUG: Attempting to schedule interview")  # Debug
+                        schedule_interview(
+                            scheduler_agent,
+                            st.session_state.candidate_email,
+                            email_agent,
+                            role
+                        )
+                        print("DEBUG: Interview scheduled successfully")  # Debug
+                        status.update(label="✅ Interview scheduled!")
+
+                    print("DEBUG: All processes completed successfully")  # Debug
+                    st.success("""
+                        🎉 Application Successfully Processed!
+                        
+                        Please check your email for:
+                        1. Selection confirmation ✅
+                        2. Interview details with Zoom link 🔗
+                        
+                        Next steps:
+                        1. Review the role requirements
+                        2. Prepare for your technical interview
+                        3. Join the interview 5 minutes early
+                    """)
+
+                except Exception as e:
+                    print(f"DEBUG: Error occurred: {str(e)}")  # Debug
+                    print(f"DEBUG: Error type: {type(e)}")  # Debug
+                    import traceback
+                    print(f"DEBUG: Full traceback: {traceback.format_exc()}")  # Debug
+                    st.error(f"An error occurred: {str(e)}")
+                    st.error("Please try again or contact support.")
+
+    # Reset button
+    if st.sidebar.button("Reset Application"):
+        for key in st.session_state.keys():
+            if key != 'openai_api_key':
+                del st.session_state[key]
+        st.rerun()
+
+if __name__ == "__main__":
+    main()