[NOTICKET] Add new endpoint /v2/calculate_score

externals/databases/pg_crud.py

@@ -338,6 +338,20 @@ async def get_profiles(
     result = await db.execute(stmt)
     return result.scalars().all()
 
+@retry_db(retries=2, delay=2)
+async def get_profiles_by_user_id(
+    db: AsyncSession,
+    current_user: CVUser,
+) -> List[CVProfile]:
+    stmt = (
+        select(CVProfile)
+        .join(CVFile, CVProfile.file_id == CVFile.file_id)
+        .where(CVFile.user_id == current_user.user_id)
+    )
+    result = await db.execute(stmt)
+    return result.scalars().all()
+
+
 
 from sqlalchemy import select, and_, func, cast, String
 from sqlalchemy.ext.asyncio import AsyncSession

interfaces/api/agentic.py

@@ -7,6 +7,7 @@ from services.agentic.agentic_setup import AgenticService
 from services.knowledge.knowledge_setup import KnowledgeService
 from services.models.data_model import (Criteria,
                                         CriteriaWeight,
+                                        InputScoringBulk,
                                         PayloadMatchOne, 
                                             ResponseMatchOne, 
                                             DataResponseMatchOne, 
@@ -163,6 +164,30 @@ async def calculate_score(
             detail=f"calculate score error: {E}"
         )
 
+
+@router.post("/v2/calculate_score")
+async def calculate_score(
+    requirements: InputScoringBulk,
+    current_user: CVUser = Depends(get_current_user),
+    db=Depends(get_db),
+):
+    try:
+        agentic_service = AgenticService(db=db, 
+                                        user=current_user)
+        
+        data = await agentic_service.score.scoring_v2(requirements=requirements)
+        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(
 #     limit: int,

services/agentic/profile_scoring.py

@@ -6,7 +6,7 @@ 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, CVScore, CVMatching
-from services.llms.LLM import model_4o_2
+from services.llms.LLM import model_4o_2, model_5_1
 # from services.base.BaseGenerator import BaseAIGenerator, MetadataObservability
 from services.base.BaseGenerator_v2 import BaseAIGenerator, MetadataObservability
 from services.models.data_model import AIProfile
@@ -14,6 +14,7 @@ from services.models.data_model import (
                                             AIMatchProfile, 
                                             Criteria, 
                                             CriteriaWeight,
+                                            InputScoringBulk,
                                             LOGIC_NUMERIC, 
                                             LOGIC_CATEGORICAL, 
                                             # InputScoring, 
@@ -28,7 +29,7 @@ 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, get_profiles_by_criteria_id, get_weight_by_id
+from externals.databases.pg_crud import get_profiles, create_matchings, create_scores, get_profiles_by_criteria_id, get_weight_by_id, get_profiles_by_user_id
 from utils.logger import get_logger
 
 
@@ -403,7 +404,8 @@ class AgenticScoringService:
             "comparison": comparison_text
         }
 
-        llm = model_4o_2.with_structured_output(AIMatchProfile)
+        # llm = model_4o_2.with_structured_output(AIMatchProfile)
+        llm = model_5_1.with_structured_output(AIMatchProfile)
 
         gen_ai = BaseAIGenerator(
             task_name="ai matching",
@@ -573,6 +575,86 @@ class AgenticScoringService:
             # 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
+
+
+    async def scoring_v2(self, requirements: InputScoringBulk):
+        try:
+            # Create criteria_id
+            filter_svc = AgenticFilterService(db=self.db, user=self.user)
+            criteria_id = await filter_svc.create_filter(filter=requirements.criteria)
+            weight_svc = AgenticWeightService(db=self.db, user=self.user)
+            cv_weight = CVWeight(
+                    criteria_id=criteria_id,
+                    weight_id=uuid4(),
+
+                    gpa_edu_1=weight.get("gpa_edu_1"),
+                    gpa_edu_2=weight.get("gpa_edu_2"),
+                    gpa_edu_3=weight.get("gpa_edu_3"),
+
+                    univ_edu_1=weight.get("univ_edu_1"),
+                    univ_edu_2=weight.get("univ_edu_2"),
+                    univ_edu_3=weight.get("univ_edu_3"),
+
+                    major_edu_1=weight.get("major_edu_1"),
+                    major_edu_2=weight.get("major_edu_2"),
+                    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")
+                )
+            weight_output = await weight_svc.create_weight(weight=cv_weight)
+            weight_id = weight_output.get("weight_id")
+
+            criteria = requirements.criteria
+            weight = requirements.criteria_weight
+            
+            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 = []
+            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)
+
+
+            match_results:List[AIMatchProfile] = await self._ai_matching_bulk(all_tobe_scored, criteria) # TODO: refactor, use non LLM solution
+            # 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}")

services/agentic/score.py

@@ -1,42 +0,0 @@
-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/llms/LLM.py

@@ -59,15 +59,15 @@ model_5mini = AzureChatOpenAI(
     disable_streaming=True
 )
 
-# model_5_1 = AzureChatOpenAI(
-#     azure_endpoint=os.environ.get("azureai--endpoint--url--5.1"),
-#     openai_api_version=os.environ.get("azureai--api--version--5.1"),
-#     deployment_name=os.environ.get("azureai--deployment--name--5.1"),
-#     openai_api_key=os.environ.get("azureai--api-key--5.1"),
-#     openai_api_type="azure",
-#     max_retries=2,
-#     disable_streaming=True
-# )
+model_5_1 = AzureChatOpenAI(
+    openai_api_key=os.environ.get("azureai__api_key__51"),
+    azure_endpoint=os.environ.get("azureai__endpoint__url__51"),
+    deployment_name=os.environ.get("azureai__deployment__name__51"),
+    openai_api_version=os.environ.get("azureai__api__version__51"),
+    openai_api_type="azure",
+    max_retries=2,
+    disable_streaming=True
+)
 
 # model_5_1codex = AzureChatOpenAI(
 #     azure_endpoint=os.environ.get("azureai--endpoint--url--5.1-codex"),

services/llms/__init__.py

@@ -1,3 +1,3 @@
-__all__ = ['model_4omini', 'model_5mini', 'model_4o_2']
+__all__ = ['model_4omini', 'model_5mini', 'model_4o_2', 'model_5_1']
 
-from .LLM import model_4omini, model_5mini, model_4o_2
+from .LLM import model_4omini, model_5mini, model_4o_2, model_5_1

services/models/data_model.py

@@ -60,39 +60,39 @@ class Profiles(TypedDict):
     profiles: List[Profile]
 
 class Criteria(TypedDict):
-    gpa_edu_1: Optional[float] = None
-    univ_edu_1: Optional[str] = None
-    major_edu_1: Optional[str] = None
-    gpa_edu_2: Optional[float] = None
-    univ_edu_2: Optional[str] = None
-    major_edu_2: Optional[str] = None
-    gpa_edu_3: Optional[float] = None
-    univ_edu_3: Optional[str] = None
-    major_edu_3: Optional[str] = None
+    gpa_edu_1: Optional[float] = 0
+    univ_edu_1: Optional[List[str]] = []
+    major_edu_1: Optional[List[str]] = []
+    gpa_edu_2: Optional[float] = 0
+    univ_edu_2: Optional[List[str]] = []
+    major_edu_2: Optional[List[str]] = []
+    gpa_edu_3: Optional[float] = 0
+    univ_edu_3: Optional[List[str]] = []
+    major_edu_3: Optional[List[str]] = []
     domicile: Optional[str] = None
-    yoe: Optional[int] = None
-    hardskills: Optional[List] = None
-    softskills: Optional[List] = None
-    certifications: Optional[List] = None
-    business_domain: Optional[List] = None
+    yoe: Optional[int] = 0
+    hardskills: Optional[List[str]] = []
+    softskills: Optional[List[str]] = []
+    certifications: Optional[List[str]] = []
+    business_domain: Optional[List[str]] = []
 
 
 class CriteriaWeight(TypedDict):
-    gpa_edu_1: Optional[float] = None
-    univ_edu_1: Optional[float] = None
-    major_edu_1: Optional[float] = None
-    gpa_edu_2: Optional[float] = None
-    univ_edu_2: Optional[float] = None
-    major_edu_2: Optional[float] = None
-    gpa_edu_3: Optional[float] = None
-    univ_edu_3: Optional[float] = None
-    major_edu_3: Optional[float] = None
-    domicile: Optional[float] = None
-    yoe: Optional[float] = None
-    hardskills: Optional[float] = None
-    softskills: Optional[float] = None
-    certifications: Optional[float] = None
-    business_domain: Optional[float] = None
+    gpa_edu_1: Optional[float] = 0
+    univ_edu_1: Optional[float] = 0
+    major_edu_1: Optional[float] = 0
+    gpa_edu_2: Optional[float] = 0
+    univ_edu_2: Optional[float] = 0
+    major_edu_2: Optional[float] = 0
+    gpa_edu_3: Optional[float] = 0
+    univ_edu_3: Optional[float] = 0
+    major_edu_3: Optional[float] = 0
+    domicile: Optional[float] = 0
+    yoe: Optional[float] = 0
+    hardskills: Optional[float] = 0
+    softskills: Optional[float] = 0
+    certifications: Optional[float] = 0
+    business_domain: Optional[float] = 0
 
 
 # class InputScoring(AIProfile):
@@ -104,8 +104,7 @@ class InputScoring(TypedDict):
     profile_id: str = Field(description="profile id")
     weight_id: str =  Field(description="weight id")
 
-class InputScoringBulk(TypedDict):
-    profile_ids: List = Field(description="list of profile id")
+class InputScoringBulk(TypedDict): #TODO: USE THIS ON /v2/calculate_score
     criteria: Criteria = Field(description="Criteria to be matched with the profile")
     criteria_weight: CriteriaWeight = Field(description="Criteria weight to be applied when profile matching")