import logging from fastapi import FastAPI, HTTPException, Body, Query from fastapi.middleware.cors import CORSMiddleware from typing import List, Dict, Any from ats_pipeline.schemas import ( Resume, JobDescription, MatchRequest, MatchResponse, FeatureRequest, FeatureResponse, SkillRequest, SkillResponse, SemanticIndexRequest, SearchResult, SampleDataResponse ) from ats_pipeline.core import ( load_data, parse_resume_text, extract_features, get_jd_search_rankings, get_sample_data, build_and_save_semantic_index, semantic_search_jobs, canonicalize_skills as util_canonicalize_skills, is_semantic_index_ready, get_dataset_status ) # Configure logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) # --- FastAPI App Initialization --- app = FastAPI( title="ATS Scoring and Matching Pipeline API", description="A modular API for parsing resumes, extracting features, and matching them against job descriptions.", version="0.1.0" ) # --- Middleware --- # WARNING: This is a permissive CORS configuration for development. # Tighten these rules for production environments. app.add_middleware( CORSMiddleware, allow_origins=["*"], # Allows all origins allow_credentials=True, allow_methods=["*"], # Allows all methods allow_headers=["*"], # Allows all headers ) # --- API Endpoints --- @app.get("/health", summary="Health Check", tags=["General"]) def read_root(): """Check if the API is running.""" return {"status": "ok", "version": app.version} @app.post("/parse_resume", response_model=Resume, summary="Parse Resume Text", tags=["Parsing"]) def parse_resume(resume_text: str = Body(..., embed=True, description="The full text content of the resume.")): """ Parses raw resume text to extract structured information like skills, experience, and education. """ try: parsed_data = parse_resume_text(resume_text) return Resume(**parsed_data) except Exception as e: logger.error(f"Error parsing resume: {e}", exc_info=True) raise HTTPException(status_code=500, detail="Failed to parse resume text.") @app.post("/features", response_model=FeatureResponse, summary="Extract Rich Features", tags=["Features"]) def get_features(request: FeatureRequest): """ Extracts a comprehensive set of features from a resume and a target job description. This includes resume-only features and comparison features. """ try: features = extract_features(request.resume, request.jd) return FeatureResponse(features=features) except Exception as e: logger.error(f"Error extracting features: {e}", exc_info=True) raise HTTPException(status_code=500, detail="Failed to extract features.") @app.post("/match", response_model=MatchResponse, summary="Match Resume to Job Description", tags=["Matching"]) def match_resume_to_jd(request: MatchRequest): """ Calculates a match score between a resume and a job description. This is the core endpoint that orchestrates parsing, feature extraction, and scoring. """ try: # 1. Parse the resume text parsed_resume_data = parse_resume_text(request.resume_text) resume = Resume(**parsed_resume_data) # 2. Extract features based on the parsed resume and the provided JD features = extract_features(resume, request.jd) # 3. The match score is part of the extracted features match_score = features.get("jd_aware_features", {}).get("match_score", 0.0) return MatchResponse( match_score=match_score, resume=resume, features=features ) except Exception as e: logger.error(f"Error during matching process: {e}", exc_info=True) raise HTTPException(status_code=500, detail="An unexpected error occurred during the matching process.") @app.post("/canonicalize_skills", response_model=List[SkillResponse], summary="Canonicalize Raw Skills", tags=["Utilities"]) def canonicalize_skills_endpoint(request: SkillRequest): """ Maps a list of raw skill strings to their canonical forms using ESCO/O*NET datasets. """ try: canonicalized = util_canonicalize_skills(request.raw_skills) return [SkillResponse(raw_skill=k, canonical_skill=v) for k, v in canonicalized.items()] except Exception as e: logger.error(f"Error canonicalizing skills: {e}", exc_info=True) raise HTTPException(status_code=500, detail="Failed to canonicalize skills.") @app.get("/search_jd", response_model=List[SearchResult], summary="Search Job Descriptions (BM25)", tags=["Search"]) def search_jd(q: str = Query(..., description="The search query string.")): """ Performs a lightweight keyword search over job descriptions using the BM25 algorithm. """ try: results = get_jd_search_rankings(q) return results except Exception as e: logger.error(f"Error during BM25 search: {e}", exc_info=True) raise HTTPException(status_code=500, detail="Failed to perform BM25 search.") @app.get("/dataset_status", summary="Get Dataset Status", tags=["Data"]) def get_data_status(): """Checks the availability and status of the required datasets.""" return get_dataset_status() @app.get("/sample_data", response_model=SampleDataResponse, summary="Get Sample Data", tags=["Data"]) def fetch_sample_data(): """Retrieves a sample resume and job description for demonstration purposes.""" try: return get_sample_data() except Exception as e: logger.error(f"Could not fetch sample data: {e}", exc_info=True) raise HTTPException(status_code=404, detail="Sample data not found or failed to load.") @app.post("/build_semantic_index", summary="Build FAISS Index", tags=["Search"]) async def build_semantic_index(request: SemanticIndexRequest): """ Builds and saves a FAISS index for semantic search. This can be a long-running operation. """ try: logger.info(f"Starting semantic index build for dataset: {request.dataset} with limit: {request.limit}") result = build_and_save_semantic_index(dataset_name=request.dataset, limit=request.limit, persist=request.persist) logger.info("Semantic index build completed.") return result except Exception as e: logger.error(f"Failed to build semantic index: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to build semantic index: {str(e)}") @app.get("/semantic_search", response_model=List[SearchResult], summary="Semantic Search (FAISS)", tags=["Search"]) def semantic_search(q: str = Query(..., description="The search query for semantic similarity search."), k: int = Query(5, ge=1, le=50, description="Number of results to return.")): """ Performs a semantic search using the pre-built FAISS index to find the most similar job descriptions. """ if not is_semantic_index_ready(): raise HTTPException(status_code=400, detail="Semantic index has not been built. Please call POST /build_semantic_index first.") try: results = semantic_search_jobs(q, k) return results except Exception as e: logger.error(f"Error during semantic search: {e}", exc_info=True) raise HTTPException(status_code=500, detail="Failed to perform semantic search.") # --- Application Startup Logic --- @app.on_event("startup") async def startup_event(): """ On application startup, log status and load necessary models and data. """ logger.info("Application startup...") logger.info("Loading datasets and initializing search models...") try: # This function pre-caches the necessary data and models on startup load_data() logger.info("Successfully loaded initial data and models.") except Exception as e: logger.error(f"Failed to load data on startup: {e}", exc_info=True) # Depending on the use case, you might want to prevent the app from starting # raise RuntimeError("Could not initialize application data.")