Spaces:
Sleeping
Sleeping
| import streamlit as st | |
| import json | |
| import tempfile | |
| import pandas as pd | |
| import altair as alt | |
| from typing import Dict, Any, Optional | |
| from roe_ai import generate_insights, extract_job_details, evaluate_candidate_job_fit | |
| def __init__(): | |
| """ | |
| Initialize the Streamlit application with configuration and styling. | |
| """ | |
| _configure_page() | |
| _apply_custom_css() | |
| def _configure_page(): | |
| """ | |
| Set up the Streamlit page configuration. | |
| """ | |
| st.set_page_config( | |
| page_title="Resume Intelligence", | |
| page_icon="📋", | |
| layout="wide", | |
| initial_sidebar_state="expanded", | |
| ) | |
| def _apply_custom_css(): | |
| """ | |
| Apply custom CSS styling to the Streamlit application. | |
| """ | |
| st.markdown( | |
| """ | |
| <style> | |
| .stButton>button { | |
| background-color: #4CAF50; | |
| border-color: white; | |
| color: white; | |
| transition: all 0.3s ease; | |
| } | |
| .stButton>button:hover { | |
| background-color: #45a049; | |
| transform: scale(1.05); | |
| } | |
| .skill-badge { | |
| display: inline-flex; | |
| align-items: center; | |
| background-color: #e1f5fe; | |
| color: #0277bd; | |
| padding: 5px 10px; | |
| border-radius: 20px; | |
| margin: 2px; | |
| } | |
| .skill-proficiency { | |
| margin-left: 5px; | |
| background-color: #4CAF50; | |
| color: white; | |
| border-radius: 10px; | |
| padding: 2px 6px; | |
| font-size: 0.8em; | |
| } | |
| .skill-gap { | |
| background-color:#fee6e6; | |
| border-left: 4px solid red; | |
| padding: 10px; | |
| margin-bottom: 10px; | |
| border-radius: 5px; | |
| } | |
| .strengths { | |
| background-color:#e6f3e6; | |
| border-left: 4px solid green; | |
| padding: 10px; | |
| margin-bottom: 10px; | |
| border-radius: 5px; | |
| } | |
| </style> | |
| """, | |
| unsafe_allow_html=True, | |
| ) | |
| def run(): | |
| """ | |
| Main method to run the Streamlit application. | |
| """ | |
| _render_title() | |
| _configure_sidebar() | |
| uploaded_file = _upload_resume() | |
| if uploaded_file is not None: | |
| _process_resume(uploaded_file) | |
| def _render_title(): | |
| """ | |
| Render the application title and description. | |
| """ | |
| st.title("📄 Resume Intelligence Platform with Roe AI") | |
| st.write("Upload a PDF document to process with our AI agent.") | |
| def _configure_sidebar(): | |
| """ | |
| Configure the sidebar with application settings. | |
| """ | |
| st.sidebar.header("🔧 Configuration") | |
| default_instruction = ( | |
| "Please extract actionable insights from the candidates resume" | |
| ) | |
| st.session_state.insights_prompt = st.sidebar.text_area( | |
| "AI Agent Instruction", value=default_instruction, height=150, disabled=True | |
| ) | |
| st.session_state.page_filter = st.sidebar.text_input( | |
| "Page Range to Process", value="@PAGERANGE(1-3)", disabled=True | |
| ) | |
| def _upload_resume(): | |
| """ | |
| Handle resume file upload. | |
| Returns: | |
| Uploaded file or None | |
| """ | |
| return st.file_uploader( | |
| "Choose a PDF file", | |
| type="pdf", | |
| help="Upload a PDF document to process with the Roe AI agent", | |
| ) | |
| def _process_resume(uploaded_file): | |
| """ | |
| Process the uploaded resume and display insights. | |
| Args: | |
| uploaded_file: Uploaded PDF file | |
| """ | |
| if st.sidebar.button( | |
| "Extract Resume Insights", | |
| type="primary", | |
| disabled=hasattr(st.session_state, "insights"), | |
| ): | |
| insights = _extract_resume_insights(uploaded_file) | |
| st.session_state.insights = insights | |
| if hasattr(st.session_state, "insights"): | |
| _display_candidate_profile(st.session_state.insights) | |
| _setup_job_description_section(st.session_state.insights) | |
| if ( | |
| hasattr(st.session_state, "show_scroll_message") | |
| and st.session_state.show_scroll_message | |
| ): | |
| st.sidebar.info("Please scroll down to see results") | |
| def _extract_resume_insights(uploaded_file): | |
| """ | |
| Extract insights from the uploaded resume. | |
| Args: | |
| uploaded_file: Uploaded PDF file | |
| Returns: | |
| Extracted insights or None | |
| """ | |
| with st.spinner("Analyzing resume..."): | |
| with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as temp_file: | |
| temp_file.write(uploaded_file.getvalue()) | |
| temp_file_path = temp_file.name | |
| result = generate_insights( | |
| temp_file_path, | |
| st.session_state.insights_prompt, | |
| st.session_state.page_filter, | |
| ) | |
| insights = json.loads(result[0]["value"]) | |
| # Validate insights against expected schema | |
| required_fields = ["name", "email", "skills"] | |
| if all(field in insights for field in required_fields): | |
| # st.success("Resume processed successfully!") | |
| return insights | |
| st.warning("Received response does not match expected schema.") | |
| return None | |
| def _setup_job_description_section(insights): | |
| """ | |
| Set up the job description extraction section. | |
| Args: | |
| insights: Candidate insights dictionary | |
| """ | |
| st.sidebar.header("🌐 Job Description Extraction") | |
| job_url = st.sidebar.text_input( | |
| "Job Description URL", | |
| placeholder="Enter URL of job description", | |
| help="Paste the URL of a job description to extract details", | |
| on_change=lambda: None, | |
| ) | |
| job_details = _extract_job_details(job_url) | |
| if job_details: | |
| _assess_job_match(job_details, insights) | |
| def _extract_job_details(job_url): | |
| """ | |
| Extract job details from the provided URL. | |
| Args: | |
| job_url: URL of the job description | |
| Returns: | |
| Job details dictionary or None | |
| """ | |
| if job_url: | |
| if st.sidebar.button( | |
| "Extract Job Details", | |
| type="primary", | |
| disabled=hasattr(st.session_state, "job_details"), | |
| ): | |
| st.session_state.show_scroll_message = True | |
| with st.spinner("Extracting job description..."): | |
| try: | |
| result = extract_job_details(job_url) | |
| job_details = json.loads(result[0]["value"]) | |
| st.session_state.job_details = job_details | |
| # st.success("Job description extracted successfully!") | |
| except Exception as e: | |
| st.error(f"An error occurred: {str(e)}") | |
| if hasattr(st.session_state, "job_details"): | |
| # Display job details | |
| st.subheader("📋 Job Description Details") | |
| st.markdown( | |
| f"**Job Title:** {st.session_state.job_details.get('job_title', 'N/A')}" | |
| ) | |
| st.markdown( | |
| f"**Location:** {st.session_state.job_details.get('location', 'N/A')}" | |
| ) | |
| st.markdown( | |
| f"**Salary:** {st.session_state.job_details.get('salary', 'N/A')}" | |
| ) | |
| st.markdown( | |
| f"**Equity:** {st.session_state.job_details.get('equity', 'N/A')}" | |
| ) | |
| st.markdown( | |
| f"**Experience Level:** {st.session_state.job_details.get('experience_level', 'N/A')}" | |
| ) | |
| st.subheader("Key Responsibilities") | |
| for responsabilities in st.session_state.job_details.get( | |
| "key_responsibilities", [] | |
| ): | |
| st.markdown(f"- {responsabilities}") | |
| st.subheader("Requirements") | |
| for requirements in st.session_state.job_details.get("requirements", []): | |
| st.markdown(f"- {requirements}") | |
| return st.session_state.job_details | |
| return None | |
| def _assess_job_match(job_details, candidate_insights): | |
| """ | |
| Assess the job match between candidate insights and job details. | |
| Args: | |
| job_details: Dictionary of job details | |
| candidate_insights: Dictionary of candidate insights | |
| """ | |
| st.sidebar.header("🔍 Job Match Assessment") | |
| if st.sidebar.button("Assess Job Fit", type="primary"): | |
| with st.spinner("Analyzing candidate-job match..."): | |
| try: | |
| # Call job matching assessment function | |
| result = evaluate_candidate_job_fit( | |
| json.dumps(candidate_insights), json.dumps(job_details) | |
| ) | |
| if result: | |
| match_assessment = json.loads(result[0]["value"]) | |
| _render_job_match_assessment(match_assessment) | |
| else: | |
| st.error("Failed to assess job fit.") | |
| except Exception as e: | |
| st.error(f"An error occurred during job fit assessment: {str(e)}") | |
| def _render_job_match_assessment(match_assessment): | |
| """ | |
| Render the detailed job match assessment. | |
| Args: | |
| match_assessment: Dictionary containing job match assessment details | |
| """ | |
| st.header("📊 Candidate-Job Fit Analysis") | |
| # Overall Match Percentage and Recommendation | |
| col1, col2, col3 = st.columns(3) | |
| with col1: | |
| st.metric( | |
| label="Overall Match", | |
| value=f"{match_assessment.get('percentage_match', 0)}%", | |
| help="Percentage of job requirements met by the candidate", | |
| ) | |
| with col2: | |
| _render_recommendation(match_assessment) | |
| with col3: | |
| st.metric( | |
| label="Interview Potential", | |
| value=( | |
| "Good" | |
| if match_assessment.get("percentage_match", 0) > 70 | |
| else "Needs Work" | |
| ), | |
| help="Candidate's potential for interview based on job match", | |
| ) | |
| # Strengths and Skill Gaps | |
| _render_strengths(match_assessment) | |
| _render_skill_gaps(match_assessment) | |
| # Full Assessment View | |
| with st.expander("📄 Detailed Match Assessment"): | |
| st.json(match_assessment) | |
| def _render_recommendation(match_assessment): | |
| """ | |
| Render the overall recommendation with color coding. | |
| Args: | |
| match_assessment: Dictionary containing job match assessment details | |
| """ | |
| recommendation = match_assessment.get("overall_recommendation", "Unknown") | |
| color_map = { | |
| "Strong Fit": ("green", "✅"), | |
| "Moderate Fit": ("orange", "⚠️"), | |
| } | |
| color, emoji = color_map.get(recommendation, ("red", "❌")) | |
| st.markdown( | |
| f""" | |
| <div style="background-color:{color}20; | |
| border-radius:10px; | |
| padding:10px; | |
| text-align:center;"> | |
| <h4 style="color:{color};"> | |
| {emoji} {recommendation} | |
| </h4> | |
| </div> | |
| """, | |
| unsafe_allow_html=True, | |
| ) | |
| def _render_strengths(match_assessment): | |
| """ | |
| Render candidate strengths. | |
| Args: | |
| match_assessment: Dictionary containing job match assessment details | |
| """ | |
| st.subheader("🌟 Candidate Strengths") | |
| strengths = match_assessment.get("strengths", []) | |
| if strengths: | |
| strength_cols = st.columns(3) | |
| for i, strength in enumerate(strengths): | |
| with strength_cols[i % 3]: | |
| st.markdown( | |
| f""" | |
| <div class="strengths"> | |
| {strength} | |
| </div> | |
| """, | |
| unsafe_allow_html=True, | |
| ) | |
| else: | |
| st.info("No specific strengths identified") | |
| def _render_skill_gaps(match_assessment): | |
| """ | |
| Render potential skill gaps. | |
| Args: | |
| match_assessment: Dictionary containing job match assessment details | |
| """ | |
| st.subheader("🚧 Potential Skill Gaps") | |
| skill_gaps = match_assessment.get("potential_skill_gaps", []) | |
| if skill_gaps: | |
| gap_cols = st.columns(3) | |
| for i, gap in enumerate(skill_gaps): | |
| with gap_cols[i % 3]: | |
| st.markdown( | |
| f""" | |
| <div class="skill-gap"> | |
| {gap} | |
| </div> | |
| """, | |
| unsafe_allow_html=True, | |
| ) | |
| else: | |
| st.info("No significant skill gaps identified") | |
| def _display_candidate_profile(candidate_data: Dict[str, Any]): | |
| """ | |
| Display a detailed candidate profile. | |
| Args: | |
| candidate_data: Dictionary containing candidate information | |
| """ | |
| st.header(f"🧑💼 {candidate_data.get('name', 'Candidate Profile')}") | |
| # Contact and Skills Overview | |
| col1, col2 = st.columns([1, 2]) | |
| with col1: | |
| # Contact Information | |
| st.subheader("📧 Contact Information") | |
| st.markdown(f"**Email:** {candidate_data.get('email', 'Not provided')}") | |
| # Age (if available) | |
| if "age" in candidate_data: | |
| st.markdown(f"**Age:** {candidate_data['age']}") | |
| with col2: | |
| # Skills Section | |
| st.subheader("🛠️ Skills Overview") | |
| _render_skills(candidate_data.get("skills", [])) | |
| # Skills Proficiency Visualization | |
| _create_skills_chart(candidate_data.get("skills", [])) | |
| # Full JSON Response | |
| with st.expander("📄 Full JSON Response"): | |
| st.json(candidate_data) | |
| def _render_skills(skills): | |
| """ | |
| Render skills with badges and proficiency. | |
| Args: | |
| skills: List of skill dictionaries | |
| """ | |
| if skills: | |
| skills_html = "" | |
| for skill in skills: | |
| skill_name = skill.get("name", "Unnamed Skill") | |
| proficiency = skill.get("proficiency") | |
| if proficiency is not None: | |
| proficiency_label = _get_proficiency_label(proficiency) | |
| skills_html += ( | |
| f'<span class="skill-badge">{skill_name}' | |
| f'<span class="skill-proficiency">{proficiency_label}</span>' | |
| f"</span> " | |
| ) | |
| else: | |
| skills_html += f'<span class="skill-badge">{skill_name}</span> ' | |
| st.markdown(skills_html, unsafe_allow_html=True) | |
| else: | |
| st.markdown("*No skills listed*") | |
| def _get_proficiency_label(proficiency): | |
| """ | |
| Get a readable proficiency label. | |
| Args: | |
| proficiency: Numeric proficiency level | |
| Returns: | |
| Proficiency label as a string | |
| """ | |
| if proficiency <= 2: | |
| return "Beginner" | |
| elif proficiency <= 4: | |
| return "Intermediate" | |
| else: | |
| return "Advanced" | |
| def _create_skills_chart(skills): | |
| """ | |
| Create skills proficiency visualization. | |
| Args: | |
| skills: List of skill dictionaries | |
| """ | |
| st.subheader("📊 Skills Proficiency") | |
| if skills: | |
| # Prepare data for the chart | |
| chart_data = [ | |
| { | |
| "skill": skill.get("name", "Unnamed Skill"), | |
| "proficiency": skill.get("proficiency", 0), | |
| } | |
| for skill in skills | |
| ] | |
| # Convert to DataFrame | |
| df = pd.DataFrame(chart_data) | |
| # Create visualization tabs | |
| tab1, tab2 = st.tabs(["Bar Chart", "Table View"]) | |
| with tab1: | |
| # Altair Bar Chart with improved styling | |
| chart = ( | |
| alt.Chart(df) | |
| .mark_bar( | |
| color="#4CAF50", # Green color to match other design elements | |
| opacity=0.7, | |
| ) | |
| .encode( | |
| x=alt.X("skill:N", title="Skills", sort="-y"), | |
| y=alt.Y( | |
| "proficiency:Q", | |
| title="Proficiency Level", | |
| scale=alt.Scale(domain=[0, max(df["proficiency"]) * 1.2]), | |
| ), | |
| tooltip=["skill", "proficiency"], | |
| ) | |
| .properties(width=600, height=400, title="Skills Proficiency Breakdown") | |
| .configure_title(fontSize=16, font="Arial", anchor="middle") | |
| ) | |
| st.altair_chart(chart, use_container_width=True) | |
| with tab2: | |
| # Enhanced Table View | |
| styled_df = df.style.background_gradient(cmap="Greens", subset=["proficiency"]) | |
| st.dataframe(styled_df, use_container_width=True) | |
| # Run the Streamlit app | |
| if __name__ == "__main__": | |
| __init__() | |
| run() | |