fix exmaple issue

Gradio_UI.py

@@ -192,61 +192,16 @@ class GradioUI:
 
     def interact_with_agent(self, prompt, messages):
         import gradio as gr
-
         messages.append(gr.ChatMessage(role="user", content=prompt))
         yield messages
+        print("ok")
+        print(messages)
         for msg in stream_to_gradio(self.agent, task=prompt, reset_agent_memory=False):
             messages.append(msg)
             yield messages
         yield messages
 
-    def upload_file(
-        self,
-        file,
-        file_uploads_log,
-        allowed_file_types=[
-            "application/pdf",
-            "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-            "text/plain",
-        ],
-    ):
-        """
-        Handle file uploads, default allowed types are .pdf, .docx, and .txt
-        """
-        import gradio as gr
-
-        if file is None:
-            return gr.Textbox("No file uploaded", visible=True), file_uploads_log
-
-        try:
-            mime_type, _ = mimetypes.guess_type(file.name)
-        except Exception as e:
-            return gr.Textbox(f"Error: {e}", visible=True), file_uploads_log
-
-        if mime_type not in allowed_file_types:
-            return gr.Textbox("File type disallowed", visible=True), file_uploads_log
-
-        # Sanitize file name
-        original_name = os.path.basename(file.name)
-        sanitized_name = re.sub(
-            r"[^\w\-.]", "_", original_name
-        )  # Replace any non-alphanumeric, non-dash, or non-dot characters with underscores
-
-        type_to_ext = {}
-        for ext, t in mimetypes.types_map.items():
-            if t not in type_to_ext:
-                type_to_ext[t] = ext
-
-        # Ensure the extension correlates to the mime type
-        sanitized_name = sanitized_name.split(".")[:-1]
-        sanitized_name.append("" + type_to_ext[mime_type])
-        sanitized_name = "".join(sanitized_name)
-
-        # Save the uploaded file to the specified folder
-        file_path = os.path.join(self.file_upload_folder, os.path.basename(sanitized_name))
-        shutil.copy(file.name, file_path)
 
-        return gr.Textbox(f"File uploaded: {file_path}", visible=True), file_uploads_log + [file_path]
 
     def log_user_message(self, text_input, file_uploads_log):
         return (
@@ -259,19 +214,26 @@ class GradioUI:
             "",
         )
 
-    def append_example_message(x: gr.SelectData, history):
-        if x.value["text"] is not None:
-            history.append((x.value["text"], None))
-        if "files" in x.value:
-            if isinstance(x.value["files"], list):
-                for file in x.value["files"]:
-                    history.append((file, None))
-            else:
-                history.append((x.value["files"], None))
-        return history
+
 
     def launch(self, **kwargs):
         import gradio as gr
+        def append_example_message(x: gr.SelectData, messages):
+            if x.value["text"] is not None:
+                message = x.value["text"]
+            if "files" in x.value:
+                if isinstance(x.value["files"], list):
+                    message = "Here are the files: "
+                    for file in x.value["files"]:
+                        message += f"{file}, "
+                else:
+                    message = x.value["files"]
+            messages.append(gr.ChatMessage(role="user", content=message))
+            #print(message)
+            #messages=message
+            #return messages
+            return message
+
         examples = [
             {
                 "text": "Calculate the VaR for returns: 0.1, -0.2, 0.05, -0.15, 0.3",  # Message to populate
@@ -302,24 +264,22 @@ class GradioUI:
                 resizeable=True,
                 scale=1,
                 # Description
-                examples=examples,  # Example inputs
+                examples=examples,
+                placeholder="""<h1>FRM Study chatbot</h1>""",
+                # Example inputs
             )
-            chatbot.example_select(self.append_example_message, [chatbot], [chatbot]).then(self.interact_with_agent, [stored_messages, chatbot], [chatbot])
+
+
             # If an upload folder is provided, enable the upload feature
-            if self.file_upload_folder is not None:
-                upload_file = gr.File(label="Upload a file")
-                upload_status = gr.Textbox(label="Upload Status", interactive=False, visible=False)
-                upload_file.change(
-                    self.upload_file,
-                    [upload_file, file_uploads_log],
-                    [upload_status, file_uploads_log],
-                )
             text_input = gr.Textbox(lines=1, label="Chat Message")
             text_input.submit(
                 self.log_user_message,
                 [text_input, file_uploads_log],
                 [stored_messages, text_input],
             ).then(self.interact_with_agent, [stored_messages, chatbot], [chatbot])
+            chatbot.example_select(append_example_message, chatbot, text_input)#.then(self.interact_with_agent, chatbot, chatbot)
+
+
 
 
         demo.launch(debug=True, share=True, **kwargs)

UIexample.py

@@ -0,0 +1,221 @@
+from __future__ import annotations as _annotations
+
+import json
+import os
+from dataclasses import dataclass
+from typing import Any
+
+import gradio as gr
+from dotenv import load_dotenv
+from httpx import AsyncClient
+from pydantic_ai import Agent, ModelRetry, RunContext
+from pydantic_ai.messages import ModelStructuredResponse, ModelTextResponse, ToolReturn
+
+load_dotenv()
+
+
+@dataclass
+class Deps:
+    client: AsyncClient
+    weather_api_key: str | None
+    geo_api_key: str | None
+
+
+weather_agent = Agent(
+    "openai:gpt-4o",
+    system_prompt="You are an expert packer. A user will ask you for help packing for a trip given a destination. Use your weather tools to provide a concise and effective packing list. Also ask follow up questions if neccessary.",
+    deps_type=Deps,
+    retries=2,
+)
+
+
+@weather_agent.tool
+async def get_lat_lng(
+    ctx: RunContext[Deps], location_description: str
+) -> dict[str, float]:
+    """Get the latitude and longitude of a location.
+    Args:
+        ctx: The context.
+        location_description: A description of a location.
+    """
+    if ctx.deps.geo_api_key is None:
+        # if no API key is provided, return a dummy response (London)
+        return {"lat": 51.1, "lng": -0.1}
+
+    params = {
+        "q": location_description,
+        "api_key": ctx.deps.geo_api_key,
+    }
+    r = await ctx.deps.client.get("https://geocode.maps.co/search", params=params)
+    r.raise_for_status()
+    data = r.json()
+
+    if data:
+        return {"lat": data[0]["lat"], "lng": data[0]["lon"]}
+    else:
+        raise ModelRetry("Could not find the location")
+
+
+@weather_agent.tool
+async def get_weather(ctx: RunContext[Deps], lat: float, lng: float) -> dict[str, Any]:
+    """Get the weather at a location.
+    Args:
+        ctx: The context.
+        lat: Latitude of the location.
+        lng: Longitude of the location.
+    """
+    if ctx.deps.weather_api_key is None:
+        # if no API key is provided, return a dummy response
+        return {"temperature": "21 °C", "description": "Sunny"}
+
+    params = {
+        "apikey": ctx.deps.weather_api_key,
+        "location": f"{lat},{lng}",
+        "units": "metric",
+    }
+    r = await ctx.deps.client.get(
+        "https://api.tomorrow.io/v4/weather/realtime", params=params
+    )
+    r.raise_for_status()
+    data = r.json()
+
+    values = data["data"]["values"]
+    # https://docs.tomorrow.io/reference/data-layers-weather-codes
+    code_lookup = {
+        1000: "Clear, Sunny",
+        1100: "Mostly Clear",
+        1101: "Partly Cloudy",
+        1102: "Mostly Cloudy",
+        1001: "Cloudy",
+        2000: "Fog",
+        2100: "Light Fog",
+        4000: "Drizzle",
+        4001: "Rain",
+        4200: "Light Rain",
+        4201: "Heavy Rain",
+        5000: "Snow",
+        5001: "Flurries",
+        5100: "Light Snow",
+        5101: "Heavy Snow",
+        6000: "Freezing Drizzle",
+        6001: "Freezing Rain",
+        6200: "Light Freezing Rain",
+        6201: "Heavy Freezing Rain",
+        7000: "Ice Pellets",
+        7101: "Heavy Ice Pellets",
+        7102: "Light Ice Pellets",
+        8000: "Thunderstorm",
+    }
+    return {
+        "temperature": f'{values["temperatureApparent"]:0.0f}°C',
+        "description": code_lookup.get(values["weatherCode"], "Unknown"),
+    }
+
+
+TOOL_TO_DISPLAY_NAME = {"get_lat_lng": "Geocoding API", "get_weather": "Weather API"}
+
+client = AsyncClient()
+weather_api_key = os.getenv("WEATHER_API_KEY")
+# create a free API key at https://geocode.maps.co/
+geo_api_key = os.getenv("GEO_API_KEY")
+deps = Deps(client=client, weather_api_key=weather_api_key, geo_api_key=geo_api_key)
+
+
+async def stream_from_agent(prompt: str, chatbot: list[dict], past_messages: list):
+    chatbot.append({"role": "user", "content": prompt})
+    yield gr.Textbox(interactive=False, value=""), chatbot, gr.skip()
+    async with weather_agent.run_stream(
+        prompt, deps=deps, message_history=past_messages
+    ) as result:
+        for message in result.new_messages():
+            past_messages.append(message)
+            if isinstance(message, ModelStructuredResponse):
+                for call in message.calls:
+                    gr_message = {
+                        "role": "assistant",
+                        "content": "",
+                        "metadata": {
+                            "title": f"### 🛠️ Using {TOOL_TO_DISPLAY_NAME[call.tool_name]}",
+                            "id": call.tool_id,
+                        },
+                    }
+                    chatbot.append(gr_message)
+            if isinstance(message, ToolReturn):
+                for gr_message in chatbot:
+                    if gr_message.get("metadata", {}).get("id", "") == message.tool_id:
+                        gr_message["content"] = f"Output: {json.dumps(message.content)}"
+            yield gr.skip(), chatbot, gr.skip()
+        chatbot.append({"role": "assistant", "content": ""})
+        async for message in result.stream_text():
+            chatbot[-1]["content"] = message
+            yield gr.skip(), chatbot, gr.skip()
+        data = await result.get_data()
+        past_messages.append(ModelTextResponse(content=data))
+        yield gr.Textbox(interactive=True), gr.skip(), past_messages
+
+
+async def handle_retry(chatbot, past_messages: list, retry_data: gr.RetryData):
+    new_history = chatbot[: retry_data.index]
+    previous_prompt = chatbot[retry_data.index]["content"]
+    past_messages = past_messages[: retry_data.index]
+    async for update in stream_from_agent(previous_prompt, new_history, past_messages):
+        yield update
+
+
+def undo(chatbot, past_messages: list, undo_data: gr.UndoData):
+    new_history = chatbot[: undo_data.index]
+    past_messages = past_messages[: undo_data.index]
+    return chatbot[undo_data.index]["content"], new_history, past_messages
+
+
+def select_data(message: gr.SelectData) -> str:
+    return message.value["text"]
+
+
+with gr.Blocks() as demo:
+    gr.HTML(
+        """
+<div style="display: flex; justify-content: center; align-items: center; gap: 2rem; padding: 1rem; width: 100%">
+    <img src="https://ai.pydantic.dev/img/logo-white.svg" style="max-width: 200px; height: auto">
+    <div>
+        <h1 style="margin: 0 0 1rem 0">Vacation Packing Assistant</h1>
+        <h3 style="margin: 0 0 0.5rem 0">
+            This assistant will help you pack for your vacation. Enter your destination and it will provide you with a concise packing list based on the weather forecast.
+        </h3>
+        <h3 style="margin: 0">
+            Feel free to ask for help with any other questions you have about your trip!
+        </h3>
+    </div>
+</div>
+"""
+    )
+    past_messages = gr.State([])
+    chatbot = gr.Chatbot(
+        label="Packing Assistant",
+        type="messages",
+        avatar_images=(None, "https://ai.pydantic.dev/img/logo-white.svg"),
+        examples=[
+            {"text": "I am going to Paris for the holidays, what should I pack?"},
+            {"text": "I am going to Tokyo this week."},
+        ],
+    )
+    with gr.Row():
+        prompt = gr.Textbox(
+            lines=1,
+            show_label=False,
+            placeholder="I am planning a trip to Miami, what should I pack?",
+        )
+    generation = prompt.submit(
+        stream_from_agent,
+        inputs=[prompt, chatbot, past_messages],
+        outputs=[prompt, chatbot, past_messages],
+    )
+    chatbot.example_select(select_data, None, [prompt])
+    chatbot.retry(
+        handle_retry, [chatbot, past_messages], [prompt, chatbot, past_messages]
+    )
+    chatbot.undo(undo, [chatbot, past_messages], [prompt, chatbot, past_messages])
+
+
+if __name__ == "__main__":
+    demo.launch()

UIexample2.py

@@ -0,0 +1,230 @@
+#https://huggingface.co/spaces/vonliechti/SQuAD_Agent_Experiment/blob/main/app.py
+import gradio as gr
+from gradio import ChatMessage
+from utils import stream_from_transformers_agent
+from gradio.context import Context
+from gradio import Request
+import pickle
+import os
+from dotenv import load_dotenv
+from agent import get_agent, DEFAULT_TASK_SOLVING_TOOLBOX
+from transformers.agents import (
+    DuckDuckGoSearchTool,
+    ImageQuestionAnsweringTool,
+    VisitWebpageTool,
+)
+from tools.text_to_image import TextToImageTool
+from PIL import Image
+from transformers import load_tool
+from prompts import (
+    DEFAULT_SQUAD_REACT_CODE_SYSTEM_PROMPT,
+    FOCUSED_SQUAD_REACT_CODE_SYSTEM_PROMPT,
+)
+from pygments.formatters import HtmlFormatter
+
+
+load_dotenv()
+
+SESSION_PERSISTENCE_ENABLED = os.getenv("SESSION_PERSISTENCE_ENABLED", False)
+
+sessions_path = "sessions.pkl"
+sessions = (
+    pickle.load(open(sessions_path, "rb"))
+    if SESSION_PERSISTENCE_ENABLED and os.path.exists(sessions_path)
+    else {}
+)
+
+# If currently hosted on HuggingFace Spaces, use the default model, otherwise use the local model
+model_name = (
+    "meta-llama/Meta-Llama-3.1-8B-Instruct"
+    if os.getenv("SPACE_ID") is not None
+    else "http://localhost:1234/v1"
+)
+
+"""
+The ImageQuestionAnsweringTool from Transformers Agents 2.0 has a bug where 
+it said it accepts the path to an image, but it does not. 
+This class uses the adapter pattern to fix the issue, in a way that may be 
+compatible with future versions of the tool even if the bug is fixed.
+"""
+class FixImageQuestionAnsweringTool(ImageQuestionAnsweringTool):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def encode(self, image: "Image | str", question: str):
+        if isinstance(image, str):
+            image = Image.open(image)
+        return super().encode(image, question)
+
+"""
+The app version of the agent has access to additional tools that are not available
+during benchmarking. We chose this approach to focus benchmarking on the agent's
+ability to solve questions about the SQuAD dataset, without the help of general 
+knowledge available on the web.  For the purposes of the project, the demo 
+app has access to additional tools to provide a more interactive and engaging experience.
+"""
+ADDITIONAL_TOOLS = [
+    DuckDuckGoSearchTool(),
+    VisitWebpageTool(),
+    FixImageQuestionAnsweringTool(),
+    load_tool("speech_to_text"),
+    load_tool("text_to_speech"),
+    load_tool("translation"),
+    TextToImageTool(),
+]
+
+# Add image tools to the default task solving toolbox, for a more visually interactive experience
+TASK_SOLVING_TOOLBOX = DEFAULT_TASK_SOLVING_TOOLBOX + ADDITIONAL_TOOLS
+
+# Using the focused prompt, which was the top-performing prompt during benchmarking
+system_prompt = FOCUSED_SQUAD_REACT_CODE_SYSTEM_PROMPT
+
+agent = get_agent(
+    model_name=model_name,
+    toolbox=TASK_SOLVING_TOOLBOX,
+    system_prompt=system_prompt,
+    use_openai=True,  # Use OpenAI instead of a local or HF model as the base LLM engine
+)
+
+def append_example_message(x: gr.SelectData, messages):
+    if x.value["text"] is not None:
+        message = x.value["text"]
+    if "files" in x.value:
+        if isinstance(x.value["files"], list):
+            message = "Here are the files: "
+            for file in x.value["files"]:
+                message += f"{file}, "
+        else:
+            message = x.value["files"]
+    messages.append(ChatMessage(role="user", content=message))
+    return messages
+
+
+def add_message(message, messages):
+    messages.append(ChatMessage(role="user", content=message))
+    return messages
+
+
+def interact_with_agent(messages, request: Request):
+    session_hash = request.session_hash
+    prompt = messages[-1]["content"]
+    agent.logs = sessions.get(session_hash + "_logs", [])
+    yield messages, gr.update(
+        value="<center><h1>Thinking...</h1></center>", visible=True
+    )
+    for msg in stream_from_transformers_agent(agent, prompt):
+        if isinstance(msg, ChatMessage):
+            messages.append(msg)
+            yield messages, gr.update(visible=True)
+        else:
+            yield messages, gr.update(
+                value=f"<center><h1>{msg}</h1></center>", visible=True
+            )
+    yield messages, gr.update(value="<center><h1>Idle</h1></center>", visible=False)
+
+
+def persist(component):
+
+    def resume_session(value, request: Request):
+        session_hash = request.session_hash
+        print(f"Resuming session for {session_hash}")
+        state = sessions.get(session_hash, value)
+        agent.logs = sessions.get(session_hash + "_logs", [])
+        return state
+
+    def update_session(value, request: Request):
+        session_hash = request.session_hash
+        print(f"Updating persisted session state for {session_hash}")
+        sessions[session_hash] = value
+        sessions[session_hash + "_logs"] = agent.logs
+        if SESSION_PERSISTENCE_ENABLED:
+            pickle.dump(sessions, open(sessions_path, "wb"))
+
+    Context.root_block.load(resume_session, inputs=[component], outputs=component)
+    component.change(update_session, inputs=[component], outputs=None)
+
+    return component
+
+
+from gradio.components import (
+    Component as GradioComponent,
+)
+from gradio.components.chatbot import (
+    Chatbot,
+    FileDataDict,
+    FileData,
+    ComponentMessage,
+    FileMessage,
+)
+
+
+class CleanChatBot(Chatbot):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def _postprocess_content(
+        self,
+        chat_message: (
+            str | tuple | list | FileDataDict | FileData | GradioComponent | None
+        ),
+    ) -> str | FileMessage | ComponentMessage | None:
+        response = super()._postprocess_content(chat_message)
+        print(f"Post processing content: {response}")
+        if isinstance(response, ComponentMessage):
+            print(f"Setting open to False for {response}")
+            response.props["open"] = False
+        return response
+
+
+with gr.Blocks(
+    fill_height=True,
+    css=".gradio-container .message .content {text-align: left;}"
+    + HtmlFormatter().get_style_defs(".highlight"),
+) as demo:
+    state = gr.State()
+    inner_monologue_component = gr.Markdown(
+        """<h2>Inner Monologue</h2>""", visible=False
+    )
+    chatbot = persist(
+        gr.Chatbot(
+            value=[],
+            label="SQuAD Agent",
+            type="messages",
+            avatar_images=(
+                None,
+                "SQuAD.png",
+            ),
+            scale=1,
+            autoscroll=True,
+            show_copy_all_button=True,
+            show_copy_button=True,
+            placeholder="""<h1>SQuAD Agent</h1>
+            <h2>I am your friendly guide to the Stanford Question and Answer Dataset (SQuAD).</h2>
+            <h2>You can ask me questions about the dataset. You can also ask me to create images 
+            to help illustrate the topics under discussion, or expand the discussion beyond the dataset.</h2>
+        """,
+            examples=[
+                {
+                    "text": "What is on top of the Notre Dame building?",
+                },
+                {
+                    "text": "What is the Olympic Torch made of?",
+                },
+                {
+                    "text": "Draw a picture of whatever is on top of the Notre Dame building.",
+                },
+            ],
+        )
+    )
+    text_input = gr.Textbox(lines=1, label="Chat Message", scale=0)
+    chat_msg = text_input.submit(add_message, [text_input, chatbot], [chatbot])
+    bot_msg = chat_msg.then(
+        interact_with_agent, [chatbot], [chatbot, inner_monologue_component]
+    )
+    text_input.submit(lambda: "", None, text_input)
+    chatbot.example_select(append_example_message, [chatbot], [chatbot]).then(
+        interact_with_agent, [chatbot], [chatbot, inner_monologue_component]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

UItest.py

@@ -0,0 +1,55 @@
+import gradio as gr
+import os
+# Multimodal Chatbot demo that shows support for examples (example messages shown within the chatbot).
+
+def print_like_dislike(x: gr.LikeData):
+    print(x.index, x.value, x.liked)
+
+def add_message(history, message):
+    for x in message["files"]:
+        history.append(((x,), None))
+    if message["text"] is not None:
+        history.append((message["text"], None))
+    return history, gr.MultimodalTextbox(value=None, interactive=False)
+
+def append_example_message(x: gr.SelectData, history):
+    if x.value["text"] is not None:
+        history.append((x.value["text"], None))
+    if "files" in x.value:
+        if isinstance(x.value["files"], list):
+            for file in x.value["files"]:
+                history.append((file, None))
+        else:
+            history.append((x.value["files"], None))
+    return history
+
+def respond(history):
+    history[-1][1] = "Cool!"
+    return history
+
+with gr.Blocks(fill_height=True) as demo:
+    chatbot = gr.Chatbot(
+        elem_id="chatbot",
+        bubble_full_width=False,
+        scale=1,
+        placeholder='<h1 style="font-weight: bold; color: #FFFFFF; text-align: center; font-size: 48px; font-family: Arial, sans-serif;">Welcome to Gradio!</h1>',
+        examples=[{"icon": os.path.join(os.path.dirname(__file__), "files/avatar.png"), "display_text": "Display Text Here!", "text": "Try this example with this audio.", "files": [os.path.join(os.path.dirname(__file__), "files/cantina.wav")]},
+                     {"text": "Try this example with this image.", "files": [os.path.join(os.path.dirname(__file__), "files/avatar.png")]},
+                     {"text": "This is just text, no files!"},
+                     {"text": "Try this example with this image.", "files": [os.path.join(os.path.dirname(__file__), "files/avatar.png"), os.path.join(os.path.dirname(__file__), "files/avatar.png")]},
+                     {"text": "Try this example with this Audio.", "files": [os.path.join(os.path.dirname(__file__), "files/cantina.wav")]}]
+    )
+
+    chat_input = gr.MultimodalTextbox(interactive=True,
+                                      file_count="multiple",
+                                      placeholder="Enter message or upload file...", show_label=False)
+
+    chat_msg = chat_input.submit(add_message, [chatbot, chat_input], [chatbot, chat_input])
+    bot_msg = chat_msg.then(respond, chatbot, chatbot, api_name="bot_response")
+    bot_msg.then(lambda: gr.MultimodalTextbox(interactive=True), None, [chat_input])
+
+    chatbot.like(print_like_dislike, None, None)
+    chatbot.example_select(append_example_message, [chatbot], [chatbot]).then(respond, chatbot, chatbot, api_name="respond")
+
+if __name__ == "__main__":
+    demo.launch()

app.py

@@ -115,7 +115,7 @@ def provide_my_information(query: str) -> str:
         return "I'm sorry, I don't have information on that. Please ask about my name, location, occupation, education, skills, hobbies, or contact details."
 
 
-qcm_tool = QCMTool("info/questions.json")
+#qcm_tool = QCMTool("info/questions.json")
 final_answer = FinalAnswerTool()
 visit_webpage = VisitWebpageTool()
 web_search = DuckDuckGoSearchTool()
@@ -141,7 +141,7 @@ with open("prompts.yaml", 'r') as stream:
     
 agent = CodeAgent(
     model=model,
-    tools=[final_answer,calculate_risk_metrics,qcm_tool,visit_webpage,web_search,provide_my_information], ## add your tools here (don't remove final answer)
+    tools=[final_answer,calculate_risk_metrics,visit_webpage,web_search,provide_my_information], ## add your tools here (don't remove final answer)
     max_steps=6,
     verbosity_level=1,
     grammar=None,

tools/QCMTool.py

@@ -3,6 +3,7 @@ from smolagents.tools import Tool
 import json
 import random
 
+
 class QCMTool(Tool):
     """
     A tool for running multiple-choice question (QCM) quizzes.
@@ -106,10 +107,11 @@ class QCMTool(Tool):
         else:
             return f"Incorrect! 😞\nExplanation: {explanation}"
 
+
 if __name__ == "__main__":
     # Initialize the QCM tool
     qcm_tool = QCMTool(json_file="../info/questions.json")
-    question=qcm_tool._pick_random_question()
+    question = qcm_tool._pick_random_question()
     print(question)
 
     # Simulate a user answering 'A'
@@ -117,4 +119,4 @@ if __name__ == "__main__":
         result = qcm_tool.forward(user_answer="A")
         print(result)
     except ValueError as e:
-        print(f"Error: {e}")
+        print(f"Error: {e}")