[NOTICKET] Feat: calculate_score v2

externals/databases/pg_crud.py

@@ -1,7 +1,7 @@
 from typing import Optional, List
 from uuid import UUID
 
-from sqlalchemy import select, and_, update, delete, func
+from sqlalchemy import select, and_, or_, update, delete, func
 from sqlalchemy.ext.asyncio import AsyncSession
 from externals.databases.pg_models import (
     CVUser,
@@ -383,42 +383,48 @@ async def get_profiles_by_criteria_id(
     if filter.gpa_edu_3 is not None:
         conditions.append(CVProfile.gpa_edu_3 >= filter.gpa_edu_3)
 
-    # --- University (case-insensitive) ---
+    # --- University (case-insensitive, any match in list) ---
     if filter.univ_edu_1:
         conditions.append(
-            func.lower(CVProfile.univ_edu_1) ==
-            filter.univ_edu_1.lower()
+            func.lower(CVProfile.univ_edu_1).in_(
+                [v.lower() for v in filter.univ_edu_1]
+            )
         )
 
     if filter.univ_edu_2:
         conditions.append(
-            func.lower(CVProfile.univ_edu_2) ==
-            filter.univ_edu_2.lower()
+            func.lower(CVProfile.univ_edu_2).in_(
+                [v.lower() for v in filter.univ_edu_2]
+            )
         )
 
     if filter.univ_edu_3:
         conditions.append(
-            func.lower(CVProfile.univ_edu_3) ==
-            filter.univ_edu_3.lower()
+            func.lower(CVProfile.univ_edu_3).in_(
+                [v.lower() for v in filter.univ_edu_3]
+            )
         )
 
-    # --- Major (case-insensitive) ---
+    # --- Major (case-insensitive, any match in list) ---
     if filter.major_edu_1:
         conditions.append(
-            func.lower(CVProfile.major_edu_1) ==
-            filter.major_edu_1.lower()
+            func.lower(CVProfile.major_edu_1).in_(
+                [v.lower() for v in filter.major_edu_1]
+            )
         )
 
     if filter.major_edu_2:
         conditions.append(
-            func.lower(CVProfile.major_edu_2) ==
-            filter.major_edu_2.lower()
+            func.lower(CVProfile.major_edu_2).in_(
+                [v.lower() for v in filter.major_edu_2]
+            )
         )
 
     if filter.major_edu_3:
         conditions.append(
-            func.lower(CVProfile.major_edu_3) ==
-            filter.major_edu_3.lower()
+            func.lower(CVProfile.major_edu_3).in_(
+                [v.lower() for v in filter.major_edu_3]
+            )
         )
 
     # --- Others ---
@@ -578,19 +584,19 @@ async def get_filter(
 
     # --- University ---
     if filter.univ_edu_1:
-        conditions.append(CVFilter.univ_edu_1 == filter.univ_edu_1)
+        conditions.append(CVFilter.univ_edu_1.overlap(filter.univ_edu_1))
     if filter.univ_edu_2:
-        conditions.append(CVFilter.univ_edu_2 == filter.univ_edu_2)
+        conditions.append(CVFilter.univ_edu_2.overlap(filter.univ_edu_2))
     if filter.univ_edu_3:
-        conditions.append(CVFilter.univ_edu_3 == filter.univ_edu_3)
+        conditions.append(CVFilter.univ_edu_3.overlap(filter.univ_edu_3))
 
     # --- Major ---
     if filter.major_edu_1:
-        conditions.append(CVFilter.major_edu_1 == filter.major_edu_1)
+        conditions.append(CVFilter.major_edu_1.overlap(filter.major_edu_1))
     if filter.major_edu_2:
-        conditions.append(CVFilter.major_edu_2 == filter.major_edu_2)
+        conditions.append(CVFilter.major_edu_2.overlap(filter.major_edu_2))
     if filter.major_edu_3:
-        conditions.append(CVFilter.major_edu_3 == filter.major_edu_3)
+        conditions.append(CVFilter.major_edu_3.overlap(filter.major_edu_3))
 
     # --- Others ---
     if filter.domicile:
@@ -621,6 +627,68 @@ async def get_filter(
 
     return result.scalar_one_or_none()
 
+from services.models.data_model import Criteria
+@retry_db(retries=2, delay=2)
+async def get_multi_filter(
+    db: AsyncSession,
+    filter: Criteria,
+):
+    conditions = []
+    list_conditions = []
+
+    # --- GPA (scalar: AND) ---
+    if filter.get("gpa_edu_1") is not None:
+        conditions.append(CVFilter.gpa_edu_1 >= filter.get("gpa_edu_1"))
+    if filter.get("gpa_edu_2") is not None:
+        conditions.append(CVFilter.gpa_edu_2 >= filter.get("gpa_edu_2"))
+    if filter.get("gpa_edu_3") is not None:
+        conditions.append(CVFilter.gpa_edu_3 >= filter.get("gpa_edu_3"))
+
+    # --- Others (scalar: AND) ---
+    if filter.get("domicile"):
+        conditions.append(CVFilter.domicile == filter.get("domicile"))
+
+    if filter.get("yoe") is not None:
+        conditions.append(CVFilter.yoe >= filter.get("yoe"))
+
+    # --- University (list: OR) ---
+    if filter.get("univ_edu_1"):
+        list_conditions.append(CVFilter.univ_edu_1.in_(filter.get("univ_edu_1")))
+    if filter.get("univ_edu_2"):
+        list_conditions.append(CVFilter.univ_edu_2.in_(filter.get("univ_edu_2")))
+    if filter.get("univ_edu_3"):
+        list_conditions.append(CVFilter.univ_edu_3.in_(filter.get("univ_edu_3")))
+
+    # --- Major (list: OR) ---
+    if filter.get("major_edu_1"):
+        list_conditions.append(CVFilter.major_edu_1.in_(filter.get("major_edu_1")))
+    if filter.get("major_edu_2"):
+        list_conditions.append(CVFilter.major_edu_2.in_(filter.get("major_edu_2")))
+    if filter.get("major_edu_3"):
+        list_conditions.append(CVFilter.major_edu_3.in_(filter.get("major_edu_3")))
+
+    # --- ARRAY fields (list: OR) ---
+    if filter.get("hardskills"):
+        list_conditions.append(CVFilter.hardskills.overlap(filter.get("hardskills")))
+    if filter.get("softskills"):
+        list_conditions.append(CVFilter.softskills.overlap(filter.get("softskills")))
+    if filter.get("certifications"):
+        list_conditions.append(CVFilter.certifications.overlap(filter.get("certifications")))
+    if filter.get("business_domain"):
+        list_conditions.append(CVFilter.business_domain.overlap(filter.get("business_domain")))
+
+    if list_conditions:
+        conditions.append(or_(*list_conditions))
+
+    # ⛔ Prevent full table scan
+    if not conditions:
+        return None
+
+    stmt = select(CVFilter).where(and_(*conditions))
+    result = await db.execute(stmt)
+
+    return result.scalar_one_or_none()
+
 
 @retry_db(retries=2, delay=2)
 async def get_filter_by_id(

externals/databases/pg_models.py

@@ -114,7 +114,7 @@ class CVFilter(Base):
 
     created_at = Column(TIMESTAMP(timezone=True), server_default=master_config.JAKARTA_NOW)
 
-
+    
 class CVWeight(Base):
     __tablename__ = "cv_weight"
 

interfaces/api/agentic.py

@@ -182,10 +182,10 @@ async def calculate_score(
             "data": data
         }
     except Exception as E:
-        logger.error(f"calculate score error: {E}")
+        logger.error(f"calculate score v2 error: {E}")
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"calculate score error: {E}"
+            detail=f"calculate score v2 error: {E}"
         )
 
 # @router.get("/get_profile_table")

services/agentic/filter.py

@@ -6,7 +6,9 @@ from externals.databases.pg_crud import (
     create_filter,
     get_filter,
     get_filter_by_id,
+    get_multi_filter,
 )
+from services.models.data_model import Criteria
 from utils.logger import get_logger
 
 logger = get_logger("filter agentic service")
@@ -31,6 +33,49 @@ class AgenticFilterService:
         filter_id = await create_filter(self.db, filter)
         logger.info(f"Filter not existed yet, creating new filter: {filter_id}")
         return filter_id.criteria_id
+    
+    
+    async def create_filter_v2(self, filter: Criteria) -> str:
+        """Return criteria_id:str"""
+
+        # check filter existence
+        existing_filter = await get_multi_filter(self.db, filter)
+
+        if existing_filter:
+            logger.info(f"Filter already exists: {existing_filter}")
+            return existing_filter.criteria_id
+
+        # Convert Criteria dict → CVFilter ORM object
+        univ_edu_1_list = filter.get("univ_edu_1") or []
+        univ_edu_2_list = filter.get("univ_edu_2") or []
+        univ_edu_3_list = filter.get("univ_edu_3") or []
+        major_edu_1_list = filter.get("major_edu_1") or []
+        major_edu_2_list = filter.get("major_edu_2") or []
+        major_edu_3_list = filter.get("major_edu_3") or []
+
+        cv_filter = CVFilter(
+            gpa_edu_1=filter.get("gpa_edu_1"),
+            gpa_edu_2=filter.get("gpa_edu_2"),
+            gpa_edu_3=filter.get("gpa_edu_3"),
+            univ_edu_1=univ_edu_1_list[0] if univ_edu_1_list else None,
+            univ_edu_2=univ_edu_2_list[0] if univ_edu_2_list else None,
+            univ_edu_3=univ_edu_3_list[0] if univ_edu_3_list else None,
+            major_edu_1=major_edu_1_list[0] if major_edu_1_list else None,
+            major_edu_2=major_edu_2_list[0] if major_edu_2_list else None,
+            major_edu_3=major_edu_3_list[0] if major_edu_3_list else None,
+            domicile=filter.get("domicile"),
+            yoe=filter.get("yoe"),
+            hardskills=filter.get("hardskills") or [],
+            softskills=filter.get("softskills") or [],
+            certifications=filter.get("certifications") or [],
+            business_domain=filter.get("business_domain") or [],
+        )
+        logger.info(f">>> cv_filter: {cv_filter}")
+
+        # create filter
+        filter_id = await create_filter(self.db, cv_filter)
+        logger.info(f"Filter not existed yet, creating new filter: {filter_id.criteria_id}")
+        return filter_id.criteria_id
 
     
     async def get_filter_by_id(self, criteria_id: str) -> CVFilter:

services/agentic/profile_scoring.py

@@ -15,6 +15,7 @@ from services.models.data_model import (
                                             Criteria, 
                                             CriteriaWeight,
                                             InputScoringBulk,
+                                            AIProfileTbScore,
                                             LOGIC_NUMERIC, 
                                             LOGIC_CATEGORICAL, 
                                             # InputScoring, 
@@ -85,12 +86,12 @@ def helper_judge_scoring(a_profile, b_criteria, rules) -> bool:
 #     return comparison
 
 
-def comparison_parser(profile:AIProfile, criteria:Criteria):
-    comparison = "| parameter | candidate_profile | criteria | true_if_rules | draft_matching_score |"
+def comparison_parser(profile:AIProfileTbScore, criteria:Criteria):
+    comparison = "| parameter | candidate_profile | job criteria | true_if_rules | draft_matching_score |"
     comparison += "\n| --- | --- | --- | --- | --- |"
     
     for k, v in criteria.items():
-        print(f" key comparison: {k}")
+        # print(f" key comparison: {k}")
         op = helper_get_operator(k)
         if ('gpa' in k or 'yoe' in k) and (profile.get(k) is not None) and (v is not None):
             judges = helper_judge_scoring(a_profile=profile.get(k), 
@@ -99,7 +100,7 @@ def comparison_parser(profile:AIProfile, criteria:Criteria):
             comparison += f"\n| {k} | {profile.get(k)} | {v} | {op} | {judges} |"
         else:
             judges = '???'
-            comparison += f"\n| {k} | {profile.get(k)} | NA | NA | False |"
+            comparison += f"\n| {k} | {profile.get(k)} | {v} | related | False |"
     return comparison
 
 
@@ -380,7 +381,7 @@ class AgenticScoringService:
         self.weight_service = AgenticWeightService(db=db, user=user)
         self.profile_service = KnowledgeGetProfileService(db=db, user=user)
 
-    async def _ai_matching(self, profile:AIProfile, criteria:Criteria) -> AIMatchProfile:
+    async def _ai_matching(self, profile:AIProfileTbScore, criteria:Criteria) -> AIMatchProfile:
         "Helper function to matching between a profile and criteria"
 
         comparison_text = comparison_parser(profile=profile, criteria=criteria)
@@ -424,13 +425,14 @@ class AgenticScoringService:
         return matching_result
 
     async def _ai_matching_bulk(self, 
-                                profiles:List, 
+                                profiles:List[AIProfileTbScore], 
                                 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)
+                print(f"==> {i+1} profile: {p} vs criteria: {criteria}")
+                logger.info(f">>> _ai_matching_bulk/tmp_matching: {tmp_matching}")
                 results.append(tmp_matching)
             return results
         except Exception as E:
@@ -487,8 +489,11 @@ class AgenticScoringService:
             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)
+            
+            match_result_dict = {c.name: getattr(match_result, c.name) for c in CVMatching.__table__.columns}
+            print(f"{i+1} match_result: {match_result_dict} vs weight_data: {weight_data}")
+            print(f"temp.score: {temp.score}")
+
             scores.append(temp)
         return scores
 
@@ -587,32 +592,13 @@ class AgenticScoringService:
             # Create criteria_id
             filter_svc = AgenticFilterService(db=self.db, user=self.user)
             criteria = requirements.get("criteria")
-            weight = requirements.get("criteria_weight")
-            
-            cv_filter = CVFilter(
-                criteria_id=uuid4(),
-
-                gpa_edu_1=filter.get("gpa_edu_1"),
-                gpa_edu_2=filter.get("gpa_edu_2"),
-                gpa_edu_3=filter.get("gpa_edu_3"),
-
-                univ_edu_1=filter.get("univ_edu_1"),
-                univ_edu_2=filter.get("univ_edu_2"),
-                univ_edu_3=filter.get("univ_edu_3"),
+            print(f"DEBUG: scoring_v2/criteria: {criteria}")
 
-                major_edu_1=filter.get("major_edu_1"),
-                major_edu_2=filter.get("major_edu_2"),
-                major_edu_3=filter.get("major_edu_3"),
-
-                domicile=filter.get("domicile"),
-                yoe=filter.get("yoe"),
+            weight = requirements.get("criteria_weight")
+            print(f"DEBUG: scoring_v2/weight: {weight}")
 
-                hardskills=filter.get("hardskills"),
-                softskills=filter.get("softskills"),
-                certifications=filter.get("certifications"),
-                business_domain=filter.get("business_domain")
-            )
-            criteria_id = await filter_svc.create_filter(filter=cv_filter)
+            criteria_id = await filter_svc.create_filter_v2(filter=criteria)
+            print(f"DEBUG: scoring_v2/criteria_id: {criteria_id}")
 
             
             weight_svc = AgenticWeightService(db=self.db, user=self.user)
@@ -648,9 +634,9 @@ class AgenticScoringService:
             all_profiles = await get_profiles_by_user_id(db=self.db, current_user=self.user)
             print(f"🫡 Found {len(all_profiles)} profiles to be scored")
             
-            all_tobe_scored = []
+            all_tobe_scored:list[AIProfileTbScore] = []
             for p in all_profiles:
-                tmp_profile = AIProfile(
+                tmp_profile = AIProfileTbScore(
                     fullname=p.fullname,
                     gpa_edu_1=p.gpa_edu_1,
                     univ_edu_1=p.univ_edu_1,
@@ -684,6 +670,6 @@ class AgenticScoringService:
             
             return scores
         except Exception as E: 
-            logger.error(f"profile scoring error, {E}")
+            logger.error(f"profile scoring v2 error, {E}")
             traceback.print_exc() 
             raise

services/models/data_model.py

@@ -52,6 +52,31 @@ class AIProfile(TypedDict):
     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 AIProfileTbScore(TypedDict):
+    fullname: str = Field(description="Fullname of the candidate", default="-")
+    # gender: str = Field(description="Gender of the candidate, if available", default="null")
+    # age: int = Field(description="Age in number")
+    gpa_edu_1: float = Field(description="""GPA of candidate's bachelor degree (same like sarjana, s1, undergradute), if exists.""", default=0)
+    univ_edu_1: list = Field(description="""University where candidate take bachelor degree, if exists.""", default="-")
+    major_edu_1: list = Field(description="""Major of candidate's bachelor degree, if exists.""", default="-")
+    
+    gpa_edu_2: float = Field(description="""GPA of candidate's master degree (same like master, s2, postgraduate), if exists.""", default=0)
+    univ_edu_2: list = Field(description="""University where candidate take master degree, if exists.""", default="-")
+    major_edu_2: list = Field(description="""Major of candidate's master degree, if exists.""", default="-")
+    
+    gpa_edu_3: float = Field(description="""GPA of candidate's doctoral or phd degree (same like phd, s3, doctoral), if exists.""", default=0)
+    univ_edu_3: list = Field(description="""University where candidate take doctoral or phd degree, if exists.""", default="-")
+    major_edu_3: list = Field(description="""Major of candidate's doctoral or phd degree, if exists.""", default="-")
+    
+    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_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
     created_at: datetime = datetime.now().replace(tzinfo=tzinfo)