Upload 3 files

app.py

@@ -1,22 +1,28 @@
 import os
 from typing import Any, Dict, List
 from dotenv import load_dotenv
+
 load_dotenv()
 import uvicorn
 from fastapi import APIRouter, FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 from model_predict_onnx import onnx_predictor
-from user_weights import (get_all_users, get_user_metadata,
-                                       get_user_weights,
-                                       track_question_tags,
-                                       update_user_metadata,
-                                       update_user_weights,
-                                       update_weights_from_feedback,
-                                       update_weights_from_query)
-from get_destinations import (get_destinations_list,get_question_vector)
+from user_weights import (
+    get_all_users,
+    get_user_metadata,
+    get_user_weights,
+    track_question_tags,
+    update_user_metadata,
+    update_user_weights,
+    update_weights_from_feedback,
+    update_weights_from_query,
+)
+from get_destinations import get_destinations_list, get_question_vector, get_recent_tags
 from get_default_weight import feature_names, weights_bias_vector
 from database import db
+from loguru import logger
+
 
 # Define request models
 class WeightUpdateRequest(BaseModel):
@@ -24,13 +30,16 @@ class WeightUpdateRequest(BaseModel):
     new_weights: List[float]
     metadata: Dict[str, Any] = {}
 
+
 class FeedbackRequest(BaseModel):
     destination_id: int
     tag_id: int
     rating: int  # 1-5 stars
 
+
 router = APIRouter(prefix="/model", tags=["Model"])
 
+
 @router.get("/get_question_tags/{question}")
 async def get_question_tags(question: str):
     # Get the prediction
@@ -41,8 +50,9 @@ async def get_question_tags(question: str):
     print("Predicted Tags:", predicted_tags)
     return {"question_tags": predicted_tags}
 
+
 @router.get("/get_destinations_list/{question_tags}/{top_k}")
-async def get_destinations_list_api(question_tags: str, top_k:str):
+async def get_destinations_list_api(question_tags: str, top_k: str):
     # Get the prediction
     question_vector = get_question_vector(question_tags)
     destinations_list = get_destinations_list(question_vector, int(top_k))
@@ -50,6 +60,22 @@ async def get_destinations_list_api(question_tags: str, top_k:str):
     print("destinations_list:", destinations_list)
     return {"destinations_list": destinations_list}
 
+
+@router.get("/get_recommendation_destinations/{user_id}/{top_k}")
+async def get_recommendation_destinations(user_id: str, top_k: str):
+    # Get the prediction
+    recent_tags = get_recent_tags(user_id)
+    question_tags = " ".join(recent_tags)
+    question_vector = get_question_vector(question_tags)
+    destinations_list = get_destinations_list(question_vector, int(top_k), user_id)
+    destination_ids = db.get_destination_ids(destinations_list)
+    return {
+        "destination_ids": destination_ids,
+        "destinations_list:": destinations_list,
+        "recent_tags": recent_tags,
+    }
+
+
 @router.get("/get_destinations_list_by_question/{question}/{top_k}")
 async def get_destinations_list_api(question: str, top_k: str):
     # Get the prediction
@@ -66,16 +92,17 @@ async def get_destinations_list_api(question: str, top_k: str):
     print("destinations_list:", destinations_list)
     return {"destinations_list": destinations_list}
 
+
 @router.get("/get_destinations_list_by_question/{question}/{top_k}/{user_id}")
 def get_destinations_list_with_user_api(question: str, top_k: str, user_id: str):
     """
     Get a list of destinations based on a question and user-specific weights.
-    
+
     Parameters:
     question (str): The question to get destinations for.
     top_k (str): The number of destinations to return.
     user_id (str): The ID of the user.
-    
+
     Returns:
     dict: A dictionary containing the list of destinations.
     """
@@ -85,13 +112,15 @@ def get_destinations_list_with_user_api(question: str, top_k: str, user_id: str)
     # Print the sentence and its predicted tags
     print("Sentence:", original_sentence)
     print("Predicted Tags:", question_tags)
-    
+
     # Track the question tags for the user
     track_question_tags(user_id, question_tags)
-    
+
     # Update weights based on query tags
-    update_weights_from_query(user_id, question_tags, feature_names, weights_bias_vector)
-    
+    update_weights_from_query(
+        user_id, question_tags, feature_names, weights_bias_vector
+    )
+
     # Get the prediction
     question_tags_str = " ".join(question_tags)
     question_vector = get_question_vector(question_tags_str)
@@ -100,31 +129,34 @@ def get_destinations_list_with_user_api(question: str, top_k: str, user_id: str)
     print("destinations_list:", destinations_list)
     return {"destinations_list": destinations_list}
 
+
 @router.get("/users")
 def get_users():
     """
     Get a list of all users.
-    
+
     Returns:
     dict: A dictionary containing the list of users.
     """
     users = get_all_users()
     return {"users": users}
 
+
 @router.get("/users/{user_id}")
 def get_user(user_id: str):
     """
     Get the metadata for a user.
-    
+
     Parameters:
     user_id (str): The ID of the user.
-    
+
     Returns:
     dict: A dictionary containing the user's metadata.
     """
     metadata = get_user_metadata(user_id)
     return {"metadata": metadata}
 
+
 @router.get("/users/{user_id}/weights")
 def get_user_weights_api(user_id: str):
     """
@@ -141,86 +173,100 @@ def get_user_weights_api(user_id: str):
     weights_list = weights.tolist() if weights is not None else None
     return {"user_id": user_id, "weights": weights_list}
 
+
 @router.post("/users/{user_id}/weights")
 def update_user_weights_api(user_id: str, request: WeightUpdateRequest):
     """
     Update the weights for a user.
-    
+
     Parameters:
     user_id (str): The ID of the user.
     request (WeightUpdateRequest): The request containing the tag indices, new weights, and metadata.
-    
+
     Returns:
     dict: A dictionary indicating whether the update was successful.
     """
     # Validate the request
     if len(request.tag_indices) != len(request.new_weights):
-        raise HTTPException(status_code=400, detail="Tag indices and new weights must have the same length")
-    
+        raise HTTPException(
+            status_code=400,
+            detail="Tag indices and new weights must have the same length",
+        )
+
     # Update the weights
-    success = update_user_weights(user_id, request.tag_indices, request.new_weights, weights_bias_vector)
-    
+    success = update_user_weights(
+        user_id, request.tag_indices, request.new_weights, weights_bias_vector
+    )
+
     # Update the metadata
     if success and request.metadata:
         update_user_metadata(user_id, request.metadata)
-    
+
     return {"success": success}
 
+
 @router.post("/users/{user_id}/feedback")
 def record_user_feedback(user_id: str, request: FeedbackRequest):
     """
     Record user feedback on a specific tag for a specific destination.
-    
+
     Parameters:
     user_id (str): The ID of the user.
     request (FeedbackRequest): The request containing the destination ID, tag ID, and rating.
-    
+
     Returns:
     dict: A dictionary indicating whether the feedback was recorded successfully.
     """
     # Validate the request
     if request.rating < 1 or request.rating > 5:
         raise HTTPException(status_code=400, detail="Rating must be between 1 and 5")
-    
+
     # Update weights based on feedback
     success = update_weights_from_feedback(
-        user_id, 
-        request.destination_id, 
-        request.tag_id, 
-        request.rating, 
-        weights_bias_vector
+        user_id,
+        request.destination_id,
+        request.tag_id,
+        request.rating,
+        weights_bias_vector,
     )
-    
+
     return {"success": success}
 
+
 @router.get("/tags")
 def get_tags():
     """
     Get a list of all tags.
-    
+
     Returns:
     dict: A dictionary containing the list of tags.
     """
-    return {"tags": feature_names.tolist()}
+    return {"tags": [tag.upper() for tag in feature_names.tolist()]}
+
 
 app = FastAPI(docs_url="/")
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=['*'],
+    allow_origins=["*"],
     allow_credentials=True,
-    allow_methods=['*'],
-    allow_headers=['*'],
-    expose_headers=['*',]
+    allow_methods=["*"],
+    allow_headers=["*"],
+    expose_headers=[
+        "*",
+    ],
 )
 
 app.include_router(router)
 
+
 @app.on_event("startup")
 def startup_event():
     """
     Connect to the database when the API starts.
     """
     db.connect()
+    logger.info("Database connected")
+
 
 @app.on_event("shutdown")
 def shutdown_event():
@@ -228,6 +274,8 @@ def shutdown_event():
     Close the database connection when the API shuts down.
     """
     db.close()
+    logger.info("Database closed")
+
 
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 7880)))

database.py

@@ -10,10 +10,7 @@ from dotenv import load_dotenv
 from bson import ObjectId
 from loguru import logger
 
-load_dotenv()
-
-print(os.environ.get("MONGODB_URL"))
-
+load_dotenv(override=True)
 
 class Database:
     def __init__(self):
@@ -27,7 +24,7 @@ class Database:
         try:
             # Connect to MongoDB
             self.client = MongoClient(os.environ.get("MONGODB_URL"))
-            self.db = self.client[os.environ.get("DB_NAME", "triventure")]
+            self.db = self.client[os.environ.get("DB_NAME", "scheduling")]
 
             # Create users collection if it doesn't exist
             if "user" not in self.db.list_collection_names():
@@ -287,7 +284,25 @@ class Database:
         except Exception as e:
             logger.error(f"Error getting all users: {e}")
             return []
+    def get_destination_ids(self,destination_names):
+        """
+        Get destination IDs from the database.
 
+        Parameters:
+        destination_names (list): A list of destination names.
+
+        Returns:
+        list: A list of destination IDs.
+        """
+        try:
+            # Get destination IDs from the database
+            results = self.db.destination.find({"name": {"$in": destination_names}})
+            destination_ids = [str(result["_id"]) for result in results]
+            return destination_ids
+        except Exception as e:
+            print(f"Error getting destination IDs: {e}")
+            return []
 
 # Create a singleton instance
 db = Database()
+

get_destinations.py

@@ -3,19 +3,22 @@ import numpy as np
 from config import vectorizer
 from get_default_weight import destinations, weights_bias_vector
 from user_weights import get_user_weights
+from database import db
 
 
 def get_des_accumulation(question_vector, weights_bias_vector):
     accumulation = 0
     for index in range(len(weights_bias_vector)):
-        if question_vector[index]==1:
+        if question_vector[index] == 1:
             accumulation += weights_bias_vector[index]
-            
+
     return accumulation
 
+
 def get_destinations_list(question_vector, top_k, user_id=None):
     des = destinations
     des = des[1:].reset_index(drop=True)
+    # print("DES:", des)
     """
     This function calculates the accumulated scores for each destination based on the given question vector and weights vector.
     It then selects the top 5 destinations with the highest scores and returns their names.
@@ -29,24 +32,28 @@ def get_destinations_list(question_vector, top_k, user_id=None):
     weights_vector = weights_bias_vector
     if user_id is not None:
         weights_vector = get_user_weights(user_id, weights_bias_vector)
-    
+    print("weights_bias_vector:", weights_vector)
+
     accumulation_dict = {}
     for index in range(len(weights_vector)):
         accumulation = get_des_accumulation(question_vector[0], weights_vector[index])
         accumulation_dict[str(index)] = accumulation
-    
+    print("accumulation_dict:", accumulation_dict)
     top_keys = sorted(accumulation_dict, key=accumulation_dict.get, reverse=True)
     print(f"Top keys: {top_keys}")
     scores = [accumulation_dict[key] for key in top_keys]
+    print("scores:", scores)
     q1_score = np.percentile(scores, 25)
+    print("q1_score:", q1_score)
     destinations_list = []
     for key in top_keys:
         if accumulation_dict[key] > q1_score:
             destinations_list.append(des["name"][int(key)])
             print(f"{des['name'][int(key)]}: {accumulation_dict[key]}")
-    
+
     return destinations_list[:top_k]
 
+
 def get_question_vector(question_tags):
     """
     Generate a question vector based on the given list of question tags.
@@ -63,4 +70,14 @@ def get_question_vector(question_tags):
     """
     question_tags = [question_tags]
     question_vector = vectorizer.transform(question_tags).toarray()
+    print("question_tags:", question_tags)
+    print("question_vector:", question_vector)
     return question_vector
+
+
+def get_recent_tags(user_id):
+    recent_tags = db.get_user_metadata(user_id).get("recent_tags", [])
+    if recent_tags:
+        return recent_tags[-1].get("tags", [])
+    else:
+        return {}