[FEATURE] Add Logic to Calculate and Get Life Score

.gitignore

@@ -2,4 +2,5 @@ logs/
 mementos/
 users/
 templates/
-.env
+.env
+__pycache__

app/assistants.py

@@ -496,8 +496,10 @@ class Assistant:
             elif tool.function.name == "end_conversation":
                 day_n = json.loads(tool.function.arguments)['day_n']
                 completed_micro_action = json.loads(tool.function.arguments)['completed_micro_action']
+                area_of_deep_reflection = json.loads(tool.function.arguments)['area_of_deep_reflection']
 
                 self.cm.user.update_micro_action_status(completed_micro_action)
+                self.cm.user.trigger_deep_reflection_point(area_of_deep_reflection)
 
                 # NOTE: we will record whether the user has completed the theme for the day
                 # NOTE: if no, we will include a short followup message to encourage the user the next day
@@ -511,7 +513,10 @@ class Assistant:
                 logger.warning(f"Creating a SMART goal...", extra={"user_id": self.cm.user.user_id, "endpoint": "create_smart_goal"})
 
                 user_goal = json.loads(tool.function.arguments)['goal']
-                self.cm.user.set_goal(user_goal)
+                user_goal_area = json.loads(tool.function.arguments)['area']
+                user_goal_status = 'PENDING'
+
+                self.cm.user.set_goal(user_goal, user_goal_area, user_goal_status)
 
                 print_log("INFO", f"SMART goal approved: {user_goal}", extra={"user_id": self.cm.user.user_id, "endpoint": "create_smart_goal"})
                 logger.info(f"SMART goal approved: {user_goal}", extra={"user_id": self.cm.user.user_id, "endpoint": "create_smart_goal"})
@@ -545,6 +550,14 @@ class Assistant:
 
             elif tool.function.name == "change_goal":
                 pass
+
+            elif tool.function.name == "complete_goal":
+                self.cm.user.update_goal_status()
+                logger.info(f"Updated recent goal status as COMPLETED.", extra={"user_id": self.cm.user.user_id, "endpoint": "complete_goal"})
+                tool_outputs.append({
+                    "tool_call_id": tool.id,
+                    "output": "true"
+                })
             
         # Submit all tool outputs at once after collecting them in a list
         if tool_outputs:

app/flows.py

@@ -382,7 +382,9 @@ The user is currently on day {{}}/{{}} of their journey.
 
  - Highlight the user's progress and achievements in bullet points
 
- - Ask the user whether they want to continue the plan for another 2 weeks, or create a new goal 
+ - Ask the user whether they have **accomplished** they goal. If they have accomplished their goal, call the complete_goal() function!
+
+ - Ask the user whether they want to continue the plan for another 2 weeks, or create a new goal. If they want to create a new goal, call the change_goal() function!
 
  - Finally, suggest to the user to speak to a Growth Guide for deeper support by booking a Growth Guide schedule through ourcoach web app
 

app/main.py

@@ -15,7 +15,7 @@ from openai import OpenAI
 import psycopg2
 from psycopg2 import sql
 import os
-from app.utils import get_api_key, get_user_info, get_growth_guide_session, pop_cache, print_log, update_user, upload_file_to_s3, get_user, upload_mementos_to_db, get_user_summary, get_user_life_status
+from app.utils import get_api_key, get_user_info, get_growth_guide_session, pop_cache, print_log, update_user, upload_file_to_s3, get_user, upload_mementos_to_db, get_user_summary, get_user_life_status, get_life_score
 from dotenv import load_dotenv
 import logging.config
 import time
@@ -336,7 +336,31 @@ def get_user_by_id(user_id: str, api_key: str = Security(get_api_key)):
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=str(e)
         )
+    
+@app.get("/get_user_life_score")
+def life_score_by_id(user_id: str, api_key: str = Security(get_api_key)):
+    print_log("INFO", "Getting user life score", extra={"user_id": user_id, "endpoint": "/get_user_life_score"})
+    logger.info("Getting user life score", extra={"user_id": user_id, "endpoint": "/get_user_life_score"})
+    try:
+        life_score = get_life_score(user_id)
+        print_log("INFO", "Successfully retrieved user life score", extra={"user_id": user_id, "endpoint": "/get_user_life_score"})
+        logger.info("Successfully retrieved user life score", extra={"user_id": user_id, "endpoint": "/get_user_life_score"})
 
+        return life_score
+    except LookupError:
+        print_log("ERROR", "User not found", extra={"user_id": user_id, "endpoint": "/get_user_life_score"})
+        logger.error("User not found", extra={"user_id": user_id, "endpoint": "/get_user_life_score"})
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"User with ID {user_id} not found"
+        )
+    except Exception as e:
+        print_log("ERROR",f"Error getting user: {str(e)}", extra={"user_id": user_id, "endpoint": "/get_user_life_score"}, exc_info=True)
+        logger.error(f"Error getting user: {str(e)}", extra={"user_id": user_id, "endpoint": "/get_user_life_score"}, exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=str(e)
+        )
 
 @app.post("/add_ai_message")
 def add_ai_message(request: ChatItem, api_key: str = Security(get_api_key)):
@@ -751,4 +775,16 @@ def get_life_status_by_id(user_id: str, api_key: str = Security(get_api_key)):
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=str(e)
-        )
+        )
+    
+@app.post("/add_booking_point")
+def add_booking_point_by_user(user_id: str, api_key: str = Security(get_api_key)):
+    user = get_user(user_id)
+    user.add_point_for_booking()
+    return {"response": "ok"}
+
+@app.post("/add_session_completion_point")
+def add_session_completion_point_by_user(user_id: str, api_key: str = Security(get_api_key)):
+    user = get_user(user_id)
+    user.add_point_for_completing_session()
+    return {"response": "ok"}

app/user.py

@@ -273,6 +273,11 @@ class User:
         self.micro_actions = []
         self.challenges = []
         self.other_focusses = []
+        self.personal_growth_score = 0
+        self.career_growth_score = 0
+        self.relationship_score = 0
+        self.mental_well_being_score = 0
+        self.health_and_wellness_score = 0
 
         # Read growth_plan.json and store it
         growth_plan = {"growthPlan": [
@@ -344,17 +349,56 @@ class User:
         self.user_interaction_guidelines = self.generate_user_interaction_guidelines(user_info, client)
         self.conversations = ConversationManager(client, self, asst_id)
 
+    def add_life_score_point(self, variable, points_added, notes):
+        if variable == 'Personal Growth':
+            self.personal_growth_score += points_added
+            logger.info(f"Added {points_added} points to Personal Growth for {notes}", extra={"user_id": self.user_id, "endpoint": "add_life_score_point"})
+        elif variable == 'Career Growth':
+            self.career_growth_score += points_added
+            logger.info(f"Added {points_added} points to Career Growth for {notes}", extra={"user_id": self.user_id, "endpoint": "add_life_score_point"})
+        elif variable == 'Health and Wellness':
+            self.health_and_wellness_score += points_added
+            logger.info(f"Added {points_added} points to Health and Wellness for {notes}", extra={"user_id": self.user_id, "endpoint": "add_life_score_point"})
+        elif variable == 'Mental Well-Being':
+            self.mental_well_being_score += points_added
+            logger.info(f"Added {points_added} points to Mental Well Being for {notes}", extra={"user_id": self.user_id, "endpoint": "add_life_score_point"})
+        elif variable == 'Relationship':
+            self.relationship_score += points_added
+            logger.info(f"Added {points_added} points to Relationship for {notes}", extra={"user_id": self.user_id, "endpoint": "add_life_score_point"})
+        
     def get_current_goal(self):
         return self.goal[-1] if self.goal else None
 
-    def set_goal(self, goal):
-        self.goal.append({"goal": goal, "created_at": pd.Timestamp.now().strftime("%d-%m-%Y %a %H:%M:%S")})
-
+    def set_goal(self, goal, area, status):
+        self.goal.append({"goal": goal, "area": area, "status": status, "created_at": pd.Timestamp.now().strftime("%d-%m-%Y %a %H:%M:%S"), "updated_at": pd.Timestamp.now().strftime("%d-%m-%Y %a %H:%M:%S")})
+        self.add_life_score_point(variable = area, points_added = 10, notes = "Setting a Goal")
+        
     def update_micro_action_status(self, completed_micro_action):
         if completed_micro_action:
             self.micro_actions[-1]["status"] = "COMPLETE"
             self.micro_actions[-1]["updated_at"] = pd.Timestamp.now().strftime("%d-%m-%Y %a %H:%M:%S")
 
+            num_of_micro_actions_completed = sum(1 for item in self.micro_actions if item['status'] == 'COMPLETE')
+
+            if (num_of_micro_actions_completed in (1,3,5)) or (num_of_micro_actions_completed % 10 == 0 and num_of_micro_actions_completed != 0):
+                self.add_life_score_point(variable = self.get_current_goal()['area'], points_added = 10, notes = f"Completing the {num_of_micro_actions_completed}-th micro-action")
+    
+    def trigger_deep_reflection_point(self, area_of_deep_reflection):
+        if len(area_of_deep_reflection)>0:
+            for area in area_of_deep_reflection:
+                self.add_life_score_point(variable = area, points_added = 5, notes = f"Doing a deep reflection about {area}")
+
+    def update_goal_status(self):
+        self.goal[-1]["status"] = "COMPLETE"
+        self.goal[-1]["updated_at"] = pd.Timestamp.now().strftime("%d-%m-%Y %a %H:%M:%S")
+        self.add_life_score_point(variable = self.get_current_goal()['area'], points_added = 30, notes = "Completing a Goal")
+
+    def add_point_for_booking(self):
+        self.add_life_score_point(variable = self.get_current_goal()['area'], points_added = 5, notes = "Booking a GG session")
+    
+    def add_point_for_completing_session(self):
+        self.add_life_score_point(variable = self.get_current_goal()['area'], points_added = 20, notes = "Completing a GG session")
+        
     def add_ai_message(self, text):
         self.conversations._add_ai_message(text)
         return text
@@ -505,6 +549,13 @@ class User:
         self.conversations.state['date'] = date
 
         action = self.growth_plan.current()
+
+        ## ADD POINT FOR CHANGE DATE
+        if self.growth_plan.current()['day'] == 7:
+            self.add_life_score_point(variable = self.get_current_goal()['area'], points_added = 5, notes = "Reaching Day 7")
+        elif self.growth_plan.current()['day'] == 14:
+            self.add_life_score_point(variable = self.get_current_goal()['area'], points_added = 10, notes = "Reaching Day 14")
+
         logger.info(f"Today's action is {action}", extra={"user_id": self.user_id, "endpoint": "user_change_date"})
 
         if action['day'] == 1:
@@ -639,22 +690,78 @@ class User:
         self._update_goal(gg_report[4]['answer'])
 
     def _update_goal(self, goal_text):
-        prompt = (
-            f"The user has a current goal: {self.get_current_goal()}.\n"
-            f"The user provided a new goal: {goal_text}.\n"
-            "Determine if the new goal is the same as the current goal or if it's a new one.\n"
-            "If it's the same, respond with the current goal.\n"
-            "If it's a new goal, respond with the new goal.\n"
-            "Only output the final goal."
-        )
+        prompt = f"""
+        The user has a current goal: {self.get_current_goal()}
+        The user provided a new goal: {goal_text}
+
+        Determine if the new goal is the same as the current goal or if it's a new one.
+        If it's the same, respond with the current goal, and set same_or_not == True
+        If it's a new goal, respond with the new goal, and set same_or_not == False
+        
+        Your response will be the final goal. You will also need to determine the area of this
+        final goal by choosing one of these areas that suits the final goal:
+        "Personal Growth", "Career Growth", "Relationship", "Mental Well-Being", "Health and Wellness"
+
+        Only output a JSON with this schema below:
+        {{
+         same_or_not: bool (whether the new goal is the same or not with the current goal),
+         goal: str (the final goal),
+         area: str (the area of the goal)
+        }}
+        """
+            
         response = self.client.chat.completions.create(
             model="gpt-4o",
             messages=[{"role": "user", "content": prompt}],
+            response_format = {
+                "type": "json_schema",
+                "json_schema": {
+                "name": "goal_determination",
+                "strict": True,
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                    "same_or_not": {
+                        "type": "boolean",
+                        "description": "Indicates whether the new goal is the same as the current goal."
+                    },
+                    "goal": {
+                        "type": "string",
+                        "description": "The final goal determined based on input."
+                    },
+                    "area": {
+                        "type": "string",
+                        "description": "The area of the goal.",
+                        "enum": [
+                        "Personal Growth",
+                        "Career Growth",
+                        "Relationship",
+                        "Mental Well-Being",
+                        "Health and Wellness"
+                        ]
+                    }
+                    },
+                    "required": [
+                    "same_or_not",
+                    "goal",
+                    "area"
+                    ],
+                    "additionalProperties": False
+                }
+                }
+            },
             temperature=0.2
         )
-        final_goal = response.choices[0].message.content.strip()
-        if final_goal != self.get_current_goal():
-            self.set_goal(final_goal)
+
+        final_goal = json.loads(response.choices[0].message.content)['goal']
+        final_goal_area = json.loads(response.choices[0].message.content)['area']
+        if json.loads(response.choices[0].message.content)['same_or_not']:
+            final_goal_status = self.get_current_goal()['status']
+        else:
+            final_goal_status = 'PENDING'
+        
+        if json.loads(response.choices[0].message.content)['same_or_not'] == False:
+            self.set_goal(final_goal, final_goal_area, final_goal_status)
             logger.info(f"User goal updated to: {final_goal}", extra={"user_id": self.user_id, "endpoint": "_update_goal"})
         else:
             logger.info(f"User goal remains unchanged.", extra={"user_id": self.user_id, "endpoint": "_update_goal"})

app/utils.py

@@ -118,6 +118,30 @@ def get_user(user_id):
             raise ReferenceError(f"User {user_id} pickle still being created")
         raise LookupError(f"User [{user_id}] has not onboarded yet")
 
+def get_life_score(user_id):
+    function_name = get_life_score.__name__
+    logger.info(f"Generating user life score for user {user_id}", extra={'user_id': user_id, 'endpoint': function_name})
+
+    # Step 1: Call get_user to get user's info
+    try:
+        user = get_user(user_id)
+        # user_info = user.user_info
+        # user_messages = user.get_messages()
+        ## all the life scores here
+    
+        life_score = {
+        "personal_growth_score": user.personal_growth_score,
+        "career_growth_score": user.career_growth_score,
+        "relationship_score": user.relationship_score,
+        "mental_well_being_score": user.mental_well_being_score,
+        "health_and_wellness_score": user.health_and_wellness_score
+        }
+    except LookupError as e:
+        logger.error(f"Error fetching user data: {e}", extra={'user_id': user_id, 'endpoint': function_name})
+        raise e
+    
+    return life_score
+
 def get_user_summary(user_id):
     function_name = get_user_summary.__name__
     logger.info(f"Generating user summary for user {user_id}", extra={'user_id': user_id, 'endpoint': function_name})

test.txt

@@ -1,3 +1 @@
 just a testing file
-
-testing