Delete utils

utils/cv_processor.py

@@ -1,111 +0,0 @@
-from PyPDF2 import PdfReader
-from docx import Document
-import re
-from sentence_transformers import SentenceTransformer
-from sklearn.metrics.pairwise import cosine_similarity
-import numpy as np
-import os
-
-# Initialize model for semantic similarity
-model = SentenceTransformer('all-MiniLM-L6-v2')
-
-def extract_text_from_file(file_path):
-    if file_path.endswith('.pdf'):
-        with open(file_path, 'rb') as f:
-            reader = PdfReader(f)
-            text = " ".join([page.extract_text() for page in reader.pages])
-    elif file_path.endswith('.docx'):
-        doc = Document(file_path)
-        text = " ".join([para.text for para in doc.paragraphs])
-    else:
-        raise ValueError("Unsupported file format")
-    
-    # Clean text
-    text = re.sub(r'\s+', ' ', text).strip()
-    return text
-
-def evaluate_cv(cv_path, job_role):
-    # Load job requirements (you would have these stored for each role)
-    job_requirements = load_job_requirements(job_role)
-    
-    # Extract text from CV
-    cv_text = extract_text_from_file(cv_path)
-    
-    # Create embeddings
-    cv_embedding = model.encode(cv_text)
-    requirements_embedding = model.encode(job_requirements["required_skills"])
-    
-    # Calculate similarity
-    similarity = cosine_similarity(
-        cv_embedding.reshape(1, -1),
-        requirements_embedding.reshape(1, -1)
-    )[0][0]
-    
-    # Check minimum requirements
-    rejection_reasons = []
-    meets_requirements = True
-    
-    # Check for minimum experience
-    experience_pattern = r"(\d+)\s+years?"
-    experience_matches = re.findall(experience_pattern, cv_text.lower())
-    total_experience = sum(int(match) for match in experience_matches) if experience_matches else 0
-    
-    if total_experience < job_requirements["min_experience"]:
-        meets_requirements = False
-        rejection_reasons.append(
-            f"Requires {job_requirements['min_experience']} years experience, found {total_experience}"
-        )
-    
-    # Check education
-    education_keywords = job_requirements["required_education"]
-    has_education = any(keyword.lower() in cv_text.lower() for keyword in education_keywords)
-    
-    if not has_education:
-        meets_requirements = False
-        rejection_reasons.append(
-            f"Required education not found: {', '.join(education_keywords)}"
-        )
-    
-    # Check similarity threshold
-    if similarity < 0.4:  # Adjust threshold as needed
-        meets_requirements = False
-        rejection_reasons.append(
-            "CV content doesn't sufficiently match the required skills"
-        )
-    
-    # Prepare CV summary for interview
-    cv_summary = {
-        "text": cv_text,
-        "experience": total_experience,
-        "skills_similarity": float(similarity),
-        "education": has_education
-    }
-    
-    return {
-        "is_qualified": meets_requirements,
-        "rejection_reasons": rejection_reasons,
-        "cv_summary": cv_summary
-    }
-
-def load_job_requirements(job_role):
-    # In a real app, these would be stored in a database or files
-    requirements = {
-        "Software Engineer": {
-            "min_experience": 2,
-            "required_education": ["Bachelor in Computer Science", "BSc CS", "Engineering"],
-            "required_skills": """
-                programming, algorithms, data structures, software development, 
-                testing, debugging, version control, agile methodologies
-            """
-        },
-        "Data Scientist": {
-            "min_experience": 3,
-            "required_education": ["Master", "PhD", "Statistics", "Data Science"],
-            "required_skills": """
-                machine learning, statistics, python, R, data analysis, 
-                data visualization, SQL, predictive modeling
-            """
-        }
-    }
-    
-    return requirements.get(job_role, requirements["Software Engineer"])

utils/interview_agent.py

@@ -1,150 +0,0 @@
-from langchain.llms import HuggingFaceHub
-from langchain.chains import RetrievalQA
-from langchain.embeddings import HuggingFaceEmbeddings
-from langchain.vectorstores import FAISS
-from langchain.document_loaders import TextLoader
-from langchain.text_splitter import CharacterTextSplitter
-import os
-
-class InterviewAgent:
-    def __init__(self, job_role, cv_summary):
-        self.job_role = job_role
-        self.cv_summary = cv_summary
-        self.llm = HuggingFaceHub(
-            repo_id="meta-llama/Meta-Llama-3-8B-Instruct",
-            model_kwargs={"temperature": 0.5, "max_length": 2048}
-        )
-        self.questions = self._generate_questions()
-    
-    def _generate_questions(self):
-        # Load job-specific questions
-        base_questions = self._load_base_questions()
-        
-        # Generate CV-specific questions
-        cv_questions = self._generate_cv_questions()
-        
-        return base_questions + cv_questions
-    
-    def _load_base_questions(self):
-        # In a real app, these would be more sophisticated and loaded from a database
-        role_questions = {
-            "Software Engineer": [
-                {"text": "Explain the SOLID principles in object-oriented design.", "type": "technical", "weight": 0.3},
-                {"text": "How would you optimize a slow database query?", "type": "technical", "weight": 0.25},
-                {"text": "Describe your experience with Agile methodologies.", "type": "behavioral", "weight": 0.2},
-                {"text": "How do you handle conflicts in a team setting?", "type": "behavioral", "weight": 0.15},
-                {"text": "Where do you see yourself in 5 years?", "type": "general", "weight": 0.1}
-            ],
-            "Data Scientist": [
-                {"text": "Explain the bias-variance tradeoff.", "type": "technical", "weight": 0.3},
-                {"text": "How would you handle missing data in a dataset?", "type": "technical", "weight": 0.25},
-                {"text": "Describe a time when you had to explain complex technical concepts to non-technical stakeholders.", "type": "behavioral", "weight": 0.2},
-                {"text": "How do you stay updated with the latest developments in data science?", "type": "behavioral", "weight": 0.15},
-                {"text": "What motivates you to work in data science?", "type": "general", "weight": 0.1}
-            ]
-        }
-        
-        return role_questions.get(self.job_role, role_questions["Software Engineer"])
-    
-    def _generate_cv_questions(self):
-        # Generate questions based on CV content
-        prompt = f"""
-        Based on the following CV summary for a {self.job_role} position, generate 3 specific interview questions.
-        Focus on areas that need clarification or seem particularly relevant to the role.
-        
-        CV Summary:
-        {self.cv_summary['text']}
-        
-        Generate exactly 3 questions in this format:
-        1. [question text]|technical
-        2. [question text]|behavioral
-        3. [question text]|technical
-        
-        Make the questions specific to the candidate's experience and the job role.
-        """
-        
-        response = self.llm(prompt)
-        questions = []
-        
-        for line in response.split('\n'):
-            if line.strip() and '|' in line:
-                text = line.split('|')[0].strip()
-                q_type = line.split('|')[1].strip().lower()
-                questions.append({
-                    "text": text,
-                    "type": q_type,
-                    "weight": 0.15 if q_type == "technical" else 0.1,
-                    "cv_based": True
-                })
-        
-        return questions[:3]  # Ensure we only take 3 questions
-    
-    def get_questions(self):
-        return self.questions
-    
-    def evaluate_answer(self, question, answer):
-        prompt = f"""
-        Evaluate the following interview answer for a {self.job_role} position.
-        Provide specific feedback and a score from 1-10 based on:
-        - Technical accuracy (if technical question)
-        - Relevance to the question
-        - Clarity of communication
-        - Demonstration of skills/experience
-        
-        Question: {question['text']}
-        Answer: {answer}
-        
-        Respond in this exact format:
-        Score: [x]/10
-        Feedback: [your feedback here]
-        """
-        
-        response = self.llm(prompt)
-        
-        # Parse the response
-        score = 5  # default if parsing fails
-        feedback = "Evaluation not available"
-        
-        if "Score:" in response and "Feedback:" in response:
-            try:
-                score_part = response.split("Score:")[1].split("/10")[0].strip()
-                score = float(score_part)
-                feedback = response.split("Feedback:")[1].strip()
-            except:
-                pass
-        
-        return {
-            "score": score,
-            "feedback": feedback,
-            "max_score": 10
-        }
-    
-    def final_evaluation(self, answers):
-        total_score = 0
-        max_possible = 0
-        
-        # Calculate weighted score
-        for answer in answers:
-            weight = answer['question'].get('weight', 0.1)
-            total_score += answer['evaluation']['score'] * weight
-            max_possible += 10 * weight
-        
-        overall_score = (total_score / max_possible) * 10
-        
-        # Determine band
-        if overall_score >= 9:
-            band = "Expert (Band 5)"
-        elif overall_score >= 7:
-            band = "Proficient (Band 4)"
-        elif overall_score >= 5:
-            band = "Competent (Band 3)"
-        elif overall_score >= 3:
-            band = "Limited (Band 2)"
-        else:
-            band = "Beginner (Band 1)"
-        
-        return {
-            "score": round(overall_score, 1),
-            "band": band,
-            "total_questions": len(answers)
-        }

utils/report_generator.py

@@ -1,47 +0,0 @@
-from fpdf import FPDF
-from datetime import datetime
-
-def generate_report(job_role, cv_summary, answers, final_evaluation):
-    pdf = FPDF()
-    pdf.add_page()
-    
-    # Set font and title
-    pdf.set_font("Arial", 'B', 16)
-    pdf.cell(0, 10, f"Interview Report for {job_role}", 0, 1, 'C')
-    pdf.ln(10)
-    
-    # Candidate Summary
-    pdf.set_font("Arial", 'B', 12)
-    pdf.cell(0, 10, "Candidate Summary:", 0, 1)
-    pdf.set_font("Arial", '', 10)
-    pdf.multi_cell(0, 7, f"Experience: {cv_summary['experience']} years\nSkills Match: {cv_summary['skills_similarity']*100:.1f}%")
-    pdf.ln(5)
-    
-    # Interview Results
-    pdf.set_font("Arial", 'B', 12)
-    pdf.cell(0, 10, "Interview Results:", 0, 1)
-    pdf.set_font("Arial", '', 10)
-    pdf.cell(0, 7, f"Overall Score: {final_evaluation['score']}/10", 0, 1)
-    pdf.cell(0, 7, f"Band: {final_evaluation['band']}", 0, 1)
-    pdf.ln(5)
-    
-    # Detailed Feedback
-    pdf.set_font("Arial", 'B', 12)
-    pdf.cell(0, 10, "Question-by-Question Feedback:", 0, 1)
-    pdf.set_font("Arial", '', 10)
-    
-    for i, answer in enumerate(answers):
-        pdf.set_fill_color(200, 220, 255)
-        pdf.cell(0, 7, f"Question {i+1}: {answer['question']['text']}", 0, 1, fill=True)
-        pdf.cell(0, 7, f"Your Answer: {answer['answer']}", 0, 1)
-        pdf.cell(0, 7, f"Score: {answer['evaluation']['score']}/10", 0, 1)
-        pdf.multi_cell(0, 7, f"Feedback: {answer['evaluation']['feedback']}")
-        pdf.ln(3)
-    
-    # Save the report
-    os.makedirs("data/interviews", exist_ok=True)
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    report_path = f"data/interviews/report_{timestamp}.pdf"
-    pdf.output(report_path)
-    
-    return report_path