import os 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 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()