Download main.py from MON3EMPASHA/smart-virtual-interview-ai: direct link, hf CLI and curl.
- Browser
- Download file 18.9 kB
-
https://huggingface.co/spaces/MON3EMPASHA/smart-virtual-interview-ai/resolve/main/main.py
- Command line
-
hf download hf://spaces/MON3EMPASHA/smart-virtual-interview-ai/main.py
-
curl -L -o main.py https://huggingface.co/spaces/MON3EMPASHA/smart-virtual-interview-ai/resolve/main/main.py
18.9 kB
| import json | |
| import os | |
| import fitz | |
| import re | |
| from datetime import datetime, timezone | |
| from fastapi import FastAPI, File, HTTPException, UploadFile | |
| from pydantic import BaseModel | |
| from CV_Parser.Extraction import extract_and_infer_profile, test_llm_connection | |
| from groq import Groq | |
| from prompts import INTERVIEW_EVALUATION_PROMPT, INTERVIEW_QUESTION_PROMPT | |
| app = FastAPI( | |
| title="AI Service", | |
| description="CV Parsing + Candidate Profile Extraction", | |
| version="1.1.0", | |
| ) | |
| SECTION_HINTS = ( | |
| "profile", | |
| "projects", | |
| "education", | |
| "professional experience", | |
| "experience", | |
| "skills & languages", | |
| "certificates & achievements", | |
| "courses", | |
| ) | |
| SECTION_BOUNDARIES = ( | |
| "professional experience", | |
| "certificates & achievements", | |
| "skills & languages", | |
| "education", | |
| "projects", | |
| "profile", | |
| "courses", | |
| ) | |
| def split_section_boundaries(text): | |
| normalized = str(text or "") | |
| for heading in sorted(SECTION_BOUNDARIES, key=len, reverse=True): | |
| pattern = rf"(?i)(?<!\n)(?<!^)(?<!\b)(?<![\r\n])(?<!\s)({re.escape(heading)})(?!\s*$)" | |
| normalized = re.sub(pattern, r"\n\1\n", normalized) | |
| normalized = re.sub( | |
| rf"(?i)(?<!\n)({re.escape(heading)})(?=\s+[A-Za-z])", | |
| r"\1\n", | |
| normalized, | |
| ) | |
| normalized = re.sub( | |
| rf"(?i)(?<=\w)({re.escape(heading)})(?=\w)", | |
| r"\n\1\n", | |
| normalized, | |
| ) | |
| return normalized | |
| def score_text_layout(text): | |
| normalized = str(text or "").strip() | |
| if not normalized: | |
| return -1 | |
| lines = [line for line in normalized.splitlines() if line.strip()] | |
| heading_hits = sum(1 for hint in SECTION_HINTS if hint in normalized.lower()) | |
| long_lines = sum(1 for line in lines if len(line) > 220) | |
| short_lines = sum(1 for line in lines if len(line) < 18) | |
| return (heading_hits * 20) + len(lines) - long_lines - (short_lines // 3) | |
| def order_blocks_by_columns(page, blocks): | |
| page_mid = page.rect.width / 2 | |
| left_column = [] | |
| right_column = [] | |
| full_order = [] | |
| for block in blocks: | |
| if len(block) < 5: | |
| continue | |
| text = str(block[4]).strip() | |
| if not text: | |
| continue | |
| x0, y0, x1, y1 = block[:4] | |
| entry = (y0, x0, text) | |
| full_order.append(entry) | |
| if x1 <= page_mid: | |
| left_column.append(entry) | |
| elif x0 >= page_mid: | |
| right_column.append(entry) | |
| elif x0 < page_mid: | |
| left_column.append(entry) | |
| else: | |
| right_column.append(entry) | |
| left_text = "\n".join(text for _, _, text in sorted(left_column)) | |
| right_text = "\n".join(text for _, _, text in sorted(right_column)) | |
| full_text = "\n".join(text for _, _, text in sorted(full_order)) | |
| return [candidate for candidate in (left_text + ("\n" + right_text if right_text else ""), full_text) if candidate.strip()] | |
| def extract_page_text(page): | |
| candidates = [] | |
| plain_text = page.get_text("text", sort=True) or "" | |
| if plain_text.strip(): | |
| candidates.append(plain_text) | |
| blocks = page.get_text("blocks", sort=False) or [] | |
| candidates.extend(order_blocks_by_columns(page, blocks)) | |
| words = page.get_text("words", sort=True) or [] | |
| if words: | |
| word_lines = {} | |
| for word in words: | |
| if len(word) < 5: | |
| continue | |
| text = str(word[4]).strip() | |
| if not text: | |
| continue | |
| y_key = round(float(word[1]), 1) | |
| x_key = float(word[0]) | |
| word_lines.setdefault(y_key, []).append((x_key, text)) | |
| reconstructed = [] | |
| for _, entries in sorted(word_lines.items()): | |
| reconstructed.append(" ".join(text for _, text in sorted(entries))) | |
| word_text = "\n".join(reconstructed) | |
| if word_text.strip(): | |
| candidates.append(word_text) | |
| best_text = max(candidates, key=score_text_layout, default="") | |
| if not best_text.strip(): | |
| try: | |
| ocr_text_page = page.get_textpage_ocr(language="eng") | |
| best_text = page.get_text(textpage=ocr_text_page) or "" | |
| except Exception: | |
| best_text = plain_text | |
| return best_text | |
| class CVRequest(BaseModel): | |
| clean_cv_text: str | |
| class InterviewSessionRequest(BaseModel): | |
| profile: dict | |
| question_count: int = 5 | |
| class InterviewAnswerRequest(BaseModel): | |
| profile: dict | |
| question: str | |
| answer: str | |
| history: list[dict] = [] | |
| def get_groq_client(): | |
| api_key = os.environ.get("GROQ_API_KEY") | |
| if not api_key: | |
| raise ValueError("GROQ_API_KEY is not set") | |
| return Groq(api_key=api_key) | |
| def normalize_text(value): | |
| return " ".join(str(value or "").split()).strip() | |
| def normalize_list(values): | |
| return [normalize_text(value) for value in values or [] if normalize_text(value)] | |
| def sanitize_profile_for_interview(profile): | |
| candidate = profile.get("candidate", {}) if isinstance(profile, dict) else {} | |
| extraction = profile.get("extraction", {}) if isinstance(profile, dict) else {} | |
| return { | |
| "candidate": { | |
| "fullName": normalize_text(candidate.get("fullName")), | |
| "currentRole": normalize_text(candidate.get("currentRole")), | |
| "suggestedRole": normalize_text(candidate.get("suggestedRole")), | |
| "experienceYears": candidate.get("experienceYears", 0), | |
| "experienceLevel": normalize_text(candidate.get("experienceLevel")), | |
| "summary": normalize_text(candidate.get("summary")), | |
| }, | |
| "extraction": { | |
| "skills": normalize_list(extraction.get("skills")), | |
| "highlights": normalize_list(extraction.get("highlights")), | |
| "experience": normalize_list(extraction.get("experience")), | |
| "projects": normalize_list(extraction.get("projects")), | |
| "certifications": normalize_list(extraction.get("certifications")), | |
| }, | |
| } | |
| def fallback_interview_plan(profile, question_count=5): | |
| candidate = profile["candidate"] | |
| extraction = profile["extraction"] | |
| target_role = ( | |
| candidate.get("suggestedRole") | |
| or candidate.get("currentRole") | |
| or "the target role" | |
| ) | |
| focus_areas = normalize_list( | |
| [ | |
| target_role, | |
| *extraction.get("skills", [])[:2], | |
| *extraction.get("projects", [])[:1], | |
| "communication", | |
| ] | |
| )[:4] | |
| questions = [ | |
| { | |
| "id": "q1", | |
| "category": "Personal", | |
| "prompt": f"Tell me a bit about yourself and why you want {target_role}.", | |
| "why": "Opens the interview with role motivation and self-presentation.", | |
| }, | |
| { | |
| "id": "q2", | |
| "category": "Personal", | |
| "prompt": "What project from your CV are you most proud of?", | |
| "why": "Checks ownership, impact, and storytelling.", | |
| }, | |
| { | |
| "id": "q3", | |
| "category": "Technical", | |
| "prompt": ( | |
| f"What skill will help you most as a {target_role}, and where did you use it?" | |
| ), | |
| "why": "Connects declared skills to real experience.", | |
| }, | |
| { | |
| "id": "q4", | |
| "category": "Technical", | |
| "prompt": "Tell me about a technical problem you solved in a project.", | |
| "why": "Assesses reasoning, resilience, and execution.", | |
| }, | |
| { | |
| "id": "q5", | |
| "category": "Personal", | |
| "prompt": "What skill would you like to improve next?", | |
| "why": "Measures self-awareness and growth mindset.", | |
| }, | |
| ] | |
| return { | |
| "interviewerIntro": ( | |
| f"Hi {candidate.get('fullName') or 'there'}, I will simulate a live interview for " | |
| f"{target_role}. Answer naturally, and I will give coaching feedback after each response." | |
| ), | |
| "focusAreas": focus_areas, | |
| "questions": questions[: max(1, min(question_count, len(questions)))], | |
| } | |
| def parse_json_response(text): | |
| cleaned = str(text or "").strip() | |
| if cleaned.startswith("```json"): | |
| cleaned = cleaned[7:] | |
| if cleaned.startswith("```"): | |
| cleaned = cleaned[3:] | |
| if cleaned.endswith("```"): | |
| cleaned = cleaned[:-3] | |
| cleaned = cleaned.strip() | |
| if cleaned.startswith("{") and cleaned.endswith("}"): | |
| return json.loads(cleaned) | |
| start = cleaned.find("{") | |
| end = cleaned.rfind("}") | |
| if start != -1 and end != -1 and end > start: | |
| return json.loads(cleaned[start : end + 1]) | |
| return json.loads(cleaned) | |
| def request_interview_plan(profile, question_count=5): | |
| client = get_groq_client() | |
| model = os.environ.get("GROQ_MODEL", "llama-3.1-8b-instant") | |
| prompt_payload = json.dumps( | |
| { | |
| "questionCount": question_count, | |
| "profile": profile, | |
| }, | |
| ensure_ascii=False, | |
| ) | |
| completion = client.chat.completions.create( | |
| model=model, | |
| temperature=0.4, | |
| messages=[ | |
| {"role": "system", "content": INTERVIEW_QUESTION_PROMPT}, | |
| {"role": "user", "content": prompt_payload}, | |
| ], | |
| ) | |
| parsed = parse_json_response(completion.choices[0].message.content) | |
| questions = parsed.get("questions") if isinstance(parsed, dict) else None | |
| if not isinstance(questions, list) or not questions: | |
| raise ValueError("Interview plan did not return any questions") | |
| return { | |
| "interviewerIntro": normalize_text(parsed.get("interviewerIntro")), | |
| "focusAreas": normalize_list(parsed.get("focusAreas"))[:6], | |
| "questions": [ | |
| { | |
| "id": normalize_text(item.get("id")) or f"q{index + 1}", | |
| "category": normalize_text(item.get("category")) or "general", | |
| "prompt": normalize_text(item.get("prompt")), | |
| "why": normalize_text(item.get("why")), | |
| } | |
| for index, item in enumerate(questions) | |
| if normalize_text(item.get("prompt")) | |
| ][: max(1, question_count)], | |
| } | |
| def evaluate_answer_fallback(question, answer): | |
| answer_text = normalize_text(answer) | |
| word_count = len(answer_text.split()) | |
| score = 5 | |
| if word_count >= 25: | |
| score += 2 | |
| if word_count >= 45: | |
| score += 1 | |
| if any(token in answer_text.lower() for token in ["because", "result", "impact", "learned", "improved"]): | |
| score += 1 | |
| score = max(3, min(score, 9)) | |
| strengths = [] | |
| improvements = [] | |
| if word_count >= 25: | |
| strengths.append("You gave enough detail to understand your thinking.") | |
| else: | |
| improvements.append("Add more detail so the interviewer can judge your contribution.") | |
| if any(token in answer_text.lower() for token in ["result", "impact", "improved", "increased", "reduced"]): | |
| strengths.append("You hinted at outcomes, which makes the answer stronger.") | |
| else: | |
| improvements.append("Mention the result or impact of your work.") | |
| if not improvements: | |
| improvements.append("Make the structure even clearer using situation, action, and result.") | |
| return { | |
| "score": score, | |
| "strengths": strengths or ["Your answer addressed the question directly."], | |
| "improvements": improvements[:2], | |
| "followUpQuestion": f"Can you give one specific example related to: {normalize_text(question)}", | |
| "coachReply": "Solid start. Tighten the structure and make your impact more explicit.", | |
| } | |
| def request_answer_evaluation(profile, question, answer, history): | |
| client = get_groq_client() | |
| model = os.environ.get("GROQ_MODEL", "llama-3.1-8b-instant") | |
| prompt_payload = json.dumps( | |
| { | |
| "profile": profile, | |
| "question": normalize_text(question), | |
| "answer": normalize_text(answer), | |
| "history": history[-3:], | |
| }, | |
| ensure_ascii=False, | |
| ) | |
| completion = client.chat.completions.create( | |
| model=model, | |
| temperature=0.3, | |
| messages=[ | |
| {"role": "system", "content": INTERVIEW_EVALUATION_PROMPT}, | |
| {"role": "user", "content": prompt_payload}, | |
| ], | |
| ) | |
| parsed = parse_json_response(completion.choices[0].message.content) | |
| return { | |
| "score": max(1, min(int(parsed.get("score", 0) or 0), 10)), | |
| "strengths": normalize_list(parsed.get("strengths"))[:3], | |
| "improvements": normalize_list(parsed.get("improvements"))[:3], | |
| "followUpQuestion": normalize_text(parsed.get("followUpQuestion")), | |
| "coachReply": normalize_text(parsed.get("coachReply")), | |
| } | |
| def extract_text_from_pdf(file_bytes): | |
| pages = [] | |
| pdf = fitz.open(stream=file_bytes, filetype="pdf") | |
| for page in pdf: | |
| page_text = extract_page_text(page) | |
| if len(page_text.strip()) < 40: | |
| try: | |
| ocr_text_page = page.get_textpage_ocr(language="eng") | |
| ocr_text = page.get_text(textpage=ocr_text_page) or "" | |
| if len(ocr_text.strip()) > len(page_text.strip()): | |
| page_text = ocr_text | |
| except Exception: | |
| pass | |
| if page_text.strip(): | |
| pages.append(page_text) | |
| return "\n".join(pages) | |
| def clean_text(text): | |
| normalized = ( | |
| str(text or "") | |
| .replace("\u00a0", " ") | |
| .replace("\u2022", "- ") | |
| .replace("\u2013", "-") | |
| .replace("\u2014", "-") | |
| ) | |
| normalized = split_section_boundaries(normalized) | |
| cleaned_lines = [] | |
| for raw_line in normalized.splitlines(): | |
| line = " ".join(raw_line.split()).strip() | |
| if line: | |
| cleaned_lines.append(line) | |
| return "\n".join(cleaned_lines) | |
| def analyze_cv_bytes(file_bytes): | |
| raw_text = extract_text_from_pdf(file_bytes) | |
| clean_cv_text = clean_text(raw_text) | |
| if len(clean_cv_text.strip()) < 30: | |
| raise HTTPException( | |
| status_code=422, | |
| detail=( | |
| "No readable text could be extracted from this PDF. " | |
| "The file may be scanned or image-based and requires OCR." | |
| ), | |
| ) | |
| result = extract_and_infer_profile(clean_cv_text) | |
| if result["status"] == "error": | |
| raise HTTPException(status_code=500, detail=result["message"]) | |
| result["data"]["metadata"]["rawTextLength"] = len(raw_text) | |
| result["data"]["metadata"]["cleanTextLength"] = len(clean_cv_text) | |
| return clean_cv_text, result | |
| async def root(): | |
| return {"message": "AI Service API is running successfully"} | |
| async def health_llm(): | |
| checked_at = datetime.now(timezone.utc).isoformat() | |
| try: | |
| result = test_llm_connection() | |
| return { | |
| "status": "success", | |
| "service": "llm", | |
| "checkedAt": checked_at, | |
| **result, | |
| } | |
| except Exception as error: | |
| raise HTTPException( | |
| status_code=503, | |
| detail={ | |
| "status": "error", | |
| "service": "llm", | |
| "checkedAt": checked_at, | |
| "message": str(error), | |
| }, | |
| ) | |
| async def parse_cv(file: UploadFile = File(...)): | |
| try: | |
| content = await file.read() | |
| raw_text = extract_text_from_pdf(content) | |
| clean_cv_text = clean_text(raw_text) | |
| return { | |
| "status": "success", | |
| "clean_cv_text": clean_cv_text, | |
| } | |
| except HTTPException: | |
| raise | |
| except Exception as error: | |
| raise HTTPException(status_code=500, detail=str(error)) | |
| async def extract_profile(request: CVRequest): | |
| if not request.clean_cv_text.strip(): | |
| raise HTTPException( | |
| status_code=400, | |
| detail="clean_cv_text cannot be empty", | |
| ) | |
| result = extract_and_infer_profile(request.clean_cv_text) | |
| if result["status"] == "error": | |
| raise HTTPException(status_code=500, detail=result["message"]) | |
| return result | |
| async def analyze_cv(file: UploadFile = File(...)): | |
| try: | |
| content = await file.read() | |
| clean_cv_text, result = analyze_cv_bytes(content) | |
| return { | |
| "status": "success", | |
| "message": "CV parsed and analyzed successfully", | |
| "clean_cv_text": clean_cv_text, | |
| "data": result["data"], | |
| } | |
| except HTTPException: | |
| raise | |
| except Exception as error: | |
| raise HTTPException(status_code=500, detail=str(error)) | |
| async def start_interview_session(request: InterviewSessionRequest): | |
| profile = sanitize_profile_for_interview(request.profile) | |
| question_count = max(1, min(int(request.question_count or 5), 7)) | |
| try: | |
| try: | |
| plan = request_interview_plan(profile, question_count=question_count) | |
| source = "llm" | |
| except Exception: | |
| plan = fallback_interview_plan(profile, question_count=question_count) | |
| source = "fallback" | |
| return { | |
| "status": "success", | |
| "message": "Interview session created successfully", | |
| "data": { | |
| **plan, | |
| "questionCount": len(plan["questions"]), | |
| "source": source, | |
| }, | |
| } | |
| except Exception as error: | |
| raise HTTPException(status_code=500, detail=str(error)) | |
| async def evaluate_interview_answer(request: InterviewAnswerRequest): | |
| question = normalize_text(request.question) | |
| answer = normalize_text(request.answer) | |
| if not question: | |
| raise HTTPException(status_code=400, detail="question cannot be empty") | |
| if not answer: | |
| raise HTTPException(status_code=400, detail="answer cannot be empty") | |
| profile = sanitize_profile_for_interview(request.profile) | |
| history = request.history if isinstance(request.history, list) else [] | |
| try: | |
| try: | |
| evaluation = request_answer_evaluation(profile, question, answer, history) | |
| source = "llm" | |
| except Exception: | |
| evaluation = evaluate_answer_fallback(question, answer) | |
| source = "fallback" | |
| return { | |
| "status": "success", | |
| "message": "Interview answer evaluated successfully", | |
| "data": { | |
| **evaluation, | |
| "source": source, | |
| }, | |
| } | |
| except Exception as error: | |
| raise HTTPException(status_code=500, detail=str(error)) | |