test

QCMTool.py

@@ -0,0 +1,65 @@
+import json
+import random
+
+class QCMTool:
+    def __init__(self, json_file):
+        """
+        Initialize the QCM tool with a JSON file containing questions.
+        """
+        self.json_file = json_file
+        self.questions = self.load_questions()
+
+    def load_questions(self):
+        """
+        Load questions from the JSON file.
+        """
+        with open(self.json_file, 'r') as file:
+            questions = json.load(file)
+        return questions
+
+    def pick_random_question(self):
+        """
+        Pick a random question from the loaded questions.
+        """
+        return random.choice(self.questions)
+
+    def check_answer(self, question, user_answer):
+        """
+        Check if the user's answer is correct and provide an explanation.
+        """
+        if user_answer == question["correct_answer"]:
+            return True, question["explanation"]
+        else:
+            return False, question["explanation"]
+
+    def run(self):
+        """
+        Run the QCM tool: pick a question, ask the user, and check the answer.
+        """
+        question = self.pick_random_question()
+        print("Question:", question["question"])
+        for i, option in enumerate(question["options"], 1):
+            print(f"{chr(64 + i)}. {option}")  # Use 'A', 'B', 'C', 'D' instead of numbers
+
+        user_answer = input("Your answer (enter the option letter, e.g., A, B, C, D): ").strip().upper()
+        try:
+            # Map user input (A, B, C, D) to the corresponding option index
+            option_index = ord(user_answer) - 65  # Convert 'A' to 0, 'B' to 1, etc.
+            if 0 <= option_index < len(question["options"]):
+                selected_option = question["options"][option_index]
+                is_correct, explanation = self.check_answer(question, selected_option)
+                if is_correct:
+                    print("Correct! 🎉")
+                else:
+                    print("Incorrect! 😞")
+                print("Explanation:", explanation)
+            else:
+                print("Invalid option letter. Please try again.")
+        except (ValueError, IndexError):
+            print("Invalid input. Please enter a valid option letter (A, B, C, D).")
+
+
+qcm_tool = QCMTool('info/questions.json')
+
+# Run the QCM tool
+qcm_tool.run()

app.py

@@ -1,4 +1,5 @@
 import json
+from random import random
 
 from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
 import datetime
@@ -94,7 +95,7 @@ def provide_my_information(query: str) -> str:
         return f"I am located in {my_info['location']}."
     elif "occupation" in query or "job" in query or "work" in query:
         return f"I work as a {my_info['occupation']}."
-    elif "education" in query or "degree" in query:
+    elif "education" in query or "educational" in query:
         return f"I have a {my_info['education']}."
     elif "skills" in query or "what can you do" in query:
         return f"My skills include: {', '.join(my_info['skills'])}."
@@ -110,21 +111,43 @@ def provide_my_information(query: str) -> str:
         )
     else:
         return "I'm sorry, I don't have information on that. Please ask about my name, location, occupation, education, skills, hobbies, or contact details."
-        
+
+
 @tool
-def get_current_time_in_timezone(timezone: str) -> str:
-    """A tool that fetches the current local time in a specified timezone.
+def qcm_tool(json_file: str, user_answer: Optional[str] = None) -> str:
+    """
+    A tool that picks a random QCM (Multiple Choice Question) from a JSON file and checks the user's answer.
+
     Args:
-        timezone: A string representing a valid timezone (e.g., 'America/New_York').
+        json_file: Path to the JSON file containing questions.
+        user_answer: The user's answer (optional). If not provided, the tool returns a question and options.
+
+    Returns:
+        If no user_answer is provided:
+            A string containing the question and options.
+        If user_answer is provided:
+            A string indicating whether the answer is correct and providing an explanation.
     """
     try:
-        # Create timezone object
-        tz = pytz.timezone(timezone)
-        # Get current time in that timezone
-        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
-        return f"The current local time in {timezone} is: {local_time}"
+        # Load questions from the JSON file
+        with open("info/questions.json", 'r') as file:
+            questions = json.load(file)
+
+        # Pick a random question
+        question = random.choice(questions)
+
+        if user_answer is None:
+            # Return the question and options
+            options_str = "\n".join([f"{chr(65 + i)}. {opt}" for i, opt in enumerate(question['options'])])
+            return f"Question: {question['question']}\nOptions:\n{options_str}"
+        else:
+            # Check the user's answer
+            if user_answer.strip().upper() == question['correct_answer'].strip().upper():
+                return f"Correct! 🎉\nExplanation: {question['explanation']}"
+            else:
+                return f"Incorrect! 😞\nExplanation: {question['explanation']}"
     except Exception as e:
-        return f"Error fetching time for timezone '{timezone}': {str(e)}"
+        return f"Error in QCM tool: {str(e)}"
 
 
 final_answer = FinalAnswerTool()
@@ -150,7 +173,7 @@ with open("prompts.yaml", 'r') as stream:
     
 agent = CodeAgent(
     model=model,
-    tools=[final_answer,calculate_risk_metrics,get_current_time_in_timezone,visit_webpage,web_search,provide_my_information], ## add your tools here (don't remove final answer)
+    tools=[final_answer,calculate_risk_metrics,qcm_tool,visit_webpage,web_search,provide_my_information], ## add your tools here (don't remove final answer)
     max_steps=6,
     verbosity_level=1,
     grammar=None,

info/questions.json

@@ -0,0 +1,13 @@
+[
+    {
+        "question": "A bank’s risk officer is evaluating climate-related risk drivers that could create financial risk for the bank. The risk officer has classified rising global temperatures and wildfires as acute physical risks. The risk officer is correct with respect to:",
+        "options": [
+            "wildfires only.",
+            "rising global temperatures only.",
+            "both wildfires and rising global temperatures.",
+            "neither wildfires nor rising global temperatures."
+        ],
+        "correct_answer": "wildfires only.",
+        "explanation": "Wildfires are correctly classified as acute physical risks, which relate to extreme weather events. Rising global temperatures should be classified as chronic physical risks, which relate to climate shifts like rising global temperatures and rising sea levels. (LO 99.b)"
+    }
+]

prompts.yaml

@@ -132,6 +132,49 @@
   {%- else %}
   {%- endif %}
 
+  ---
+  **QCM Tool**
+  You also have access to a QCM (Multiple Choice Question) tool that can fetch questions from a JSON file and check user answers. Here’s how to use it:
+
+  - To fetch a random question, call `qcm_tool(json_file='questions.json')`.
+  - To check a user's answer, call `qcm_tool(json_file='questions.json', user_answer="A")`.
+
+  Example:
+  ---
+  Task: "Ask me a practice question on financial risk management."
+
+  Thought: I will use the QCM tool to fetch a random question from the JSON file and display it to the user.
+  Code:
+  ```py
+  question_data = qcm_tool(json_file='questions.json')
+  print(question_data)
+  ```<end_code>
+  Observation:
+  Question: A bank’s risk officer is evaluating climate-related risk drivers that could create financial risk for the bank. The risk officer has classified rising global temperatures and wildfires as acute physical risks. The risk officer is correct with respect to:
+  Options:
+  A. wildfires only.
+  B. rising global temperatures only.
+  C. both wildfires and rising global temperatures.
+  D. neither wildfires nor rising global temperatures.
+
+  Thought: I will now ask the user to provide their answer.
+  Code:
+  ```py
+  user_answer = input("Please enter your answer (A, B, C, or D): ")
+  result = qcm_tool(json_file='questions.json', user_answer=user_answer)
+  print(result)
+  ```<end_code>
+  Observation:
+  Correct! 🎉
+  Explanation: Wildfires are correctly classified as acute physical risks, which relate to extreme weather events. Rising global temperatures should be classified as chronic physical risks, which relate to climate shifts like rising global temperatures and rising sea levels. (LO 99.b)
+
+  Thought: I will now provide the final answer with the result.
+  Code:
+  ```py
+  final_answer(result)
+  ```<end_code>
+
+  ---
   Here are the rules you should always follow to solve your task:
   1. Always provide a 'Thought:' sequence, and a 'Code:\n```py' sequence ending with '```<end_code>' sequence, else you will fail.
   2. Use only variables that you have defined!