Upload 7 files

app.py

@@ -0,0 +1,85 @@
+import streamlit as st
+from resume_parser import ResumeParser
+from job_matcher import JobMatcher
+from langflow_chain import LangflowChain
+from ui_components import (
+    render_header,
+    render_upload_section,
+    render_results_section,
+    render_footer
+)
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Check if API key is set
+if not os.getenv("OPENAI_API_KEY"):
+    st.error("Please set your OPENAI_API_KEY in the .env file")
+    st.stop()
+
+# Set page configuration
+st.set_page_config(
+    page_title="Resume Analyzer & Job Matcher",
+    page_icon="📄",
+    layout="wide"
+)
+
+# Initialize session state
+if "resume_data" not in st.session_state:
+    st.session_state.resume_data = None
+    st.session_state.job_matches = None
+    st.session_state.skill_gaps = None
+    st.session_state.improvement_tips = None
+    st.session_state.processed = False
+
+def main():
+    # Render header
+    render_header()
+    
+    # Render upload section
+    uploaded_file = render_upload_section()
+    
+    # Process the uploaded file
+    if uploaded_file is not None and st.button("Analyze Resume"):
+        with st.spinner("Analyzing your resume..."):
+            # Parse resume
+            resume_parser = ResumeParser()
+            resume_data = resume_parser.parse(uploaded_file)
+            st.session_state.resume_data = resume_data
+            
+            # Process with LLM
+            langflow_chain = LangflowChain()
+            analysis_results = langflow_chain.analyze_resume(resume_data)
+            
+            # Match jobs
+            job_matcher = JobMatcher()
+            job_matches = job_matcher.find_matches(analysis_results)
+            
+            # Store results in session state
+            st.session_state.job_matches = analysis_results.get("job_matches", [])
+            st.session_state.skill_gaps = analysis_results.get("skill_gaps", [])
+            st.session_state.improvement_tips = analysis_results.get("improvement_tips", [])
+            st.session_state.processed = True
+            
+            st.success("Resume analyzed successfully!")
+    
+    # Render results
+    if st.session_state.processed:
+        render_results_section(
+            st.session_state.resume_data,
+            st.session_state.job_matches,
+            st.session_state.skill_gaps,
+            st.session_state.improvement_tips
+        )
+    
+    # Render footer
+    render_footer()
+
+if __name__ == "__main__":
+    main()
+
+
+
+  

gitattributes.txt

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

job_matcher.py

@@ -0,0 +1,44 @@
+from typing import Dict, List, Any
+
+class JobMatcher:
+    def __init__(self):
+        # In a real application, this could connect to a job database or API
+        pass
+    
+    def find_matches(self, analysis_results: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """
+        Process the job matches already generated by the LLM
+        
+        In a real application, this module could:
+        1. Connect to job databases or APIs
+        2. Implement sophisticated matching algorithms
+        3. Apply filters based on location, experience level, etc.
+        
+        For this implementation, we're using the matches already provided by the LLM
+        """
+        job_matches = analysis_results.get("job_matches", [])
+        
+        # Additional processing or filtering could be applied here
+        # For now, we're just returning the matches as provided by the LLM
+        
+        return job_matches
+    
+    def calculate_match_score(self, job_requirements: List[str], candidate_skills: List[str]) -> float:
+        """
+        Calculate a match score between job requirements and candidate skills
+        
+        Args:
+            job_requirements: List of skills required for the job
+            candidate_skills: List of skills possessed by the candidate
+            
+        Returns:
+            A match score between 0 and 1
+        """
+        if not job_requirements:
+            return 0.0
+            
+        matched_skills = [skill for skill in candidate_skills if any(req.lower() in skill.lower() for req in job_requirements)]
+        match_score = len(matched_skills) / len(job_requirements)
+        
+        return min(match_score, 1.0)
+        

langflow_chain.py

@@ -0,0 +1,189 @@
+import os
+from typing import Dict, Any
+from langchain_openai import ChatOpenAI
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+class LangflowChain:
+    def __init__(self):
+        """Initialize the LangflowChain with OpenAI LLM"""
+        self.llm = ChatOpenAI(
+            model="gpt-3.5-turbo",
+            temperature=0.2
+        )
+        
+        self.template = """
+        You are an expert resume analyzer and career advisor. Your task is to analyze the resume details provided 
+        and generate actionable insights.
+
+        Resume Details:
+        {resume_data}
+
+        Based on the resume details above, please provide the following:
+
+        1. Suitable Job Roles: List the top 5 job roles that match this candidate's skills and experience.
+        2. Skill Gap Analysis: Identify important skills that are missing for the suggested job roles and 
+           recommend courses or certifications to acquire these skills.
+        3. Resume Improvement Tips: Provide specific, actionable recommendations for enhancing the resume.
+
+        Format your response as a JSON object with the following structure:
+        {{
+            "job_matches": [
+                {{
+                    "title": "Job Title 1",
+                    "match_score": 85,
+                    "key_matching_skills": ["Skill 1", "Skill 2", "Skill 3"],
+                    "description": "Brief description of why this role is suitable"
+                }},
+                // Other job matches...
+            ],
+            "skill_gaps": [
+                {{
+                    "skill": "Missing Skill 1",
+                    "importance": "High",
+                    "acquisition_recommendation": "Specific course, certification, or project to gain this skill"
+                }},
+                // Other skill gaps...
+            ],
+            "improvement_tips": [
+                "Specific tip 1 for improving the resume",
+                "Specific tip 2 for improving the resume",
+                // Other tips...
+            ]
+        }}
+
+        Ensure your response is properly formatted as valid JSON.
+        """
+        
+        self.prompt = PromptTemplate(
+            input_variables=["resume_data"],
+            template=self.template
+        )
+        
+        self.chain = LLMChain(
+            llm=self.llm,
+            prompt=self.prompt
+        )
+    
+    def analyze_resume(self, resume_data: Any) -> Dict[str, Any]:
+        """
+        Analyze a resume and generate insights using the LLM chain
+        
+        Args:
+            resume_data: Structured resume data
+            
+        Returns:
+            Dictionary containing job matches, skill gaps, and improvement tips
+        """
+        # Convert resume data to string representation
+        resume_str = self._format_resume_data(resume_data)
+        
+        # Execute the chain
+        try:
+            result = self.chain.invoke({"resume_data": resume_str})
+            
+            # Extract the response text
+            response_text = result.get("text", "{}")
+            
+            # In a real implementation, we'd parse the JSON here
+            # For simplicity, we're returning a mock result
+            import json
+            try:
+                return json.loads(response_text)
+            except json.JSONDecodeError:
+                # Fall back to a mock response if JSON parsing fails
+                return self._create_mock_response()
+            
+        except Exception as e:
+            print(f"Error in LLM chain: {e}")
+            return self._create_mock_response()
+    
+    def _format_resume_data(self, resume_data: Any) -> str:
+        """Format resume data into a string for the prompt"""
+        if hasattr(resume_data, "dict"):
+            # If it's a Pydantic model
+            data_dict = resume_data.dict()
+        else:
+            # Assume it's already a dictionary or can be converted to string
+            data_dict = resume_data
+            
+        formatted_str = ""
+        
+        # Personal Info
+        personal_info = data_dict.get("personal_info", {})
+        formatted_str += "Personal Information:\n"
+        for key, value in personal_info.items():
+            if value:
+                formatted_str += f"- {key.replace('_', ' ').title()}: {value}\n"
+        
+        # Education
+        education = data_dict.get("education", [])
+        formatted_str += "\nEducation:\n"
+        for edu in education:
+            if isinstance(edu, dict):
+                inst = edu.get("institution", "")
+                degree = edu.get("degree", "")
+                formatted_str += f"- {degree} at {inst}\n"
+            else:
+                formatted_str += f"- {str(edu)}\n"
+        
+        # Work Experience
+        work_exp = data_dict.get("work_experience", [])
+        formatted_str += "\nWork Experience:\n"
+        for exp in work_exp:
+            if isinstance(exp, dict):
+                company = exp.get("company", "")
+                position = exp.get("position", "")
+                formatted_str += f"- {position} at {company}\n"
+            else:
+                formatted_str += f"- {str(exp)}\n"
+        
+        # Skills
+        skills = data_dict.get("skills", [])
+        formatted_str += "\nSkills:\n"
+        for skill in skills:
+            formatted_str += f"- {skill}\n"
+        
+        # Certifications
+        certifications = data_dict.get("certifications", [])
+        formatted_str += "\nCertifications:\n"
+        for cert in certifications:
+            formatted_str += f"- {cert}\n"
+            
+        return formatted_str
+    
+    def _create_mock_response(self) -> Dict[str, Any]:
+        """Create a mock response for testing or fallback"""
+        return {
+            "job_matches": [
+                {
+                    "title": "Data Scientist",
+                    "match_score": 85,
+                    "key_matching_skills": ["Python", "Data Analysis", "Machine Learning"],
+                    "description": "Your strong analytical skills and programming experience make you well-suited for this role."
+                },
+                {
+                    "title": "Software Engineer",
+                    "match_score": 80,
+                    "key_matching_skills": ["Python", "JavaScript", "Git"],
+                    "description": "Your technical skills and project experience align well with software engineering positions."
+                }
+            ],
+            "skill_gaps": [
+                {
+                    "skill": "Cloud Computing (AWS/Azure)",
+                    "importance": "High",
+                    "acquisition_recommendation": "AWS Certified Solutions Architect or Azure Fundamentals certification"
+                },
+                {
+                    "skill": "SQL and Database Management",
+                    "importance": "Medium",
+                    "acquisition_recommendation": "Take an online course on SQL and database design"
+                }
+            ],
+            "improvement_tips": [
+                "Quantify your achievements with specific metrics and results",
+                "Add a professional summary section highlighting your key strengths",
+                "Reorganize your skills section to prioritize the most relevant skills for your target roles"
+            ]
+        }

requirements.txt

@@ -0,0 +1,12 @@
+
+streamlit==1.30.0
+langchain==0.1.0
+langchain-openai==0.0.5
+python-docx==0.8.11
+PyPDF2==3.0.1
+pydantic==2.5.2
+python-dotenv==1.0.0
+streamlit-extras==0.3.5
+numpy==1.26.2
+pandas==2.1.3
+

resume_parser.py

@@ -0,0 +1,226 @@
+import PyPDF2
+import docx
+import io
+import re
+from pydantic import BaseModel
+from typing import List, Optional, Dict
+
+class Education(BaseModel):
+    institution: str
+    degree: str
+    field_of_study: Optional[str] = None
+    graduation_date: Optional[str] = None
+
+class WorkExperience(BaseModel):
+    company: str
+    position: str
+    start_date: Optional[str] = None
+    end_date: Optional[str] = None
+    description: Optional[str] = None
+
+class PersonalInfo(BaseModel):
+    name: Optional[str] = None
+    email: Optional[str] = None
+    phone: Optional[str] = None
+    location: Optional[str] = None
+    github: Optional[str] = None
+    linkedin: Optional[str] = None
+    portfolio: Optional[str] = None
+
+class ResumeData(BaseModel):
+    personal_info: PersonalInfo
+    education: List[Education]
+    work_experience: List[WorkExperience]
+    skills: List[str]
+    certifications: List[str]
+    raw_text: str
+
+class ResumeParser:
+    def __init__(self):
+        self.email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+        self.phone_pattern = r'(\+\d{1,3}[\s-]?)?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}'
+        self.github_pattern = r'github\.com/([A-Za-z0-9_-]+)'
+        self.linkedin_pattern = r'linkedin\.com/in/([A-Za-z0-9_-]+)'
+
+    def parse(self, uploaded_file) -> ResumeData:
+        """Parse the uploaded resume file and extract key information"""
+        # Extract text from file
+        file_extension = uploaded_file.name.split('.')[-1].lower()
+        
+        if file_extension == 'pdf':
+            raw_text = self._extract_text_from_pdf(uploaded_file)
+        elif file_extension in ['docx', 'doc']:
+            raw_text = self._extract_text_from_docx(uploaded_file)
+        else:
+            raise ValueError("Unsupported file format. Please upload a PDF or DOCX file.")
+        
+        # Extract components
+        personal_info = self._extract_personal_info(raw_text)
+        education = self._extract_education(raw_text)
+        work_experience = self._extract_work_experience(raw_text)
+        skills = self._extract_skills(raw_text)
+        certifications = self._extract_certifications(raw_text)
+        
+        # Create and return ResumeData
+        resume_data = ResumeData(
+            personal_info=personal_info,
+            education=education,
+            work_experience=work_experience,
+            skills=skills,
+            certifications=certifications,
+            raw_text=raw_text
+        )
+        
+        return resume_data
+    
+    def _extract_text_from_pdf(self, file) -> str:
+        """Extract text from PDF file"""
+        pdf_reader = PyPDF2.PdfReader(io.BytesIO(file.getvalue()))
+        text = ""
+        for page in pdf_reader.pages:
+            text += page.extract_text()
+        return text
+    
+    def _extract_text_from_docx(self, file) -> str:
+        """Extract text from DOCX file"""
+        doc = docx.Document(io.BytesIO(file.getvalue()))
+        text = ""
+        for paragraph in doc.paragraphs:
+            text += paragraph.text + "\n"
+        return text
+    
+    def _extract_personal_info(self, text) -> PersonalInfo:
+        """Extract personal information from resume text"""
+        # Basic extraction with regex
+        email = re.search(self.email_pattern, text)
+        phone = re.search(self.phone_pattern, text)
+        github = re.search(self.github_pattern, text)
+        linkedin = re.search(self.linkedin_pattern, text)
+        
+        # First line often contains the name
+        lines = text.split('\n')
+        name = lines[0].strip() if lines else None
+        
+        return PersonalInfo(
+            name=name,
+            email=email.group(0) if email else None,
+            phone=phone.group(0) if phone else None,
+            github=github.group(1) if github else None,
+            linkedin=linkedin.group(1) if linkedin else None
+        )
+    
+    def _extract_education(self, text) -> List[Education]:
+        """Extract education information from resume text"""
+        # Simple implementation - in a real system this would be more sophisticated
+        education_section = self._extract_section(text, ["EDUCATION", "Education", "ACADEMIC BACKGROUND"])
+        if not education_section:
+            return []
+        
+        # Very basic parsing - a real implementation would use more sophisticated NLP
+        educations = []
+        lines = education_section.split('\n')
+        current_education = None
+        
+        for line in lines:
+            if not line.strip():
+                continue
+                
+            if any(degree in line for degree in ["Bachelor", "Master", "PhD", "B.S.", "M.S.", "Ph.D"]):
+                if current_education:
+                    educations.append(current_education)
+                
+                parts = line.split(',')
+                degree = parts[0].strip() if parts else line.strip()
+                institution = parts[1].strip() if len(parts) > 1 else ""
+                
+                current_education = Education(
+                    institution=institution,
+                    degree=degree
+                )
+        
+        if current_education:
+            educations.append(current_education)
+            
+        return educations
+    
+    def _extract_work_experience(self, text) -> List[WorkExperience]:
+        """Extract work experience from resume text"""
+        experience_section = self._extract_section(text, ["EXPERIENCE", "Experience", "WORK EXPERIENCE", "EMPLOYMENT"])
+        if not experience_section:
+            return []
+        
+        # Simple implementation
+        experiences = []
+        lines = experience_section.split('\n')
+        current_experience = None
+        
+        for line in lines:
+            if not line.strip():
+                continue
+                
+            if re.search(r'\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec|January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{4}\b', line):
+                if current_experience:
+                    experiences.append(current_experience)
+                
+                # Very simplistic parsing
+                company_match = re.search(r'([A-Za-z0-9\s]+)', line)
+                company = company_match.group(1).strip() if company_match else "Unknown Company"
+                
+                position_match = re.search(r'([A-Za-z\s]+)', line)
+                position = position_match.group(1).strip() if position_match else "Unknown Position"
+                
+                current_experience = WorkExperience(
+                    company=company,
+                    position=position
+                )
+        
+        if current_experience:
+            experiences.append(current_experience)
+            
+        return experiences
+    
+    def _extract_skills(self, text) -> List[str]:
+        """Extract skills from resume text"""
+        skills_section = self._extract_section(text, ["SKILLS", "Skills", "TECHNICAL SKILLS"])
+        if not skills_section:
+            return []
+        
+        # Simple split by commas and cleanup
+        skills_text = skills_section.replace('\n', ' ')
+        skills = [skill.strip() for skill in re.split(r'[,•]', skills_text) if skill.strip()]
+        
+        return skills
+    
+    def _extract_certifications(self, text) -> List[str]:
+        """Extract certifications from resume text"""
+        cert_section = self._extract_section(text, ["CERTIFICATIONS", "Certifications", "CERTIFICATES"])
+        if not cert_section:
+            return []
+        
+        # Simple split by newlines and cleanup
+        certifications = [cert.strip() for cert in cert_section.split('\n') if cert.strip()]
+        
+        return certifications
+    
+    def _extract_section(self, text, section_headers) -> str:
+        """Extract a section from the resume text based on headers"""
+        lines = text.split('\n')
+        section_text = ""
+        in_section = False
+        
+        for i, line in enumerate(lines):
+            # Check if this line contains a section header
+            if any(header in line for header in section_headers):
+                in_section = True
+                continue
+            
+            # Check if we've reached the next section
+            if in_section and i < len(lines) - 1:
+                next_line = lines[i+1]
+                if next_line.isupper() and len(next_line.strip()) > 0:
+                    break
+            
+            if in_section:
+                section_text += line + "\n"
+        
+        return section_text.strip()

ui_components.py

@@ -0,0 +1,99 @@
+import streamlit as st
+from typing import Dict, List, Any, Optional
+
+def render_header():
+    """Render the application header"""
+    st.title("📄 Resume Analyzer & Job Matcher")
+    st.markdown("""
+    Upload your resume to get personalized job matches, identify skill gaps, 
+    and receive recommendations for improvement.
+    """)
+    st.divider()
+
+def render_upload_section():
+    """Render the file upload section"""
+    st.subheader("Upload Your Resume")
+    st.markdown("Supported formats: PDF, DOCX")
+    
+    uploaded_file = st.file_uploader("Choose a file", type=["pdf", "docx"])
+    
+    if uploaded_file is not None:
+        st.success(f"File uploaded: {uploaded_file.name}")
+        
+        file_details = {
+            "Filename": uploaded_file.name,
+            "File size": f"{uploaded_file.size / 1024:.2f} KB",
+            "File type": uploaded_file.type
+        }
+        
+        with st.expander("File Details"):
+            for key, value in file_details.items():
+                st.write(f"**{key}:** {value}")
+    
+    return uploaded_file
+
+def render_results_section(
+    resume_data: Any, 
+    job_matches: List[Dict[str, Any]], 
+    skill_gaps: List[Dict[str, Any]], 
+    improvement_tips: List[str]
+):
+    """Render the results section with analysis output"""
+    st.divider()
+    st.header("Analysis Results")
+    
+    # Create tabs for different result categories
+    tab1, tab2, tab3 = st.tabs(["Job Matches", "Skill Gaps", "Resume Improvement"])
+    
+    # Tab 1: Job Matches
+    with tab1:
+        st.subheader("Recommended Job Roles")
+        if not job_matches:
+            st.info("No job matches found. Please try uploading a different resume.")
+        else:
+            for i, job in enumerate(job_matches):
+                with st.container():
+                    col1, col2 = st.columns([3, 1])
+                    with col1:
+                        st.markdown(f"### {i+1}. {job.get('title', 'Unknown Job')}")
+                        st.markdown(f"**Match Score:** {job.get('match_score', 'N/A')}%")
+                        st.markdown(f"**Description:** {job.get('description', 'No description available')}")
+                    with col2:
+                        st.markdown("**Matching Skills:**")
+                        for skill in job.get('key_matching_skills', []):
+                            st.markdown(f"- {skill}")
+                st.divider()
+    
+    # Tab 2: Skill Gaps
+    with tab2:
+        st.subheader("Skill Gap Analysis")
+        if not skill_gaps:
+            st.info("No skill gaps identified.")
+        else:
+            for skill_gap in skill_gaps:
+                with st.container():
+                    col1, col2 = st.columns([1, 2])
+                    with col1:
+                        st.markdown(f"### {skill_gap.get('skill', 'Unknown Skill')}")
+                        st.markdown(f"**Importance:** {skill_gap.get('importance', 'Medium')}")
+                    with col2:
+                        st.markdown("**How to acquire this skill:**")
+                        st.markdown(skill_gap.get('acquisition_recommendation', 'No recommendation available'))
+                st.divider()
+    
+    # Tab 3: Resume Improvement
+    with tab3:
+        st.subheader("Resume Improvement Tips")
+        if not improvement_tips:
+            st.info("No improvement tips available.")
+        else:
+            for i, tip in enumerate(improvement_tips):
+                st.markdown(f"**{i+1}.** {tip}")
+
+def render_footer():
+    """Render the application footer"""
+    st.divider()
+    st.markdown("""
+    **Note:** This application uses AI to analyze your resume and provide recommendations. 
+    The results should be considered as suggestions and may not be 100% accurate.
+    """)