[NOTICKET] Feat: Matching and Scoring

externals/databases/pg_crud.py

@@ -267,6 +267,12 @@ async def get_profile_by_filename(
     result = await db.execute(stmt)
     return result.scalar_one_or_none()
 
+async def get_profiles(
+    db: AsyncSession,
+) -> List[CVProfile]:
+    stmt = select(CVProfile)
+    result = await db.execute(stmt)
+    return result.scalars().all()
 
 async def get_profile_by_id(
     db: AsyncSession,
@@ -382,7 +388,7 @@ async def get_filter_and_weight(
         .where(CVFilter.criteria_id == criteria_id)
     )
     result = await db.execute(stmt)
-    return result.first()
+    return result.scalar_one_or_none()
 
 
 async def get_weight_by_id(
@@ -391,11 +397,10 @@ async def get_weight_by_id(
 ):
     stmt = (
         select(CVWeight)
-        .where(CVFilter.weight_id == weight_id)
+        .where(CVWeight.weight_id == weight_id)
     )
     result = await db.execute(stmt)
-    return result.first()
-
+    return result.scalar_one_or_none()
 
 async def create_filter_and_weight(
     db: AsyncSession,
@@ -427,6 +432,27 @@ async def create_matching(
     return matching
 
 
+from services.models.data_model import AIMatchProfile
+
+async def create_matchings(
+    db: AsyncSession,
+    matchings: list,
+) -> list[CVMatching]:
+    try:
+        orm_objects = [
+            CVMatching(**matching)
+            for matching in matchings
+        ]
+        db.add_all(orm_objects)
+        await db.commit()
+        for obj in orm_objects:
+            await db.refresh(obj)
+        return orm_objects
+    except Exception as E:
+        print(f"Error creating matchings: {E}")
+        raise
+
+
 async def get_matching_by_profile_and_criteria(
     db: AsyncSession,
     profile_id: str,
@@ -459,6 +485,21 @@ async def create_score(
     return score
 
 
+async def create_scores(
+    db: AsyncSession,
+    scores: list[CVScore],
+) -> list[CVScore]:
+    try:
+        db.add_all(scores)
+        await db.commit()
+        for score in scores:
+            await db.refresh(score)
+        return scores
+    except Exception as E:
+        print(f"Error creating scores: {E}")
+        raise
+
+
 async def get_scores_by_criteria(
     db: AsyncSession,
     criteria_id: str,

externals/databases/pg_models.py

@@ -104,7 +104,7 @@ class CVFilter(Base):
 class CVWeight(Base):
     __tablename__ = "cv_weight"
 
-    weight_id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    weight_id = Column(UUID(as_uuid=True), primary_key=True, server_default=master_config.JAKARTA_NOW)
     criteria_id = Column(UUID(as_uuid=True), primary_key=False, nullable=False)
 
     gpa_edu_1 = Column(DOUBLE_PRECISION)
@@ -135,7 +135,7 @@ class CVMatching(Base):
 
     matching_id = Column(UUID(as_uuid=True), primary_key=True, server_default=func.uuid_generate_v4())
     profile_id = Column(UUID(as_uuid=True))
-    criteria_id = Column(UUID(as_uuid=True))
+    weight_id = Column(UUID(as_uuid=True))
 
     gpa_edu_1 = Column(BOOLEAN)
     gpa_edu_2 = Column(BOOLEAN)
@@ -165,6 +165,7 @@ class CVScore(Base):
 
     scoring_id = Column(UUID(as_uuid=True), primary_key=True, server_default=func.uuid_generate_v4())
     matching_id = Column(UUID(as_uuid=True))
+    profile_id = Column(UUID(as_uuid=True))
     score = Column(Integer)
 
     created_at = Column(TIMESTAMP(timezone=True), server_default=master_config.JAKARTA_NOW)

interfaces/api/agentic.py

@@ -147,9 +147,21 @@ async def calculate_score(
     db=Depends(get_db),
     current_user: CVUser = Depends(get_current_user),
 ):
-    # TODO: endpoint to calculate profile matching
-    pass
-
+    try:
+        agentic_service = AgenticService(db=db, 
+                                        user=current_user)
+        data = await agentic_service.score.scoring(weight_id=weight_id)
+        return {
+            "status": "success",
+            "message": "Score calculated successfully",
+            "data": data
+        }
+    except Exception as E:
+        logger.error(f"calculate score error: {E}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"calculate score error: {E}"
+        )
 
 # @router.get("/get_profile_table")
 # async def get_profile_table(

interfaces/handlers/handlers.py

@@ -1,2 +0,0 @@
-
-

services/agentic/agentic_setup.py

@@ -2,8 +2,8 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from externals.databases.pg_models import CVUser
 from services.agentic.filter import AgenticFilterService
 from services.agentic.weight import AgenticWeightService
+from services.agentic.profile_scoring import AgenticScoringService
 # from services.agentic.matching import AgenticMatchingService
-# from services.agentic.profile_scoring import AgenticScoringService
 
 
 from utils.logger import get_logger
@@ -21,6 +21,8 @@ class AgenticService:
 
         self.filter = AgenticFilterService(db, user)
         self.weight = AgenticWeightService(db, user)
+        self.score = AgenticScoringService(db, user)
+
         # self.filter = AgenticMatchingService(db, user)
         # self.filter = AgenticScoringService(db, user)
 

services/agentic/profile_scoring.py

@@ -1,30 +1,32 @@
-# from typing import List
+import traceback
+from typing import List
 from langchain_core.prompts import ChatPromptTemplate
 
 from config.constant import ProfileFieldTypes
-from externals.databases.pg_crud import get_criteria_id, create_cv_filter, create_cv_matching, get_matching_id, create_cv_score, get_scoring_id
-from externals.databases.pg_models import CVProfile, CVWeight, CVFilter
+# from externals.databases.pg_crud import get_criteria_id, create_cv_filter, create_cv_matching, get_matching_id, create_cv_score, get_scoring_id
+from externals.databases.pg_models import CVProfile, CVWeight, CVFilter, CVScore, CVMatching
 from services.llms.LLM import model_4o_2
 from services.base.BaseGenerator import BaseAIGenerator, MetadataObservability
-from models.data_model import AIProfile
+from services.models.data_model import AIProfile
 from services.models.data_model import (
                                             AIMatchProfile, 
                                             Criteria, 
                                             CriteriaWeight,
                                             LOGIC_NUMERIC, 
                                             LOGIC_CATEGORICAL, 
-                                            InputScoring, 
-                                            DataResponseMatchOne, 
-                                            ResponseMatchOne,
-                                            InputScoringBulk, 
-                                            DataResponseMatchBulk,
-                                            ResponseMatchBulk
+                                            # InputScoring, 
+                                            # DataResponseMatchOne, 
+                                            # ResponseMatchOne,
+                                            # InputScoringBulk, 
+                                            # DataResponseMatchBulk,
+                                            # ResponseMatchBulk
                                             )
 # from services.knowledge.knowledge_setup import KnowledgeService
 from services.agentic.weight import AgenticWeightService
 from services.agentic.filter import AgenticFilterService
 from services.knowledge.get_profile import KnowledgeGetProfileService
 from sqlalchemy.ext.asyncio import AsyncSession
+from externals.databases.pg_crud import get_profiles, create_matchings, create_scores
 from utils.logger import get_logger
 
 
@@ -41,18 +43,22 @@ def helper_get_operator(col_name: str):
         return op
 
 def helper_judge_scoring(a_profile, b_criteria, rules) -> bool:
-    if rules == "greater than":
-        return int(a_profile > b_criteria)
-    elif rules == "less than":
-        return int(a_profile < b_criteria)
-    elif rules == "equal":
-        return int(a_profile == b_criteria)
-    elif rules == "greater than or equal":
-        return int(a_profile >= b_criteria)
-    elif rules == "less than or equal":
-        return int(a_profile <= b_criteria)
-    return 0
-
+    try:
+        if rules == "greater than":
+            return int(a_profile > b_criteria)
+        elif rules == "less than":
+            return int(a_profile < b_criteria)
+        elif rules == "equal":
+            return int(a_profile == b_criteria)
+        elif rules == "greater than or equal":
+            return int(a_profile >= b_criteria)
+        elif rules == "less than or equal":
+            return int(a_profile <= b_criteria)
+        return 0
+    except Exception as E:
+        logger.error(f"❌ error in helper_judge_scoring: {E}")
+        logger.error(f"a_profile={a_profile}, b_criteria={b_criteria}")
+        return 0
 
 # @deprecated
 # def comparison_parser(input_scoring: InputScoring):
@@ -81,10 +87,11 @@ def comparison_parser(profile:AIProfile, criteria:Criteria):
     comparison += "\n| --- | --- | --- | --- | --- |"
     
     for k, v in criteria.items():
+        print(f" key comparison: {k}")
         op = helper_get_operator(k)
         if 'gpa' in k or 'yoe' in k:
             judges = helper_judge_scoring(a_profile=profile.get(k), 
-                                            b_criteria=v, 
+                                            b_criteria=v,
                                             rules=op)
         else:
             judges = '???'
@@ -409,6 +416,20 @@ class AgenticScoringService:
 
         matching_result = await gen_ai.agenerate()
         return matching_result
+
+    async def _ai_matching_bulk(self, 
+                                profiles:List, 
+                                criteria:Criteria) -> List:
+        try:
+            results = []
+            for i, p in enumerate(profiles):
+                print(f"==> {i+1} profile: {p} vs criteria: {criteria}")
+                tmp_matching:AIMatchProfile = await self._ai_matching(profile=p, criteria=criteria)
+                results.append(tmp_matching)
+            return results
+        except Exception as E:
+            print(f"❌ error in _ai_matching_bulk: {E}")
+            raise
     
     def _calculate_score(self, match_result:AIMatchProfile, weight_data:CriteriaWeight) -> float:
         """Returns matching score (float) with min-max is 0-100.0
@@ -427,99 +448,128 @@ class AgenticScoringService:
         # weight_data = self.weight_service.get_weight_by_weight_id(weight_id)
 
         for k, v in weight_data.items():
-            if k.startswith("w_") and v:
-                total_weight += v
+            total_weight += v
 
-        # logger.info(f"👁️ helper_calculate_score/total_weight: {total_weight}")
+        logger.info(f"👁️ helper_calculate_score/total_weight: {total_weight}")
         
         if total_weight > 1.0:
             # normalized weight
             for k, v in weight_data.items():
-                if k.startswith("w_") and v:
-                    norm_criteria[k] = v/total_weight
+                norm_criteria[k] = v/total_weight
         else:
             norm_criteria = weight_data.copy()
         
         # logger.info(f"👁️ helper_calculate_score/norm_criteria: {norm_criteria}")
+        match_dict = {
+            column.name: getattr(match_result, column.name)
+            for column in match_result.__table__.columns
+        }
 
-        for k, value_comparison in match_result.items():
-            if f"w_{k}" in norm_criteria and value_comparison:
-                temp_score = norm_criteria[f"w_{k}"] * value_comparison * 100
-                # logger.info(f"👁️ w_{k}: {temp_score}")
-                
+        for k, value_comparison in match_dict.items():
+            if k in norm_criteria and value_comparison:
+                temp_score = norm_criteria[k] * value_comparison * 100
                 score += temp_score
 
         # logger.info(f"👁️ helper_calculate_score/score: {score}")
         return score
 
-    async def scoring(self, profile_id: str, criteria_id: str, weight_id: str):
+        
+    def _calculate_score_bulk(self, match_results:List[CVMatching], weight_data:CriteriaWeight) -> List[CVScore]:
+        scores = []
+        for i, match_result in enumerate(match_results):
+            temp = CVScore()
+            temp.profile_id = match_result.profile_id
+            temp.matching_id = match_result.matching_id
+            temp.score = self._calculate_score(match_result=match_result, weight_data=weight_data)
+            # print(f"{i+1} match_result: {match_result} vs weight_data: {weight_data}")
+            # score = self._calculate_score(match_result=match_result, weight_data=weight_data)
+            scores.append(temp)
+        return scores
+
+    async def scoring(self, weight_id: str):
         try:
-            _profile:CVProfile = self.profile_service.get_profile(profile_id=profile_id)
-            _criteria:CVFilter = self.criteria_service.get_filter_by_id(criteria_id=criteria_id)
-            _weight:CVWeight = self.weight_service.get_weight_by_weight_id(weight_id=weight_id)
+            # Get profile data all
+            all_profiles = await get_profiles(self.db)
+            print(f"Found {len(all_profiles)} profiles to be scored")
+            all_profiles = all_profiles[:5] # FIXME: DELETE LATER
             
-            profile = AIProfile(
-                fullname=_profile.get("fullname"),
-                gpa_edu_1=_profile.get("gpa_edu_1"),
-                univ_edu_1=_profile.get("univ_edu_1"),
-                major_edu_1=_profile.get("major_edu_1"),
-                gpa_edu_2=_profile.get("gpa_edu_2"),
-                univ_edu_2=_profile.get("univ_edu_2"),
-                major_edu_2=_profile.get("major_edu_2"),
-                gpa_edu_3=_profile.get("gpa_edu_3"),
-                univ_edu_3=_profile.get("univ_edu_3"),
-                major_edu_3=_profile.get("major_edu_3"),
-                domicile=_profile.get("domicile"),
-                yoe=_profile.get("yoe"),
-                hardskills=_profile.get("hardskills"),
-                softskills=_profile.get("softskills"),
-                certifications=_profile.get("certifications"),
-                business_domain=_profile.get("business_domain")
-            )
+            _weight:CVWeight = await self.weight_service.get_weight_by_weight_id(weight_id=weight_id)
+            print(f"Found weight: {_weight}")
+            print(f"--> criteria id: {_weight.criteria_id}")
+
+            _criteria:CVFilter = await self.criteria_service.get_filter_by_id(criteria_id=_weight.criteria_id)
+            
+            all_tobe_scored = []
+            for p in all_profiles:
+                tmp_profile = AIProfile(
+                    fullname=p.fullname,
+                    gpa_edu_1=p.gpa_edu_1,
+                    univ_edu_1=p.univ_edu_1,
+                    major_edu_1=p.major_edu_1,
+                    gpa_edu_2=p.gpa_edu_2,
+                    univ_edu_2=p.univ_edu_2,
+                    major_edu_2=p.major_edu_2,
+                    gpa_edu_3=p.gpa_edu_3,
+                    univ_edu_3=p.univ_edu_3,
+                    major_edu_3=p.major_edu_3,
+                    domicile=p.domicile,
+                    yoe=p.yoe,
+                    hardskills=p.hardskills,
+                    softskills=p.softskills,
+                    certifications=p.certifications,
+                    business_domain=p.business_domain
+                )
+                all_tobe_scored.append(tmp_profile)
 
             criteria = Criteria(
-                gpa_edu_1=_criteria.get("gpa_edu_1"),
-                univ_edu_1=_criteria.get("univ_edu_1"),
-                major_edu_1=_criteria.get("major_edu_1"),
-                gpa_edu_2=_criteria.get("gpa_edu_2"),
-                univ_edu_2=_criteria.get("univ_edu_2"),
-                major_edu_2=_criteria.get("major_edu_2"),
-                gpa_edu_3=_criteria.get("gpa_edu_3"),
-                univ_edu_3=_criteria.get("univ_edu_3"),
-                major_edu_3=_criteria.get("major_edu_3"),
-                domicile=_criteria.get("domicile"),
-                yoe=_criteria.get("yoe"),
-                hardskills=_criteria.get("hardskills"),
-                softskills=_criteria.get("softskills"),
-                certifications=_criteria.get("certifications"),
-                business_domain=_criteria.get("business_domain")
+                gpa_edu_1=_criteria.gpa_edu_1,
+                univ_edu_1=_criteria.univ_edu_1,
+                major_edu_1=_criteria.major_edu_1,
+                gpa_edu_2=_criteria.gpa_edu_2,
+                univ_edu_2=_criteria.univ_edu_2,
+                major_edu_2=_criteria.major_edu_2,
+                gpa_edu_3=_criteria.gpa_edu_3,
+                univ_edu_3=_criteria.univ_edu_3,
+                major_edu_3=_criteria.major_edu_3,
+                domicile=_criteria.domicile,
+                yoe=_criteria.yoe,
+                hardskills=_criteria.hardskills,
+                softskills=_criteria.softskills,
+                certifications=_criteria.certifications,
+                business_domain=_criteria.business_domain
             )
 
             weight = CriteriaWeight(
-                gpa_edu_1=_weight.get("gpa_edu_1"),
-                univ_edu_1=_weight.get("univ_edu_1"),
-                major_edu_1=_weight.get("major_edu_1"),
-                gpa_edu_2=_weight.get("gpa_edu_2"),
-                univ_edu_2=_weight.get("univ_edu_2"),
-                major_edu_2=_weight.get("major_edu_2"),
-                gpa_edu_3=_weight.get("gpa_edu_3"),
-                univ_edu_3=_weight.get("univ_edu_3"),
-                major_edu_3=_weight.get("major_edu_3"),
-                domicile=_weight.get("domicile"),
-                yoe=_weight.get("yoe"),
-                hardskills=_weight.get("hardskills"),
-                softskills=_weight.get("softskills"),
-                certifications=_weight.get("certifications"),
-                business_domain=_weight.get("business_domain")
+                gpa_edu_1=_weight.gpa_edu_1,
+                univ_edu_1=_weight.univ_edu_1,
+                major_edu_1=_weight.major_edu_1,
+                gpa_edu_2=_weight.gpa_edu_2,
+                univ_edu_2=_weight.univ_edu_2,
+                major_edu_2=_weight.major_edu_2,
+                gpa_edu_3=_weight.gpa_edu_3,
+                univ_edu_3=_weight.univ_edu_3,
+                major_edu_3=_weight.major_edu_3,
+                domicile=_weight.domicile,
+                yoe=_weight.yoe,
+                hardskills=_weight.hardskills,
+                softskills=_weight.softskills,
+                certifications=_weight.certifications,
+                business_domain=_weight.business_domain
             )
 
-            match_result:AIMatchProfile = await self._ai_matching(profile, criteria)
-            score = self._calculate_score(match_result=match_result, weight_data=weight)
-
-            return score
+            match_results:List[AIMatchProfile] = await self._ai_matching_bulk(all_tobe_scored, criteria)
+            # match_results kurang profile_id dan criteria id
+            match_results = [{"profile_id": p.profile_id, "weight_id": weight_id, **match_results[i]} for i, p in enumerate(all_profiles)]
+            # Insert Match Result to DB
+            matchings = await create_matchings(self.db, match_results) 
+            
+            score_results = self._calculate_score_bulk(match_results=matchings, weight_data=weight)
+            
+            # Insert Score Result to DB
+            scores = await create_scores(self.db, score_results)
+            
+            return scores
         except Exception as E: 
             logger.error(f"profile scoring error, {E}")
+            traceback.print_exc() 
             raise
-
-
-        

services/agentic/score.py

@@ -0,0 +1,42 @@
+import os, sys
+
+from fastapi import HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from externals.databases.pg_models import CVWeight
+from externals.databases.pg_crud import (
+    create_filter,
+    get_filter_by_id,
+    create_weight,
+    get_weight_by_id
+)
+from utils.logger import get_logger
+
+logger = get_logger("weight agentic service")
+
+
+class AgenticScoreService:
+    def __init__(self, db: AsyncSession, user):
+        self.db = db
+        self.user = user
+    
+    async def calculate_score(self, weight_id: str) -> dict:
+        """Return criteria_id:str"""
+        
+        try:
+            weight_data = await get_weight_by_id(db=self.db, weight_id=weight_id)
+
+            filters = await get_filter_by_id(db=self.db, criteria_id=weight_data.criteria_id)
+            weights = {field: getattr(weight_data, field) for field in weight_data.__table__.columns.keys() if field not in ["created_at", "_sa_instance_state", "criteria_id", "weight_id"]}
+
+            # Calculate Matching
+
+            # Calculate Scoring
+
+
+        except Exception as E:
+            logger.error(f"get weight by weight id error, {E}")
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=f"get weight by weight id error: {E}"
+            )

services/models/data_model.py

@@ -47,10 +47,10 @@ class AIProfile(TypedDict):
     domicile: str = Field(description="Current domicile of the candidate", default="-")
 
     yoe: float = Field(description="The candidate's total years of experience (as an float)", default=0)
-    hardskills: Optional[List[str]] = Field(description="List of the candidate's hard skills", default=[])
-    softskills: Optional[List[str]] = Field(description="List of the candidate's soft skills", default=[])
-    certifications: Optional[List[str]] = Field(description="List of the candidate's certifications", default=[])
-    business_domain: Optional[List[str]] = Field(description="List of the candidate's business domain experience based on working experience or project", default=[])
+    hardskills: Optional[List[str]] = Field(description="List of the candidate's hard skills",default_factory=list)
+    softskills: Optional[List[str]] = Field(description="List of the candidate's soft skills", default_factory=list)
+    certifications: Optional[List[str]] = Field(description="List of the candidate's certifications", default_factory=list)
+    business_domain: Optional[List[str]] = Field(description="List of the candidate's business domain experience based on working experience or project", default_factory=list)
 
 class Profile(AIProfile):
     profile_id: str