chore: Update dependencies and add pyproject.toml file

{skills → kitt/skills}/weather.py

@@ -2,8 +2,9 @@ import requests
 
 from .common import config, vehicle
 
-#current weather API
-def get_weather(location:str= ""):
+
+# current weather API
+def get_weather(location: str = ""):
     """
     Returns the CURRENT weather in a specified location.
     Args:
@@ -11,7 +12,9 @@ def get_weather(location:str= ""):
     """
 
     if location == "":
-        print(f"get_weather: location is empty, using the vehicle location. ({vehicle.location})")
+        print(
+            f"get_weather: location is empty, using the vehicle location. ({vehicle.location})"
+        )
         location = vehicle.location
 
     # The endpoint URL provided by WeatherAPI
@@ -29,16 +32,16 @@ def get_weather(location:str= ""):
     weather_data = response.json()
 
     # Extracting the necessary pieces of data
-    location = weather_data['location']['name']
-    region = weather_data['location']['region']
-    country = weather_data['location']['country']
-    time = weather_data['location']['localtime']
-    temperature_c = weather_data['current']['temp_c']
-    condition_text = weather_data['current']['condition']['text']
-    if 'wind_kph' in weather_data['current']:
-        wind_kph = weather_data['current']['wind_kph']
-    humidity = weather_data['current']['humidity']
-    feelslike_c = weather_data['current']['feelslike_c']
+    location = weather_data["location"]["name"]
+    region = weather_data["location"]["region"]
+    country = weather_data["location"]["country"]
+    time = weather_data["location"]["localtime"]
+    temperature_c = weather_data["current"]["temp_c"]
+    condition_text = weather_data["current"]["condition"]["text"]
+    if "wind_kph" in weather_data["current"]:
+        wind_kph = weather_data["current"]["wind_kph"]
+    humidity = weather_data["current"]["humidity"]
+    feelslike_c = weather_data["current"]["feelslike_c"]
 
     # Formulate the sentences - {region}, {country}
     weather_sentences = (
@@ -49,65 +52,68 @@ def get_weather(location:str= ""):
     )
     return weather_sentences, weather_data
 
-#weather forecast API
-def get_forecast(city_name:str= "", when = 0, **kwargs):
+
+# weather forecast API
+def get_forecast(city_name: str = "", when=0, **kwargs):
     """
     Returns the weather forecast in a specified number of days for a specified city .
     Args:
     city_name (string) : Required. The name of the city.
     when (int) : Required. in number of days (until the day for which we want to know the forecast) (example: tomorrow is 1, in two days is 2, etc.)
     """
-    #print(when)
-    when +=1
+
+    when += 1
     # The endpoint URL provided by WeatherAPI
     url = f"http://api.weatherapi.com/v1/forecast.json?key={WEATHER_API_KEY}&q={city_name}&days={str(when)}&aqi=no"
 
-
     # Make the API request
     response = requests.get(url)
 
     if response.status_code == 200:
         # Parse the JSON response
         data = response.json()
-        
+
         # Initialize an empty string to hold our result
         forecast_sentences = ""
 
         # Extract city information
-        location = data.get('location', {})
-        city_name = location.get('name', 'the specified location')
-        
-        #print(data)
-    
+        location = data.get("location", {})
+        city_name = location.get("name", "the specified location")
+
+        # print(data)
 
         # Extract the forecast days
-        forecast_days = data.get('forecast', {}).get('forecastday', [])[when-1:]
-        #number = 0
-        
-        #print (forecast_days)
+        forecast_days = data.get("forecast", {}).get("forecastday", [])[when - 1 :]
+        # number = 0
+
+        # print (forecast_days)
 
         for day in forecast_days:
-            date = day.get('date', 'a specific day')
-            conditions = day.get('day', {}).get('condition', {}).get('text', 'weather conditions')
-            max_temp_c = day.get('day', {}).get('maxtemp_c', 'N/A')
-            min_temp_c = day.get('day', {}).get('mintemp_c', 'N/A')
-            chance_of_rain = day.get('day', {}).get('daily_chance_of_rain', 'N/A')
-            
+            date = day.get("date", "a specific day")
+            conditions = (
+                day.get("day", {})
+                .get("condition", {})
+                .get("text", "weather conditions")
+            )
+            max_temp_c = day.get("day", {}).get("maxtemp_c", "N/A")
+            min_temp_c = day.get("day", {}).get("mintemp_c", "N/A")
+            chance_of_rain = day.get("day", {}).get("daily_chance_of_rain", "N/A")
+
             if when == 1:
-                number_str = 'today'
+                number_str = "today"
             elif when == 2:
-                number_str = 'tomorrow'
+                number_str = "tomorrow"
             else:
-                number_str = f'in {when-1} days'
+                number_str = f"in {when-1} days"
 
             # Generate a sentence for the day's forecast
             forecast_sentence = f"On {date} ({number_str}) in {city_name}, the weather will be {conditions} with a high of {max_temp_c}°C and a low of {min_temp_c}°C. There's a {chance_of_rain}% chance of rain. "
-            
-            #number = number + 1
+
+            # number = number + 1
             # Add the sentence to the result
             forecast_sentences += forecast_sentence
         return forecast_sentences
     else:
         # Handle errors
-        print( f"Failed to get weather data: {response.status_code}, {response.text}")
-        return f'error {response.status_code}'
+        print(f"Failed to get weather data: {response.status_code}, {response.text}")
+        return f"error {response.status_code}"

kitt.py → main.py

@@ -1,23 +1,18 @@
 import time
 import gradio as gr
 import numpy as np
-import requests
 import torch
 import torchaudio
 from transformers import pipeline
+import typer
 
-
-
-import skills
-from skills.common import config, vehicle
-from skills.routing import calculate_route
+from kitt.skills.common import config, vehicle
+from kitt.skills.routing import calculate_route
 import ollama
 
-### LLM Stuff ###
-from langchain_community.llms import Ollama
 from langchain.tools.base import StructuredTool
 
-from skills import (
+from kitt.skills import (
     get_weather,
     find_route,
     get_forecast,
@@ -25,10 +20,10 @@ from skills import (
     search_points_of_interests,
     search_along_route_w_coordinates,
     do_anything_else,
-    date_time_info
+    date_time_info,
 )
-from skills import extract_func_args
-from core import voice_options, load_tts_pipeline, tts_gradio
+from kitt.skills import extract_func_args
+from kitt.core import voice_options, tts_gradio
 
 
 global_context = {
@@ -52,6 +47,17 @@ Answer questions concisely and do not mention what you base your reply on."
 User Query: Question: {input}<human_end>
 """
 
+
+HERMES_PROMPT_FUNC = """
+<|im_start|>system
+You are a helpful AI assistant in a car (vehicle), that follows instructions extremely well. \
+Answer questions concisely and do not mention what you base your reply on.<|im_end|>
+<|im_start|>user
+{{ .Prompt }}<|im_end|>
+<|im_start|>assistant
+"""
+
+
 def get_prompt(template, input, history, tools):
     # "vehicle_status": vehicle_status_fn()[0]
     kwargs = {"history": history, "input": input}
@@ -66,12 +72,14 @@ def get_prompt(template, input, history, tools):
 
     return template.format(**kwargs).replace("{{", "{").replace("}}", "}")
 
+
 def use_tool(func_name, kwargs, tools):
     for tool in tools:
         if tool.name == func_name:
             return tool.invoke(input=kwargs)
     return None
 
+
 # llm = Ollama(model="nexusraven", stop=["\nReflection:", "\nThought:"], keep_alive=60*10)
 
 
@@ -84,7 +92,7 @@ def search_along_route(query=""):
 
     Args:
         query (str, optional): The type of point of interest to search for. Defaults to "restaurant".
-    
+
     """
     points = global_context["route_points"]
     # maybe reshape
@@ -119,16 +127,14 @@ def run_generic_model(query):
         "options": {
             # "temperature": 0.1,
             # "stop":["\nReflection:", "\nThought:"]
-        }
+        },
     }
     out = ollama.generate(**data)
     return out["response"]
 
 
-def run_model(query, voice_character):
-    query = query.strip().replace("'", "")
-    print("Query: ", query)
-    global_context["query"] = query
+
+def run_nexusraven_model(query, voice_character):
     global_context["prompt"] = get_prompt(RAVEN_PROMPT_FUNC, query, "", tools)
     print("Prompt: ", global_context["prompt"])
     data = {
@@ -137,16 +143,13 @@ def run_model(query, voice_character):
         "model": "nexusraven",
         # "model": "smangrul/llama-3-8b-instruct-function-calling",
         "raw": True,
-        "options": {
-            "temperature": 0.5,
-            "stop":["\nReflection:", "\nThought:"]
-        }
+        "options": {"temperature": 0.5, "stop": ["\nReflection:", "\nThought:"]},
     }
     out = ollama.generate(**data)
     llm_response = out["response"]
     if "Call: " in llm_response:
         print(f"llm_response: {llm_response}")
-        llm_response = llm_response.replace("<bot_end>"," ")
+        llm_response = llm_response.replace("<bot_end>", " ")
         func_name, kwargs = extract_func_args(llm_response)
         print(f"Function: {func_name}, Args: {kwargs}")
         if func_name == "do_anything_else":
@@ -159,7 +162,57 @@ def run_model(query, voice_character):
     if type(output_text) == tuple:
         output_text = output_text[0]
     gr.Info(f"Output text: {output_text}, generating voice output...")
-    return output_text, tts_gradio(tts_pipeline, output_text, voice_character, speaker_embedding_cache)[0]
+    return (
+        output_text,
+        tts_gradio(output_text, voice_character, speaker_embedding_cache)[0],
+    )
+
+
+def run_llama3_model(query, voice_character):
+    global_context["prompt"] = get_prompt(RAVEN_PROMPT_FUNC, query, "", tools)
+    print("Prompt: ", global_context["prompt"])
+    data = {
+        "prompt": global_context["prompt"],
+        # "streaming": False,
+        # "model": "smangrul/llama-3-8b-instruct-function-calling",
+        "model": "elvee/hermes-2-pro-llama-3:8b-Q5_K_M",
+        "raw": True,
+        "options": {"temperature": 0.5, "stop": ["\nReflection:", "\nThought:"]},
+    }
+    out = ollama.generate(**data)
+    llm_response = out["response"]
+    if "Call: " in llm_response:
+        print(f"llm_response: {llm_response}")
+        llm_response = llm_response.replace("<bot_end>", " ")
+        func_name, kwargs = extract_func_args(llm_response)
+        print(f"Function: {func_name}, Args: {kwargs}")
+        if func_name == "do_anything_else":
+            output_text = run_generic_model(query)
+        else:
+            output_text = use_tool(func_name, kwargs, tools)
+    else:
+        output_text = out["response"]
+
+    if type(output_text) == tuple:
+        output_text = output_text[0]
+    gr.Info(f"Output text: {output_text}, generating voice output...")
+    return (
+        output_text,
+        tts_gradio(output_text, voice_character, speaker_embedding_cache)[0],
+    )
+
+
+def run_model(query, voice_character, state):
+
+    model = state.get("model", "nexusraven")
+    query = query.strip().replace("'", "")
+    print("Query: ", query)
+    print("Model: ", model)
+    global_context["query"] = query
+    if model == "nexusraven":
+        return run_nexusraven_model(query, voice_character)
+    elif model == "llama3":
+        return run_llama3_model(query, voice_character)
 
 
 def calculate_route_gradio(origin, destination):
@@ -171,7 +224,9 @@ def calculate_route_gradio(origin, destination):
 
 def update_vehicle_status(trip_progress):
     n_points = len(global_context["route_points"])
-    new_coords = global_context["route_points"][min(int(trip_progress / 100 * n_points), n_points - 1)]
+    new_coords = global_context["route_points"][
+        min(int(trip_progress / 100 * n_points), n_points - 1)
+    ]
     new_coords = new_coords["latitude"], new_coords["longitude"]
     print(f"Trip progress: {trip_progress}, len: {n_points}, new_coords: {new_coords}")
     vehicle.location_coordinates = new_coords
@@ -180,13 +235,17 @@ def update_vehicle_status(trip_progress):
 
 
 device = "cuda" if torch.cuda.is_available() else "cpu"
-transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base.en", device=device)
+transcriber = pipeline(
+    "automatic-speech-recognition", model="openai/whisper-base.en", device=device
+)
 
 
 def save_audio_as_wav(data, sample_rate, file_path):
     # make a tensor from the numpy array
     data = torch.tensor(data).reshape(1, -1)
-    torchaudio.save(file_path, data, sample_rate=sample_rate, bits_per_sample=16, encoding="PCM_S")
+    torchaudio.save(
+        file_path, data, sample_rate=sample_rate, bits_per_sample=16, encoding="PCM_S"
+    )
 
 
 def save_and_transcribe_audio(audio):
@@ -200,16 +259,17 @@ def save_and_transcribe_audio(audio):
         # add timestamp to file name
         filename = f"recordings/audio{time.time()}.wav"
         save_audio_as_wav(y, sr, filename)
-        
+
         sr, y = audio
         y = y.astype(np.float32)
         y /= np.max(np.abs(y))
-        text = transcriber({"sampling_rate": sr, "raw":y})["text"]
+        text = transcriber({"sampling_rate": sr, "raw": y})["text"]
     except Exception as e:
         print(f"Error: {e}")
         return "Error transcribing audio"
     return text
 
+
 # to be able to use the microphone on chrome, you will have to go to chrome://flags/#unsafely-treat-insecure-origin-as-secure and enter http://10.186.115.21:7860/
 # in "Insecure origins treated as secure", enable it and relaunch chrome
 
@@ -218,114 +278,148 @@ def save_and_transcribe_audio(audio):
 # What's the closest restaurant from here?
 
 
-tts_pipeline = load_tts_pipeline()
+def create_demo(tts_server: bool = False, model="llama3"):
+    print(f"Running the demo with model: {model} and TTSServer: {tts_server}")
+    with gr.Blocks(theme=gr.themes.Default()) as demo:
+        state = gr.State(
+            value={
+                # "context": initial_context,
+                "query": "",
+                "route_points": [],
+                "model": model,
+            }
+        )
+        trip_points = gr.State(value=[])
+
+        with gr.Row():
+            with gr.Column(scale=1, min_width=300):
+                time_picker = gr.Dropdown(
+                    choices=hour_options,
+                    label="What time is it? (HH:MM)",
+                    value="08:00:00",
+                    interactive=True,
+                )
+                history = gr.Radio(
+                    ["Yes", "No"],
+                    label="Maintain the conversation history?",
+                    value="No",
+                    interactive=True,
+                )
+                voice_character = gr.Radio(
+                    choices=voice_options,
+                    label="Choose a voice",
+                    value=voice_options[0],
+                    show_label=True,
+                )
+                origin = gr.Textbox(
+                    value="Mondorf-les-Bains, Luxembourg",
+                    label="Origin",
+                    interactive=True,
+                )
+                destination = gr.Textbox(
+                    value="Rue Alphonse Weicker, Luxembourg",
+                    label="Destination",
+                    interactive=True,
+                )
+
+            with gr.Column(scale=2, min_width=600):
+                map_plot = gr.Plot()
+                trip_progress = gr.Slider(
+                    0, 100, step=5, label="Trip progress", interactive=True
+                )
+
+                # map_if = gr.Interface(fn=plot_map, inputs=year_input, outputs=map_plot)
+
+        with gr.Row():
+            with gr.Column():
+                input_audio = gr.Audio(
+                    type="numpy",
+                    sources=["microphone"],
+                    label="Input audio",
+                    elem_id="input_audio",
+                )
+                input_text = gr.Textbox(
+                    value="How is the weather?", label="Input text", interactive=True
+                )
+                vehicle_status = gr.JSON(
+                    value=vehicle.model_dump_json(), label="Vehicle status"
+                )
+            with gr.Column():
+                output_audio = gr.Audio(label="output audio", autoplay=True)
+                output_text = gr.TextArea(
+                    value="", label="Output text", interactive=False
+                )
+
+        # Update plot based on the origin and destination
+        # Sets the current location and destination
+        origin.submit(
+            fn=calculate_route_gradio,
+            inputs=[origin, destination],
+            outputs=[map_plot, vehicle_status],
+        )
+        destination.submit(
+            fn=calculate_route_gradio,
+            inputs=[origin, destination],
+            outputs=[map_plot, vehicle_status],
+        )
+
+        # Update time based on the time picker
+        time_picker.select(fn=set_time, inputs=[time_picker], outputs=[vehicle_status])
+
+        # Run the model if the input text is changed
+        input_text.submit(
+            fn=run_model,
+            inputs=[input_text, voice_character, state],
+            outputs=[output_text, output_audio],
+        )
+
+        # Set the vehicle status based on the trip progress
+        trip_progress.release(
+            fn=update_vehicle_status, inputs=[trip_progress], outputs=[vehicle_status]
+        )
+
+        # Save and transcribe the audio
+        input_audio.stop_recording(
+            fn=save_and_transcribe_audio, inputs=[input_audio], outputs=[input_text]
+        )
+    return demo
 
 
-with gr.Blocks(theme=gr.themes.Default()) as demo:
-    state = gr.State(
-        value={
-            # "context": initial_context,
-            "query": "",
-            "route_points": [],
-        }
-    )
-    trip_points = gr.State(value=[])
-
-    with gr.Row():
-        with gr.Column(scale=1, min_width=300):
-            time_picker = gr.Dropdown(
-                choices=hour_options,
-                label="What time is it? (HH:MM)",
-                value="08:00:00",
-                interactive=True,
-            )
-            history = gr.Radio(
-                ["Yes", "No"],
-                label="Maintain the conversation history?",
-                value="No",
-                interactive=True,
-            )
-            voice_character = gr.Radio(choices=voice_options, label='Choose a voice', value=voice_options[0], show_label=True)
-            origin = gr.Textbox(
-                value="Mondorf-les-Bains, Luxembourg", label="Origin", interactive=True
-            )
-            destination = gr.Textbox(
-                value="Rue Alphonse Weicker, Luxembourg",
-                label="Destination",
-                interactive=True,
-            )
-
-        with gr.Column(scale=2, min_width=600):
-            map_plot = gr.Plot()
-            trip_progress = gr.Slider(0, 100, step=5, label="Trip progress", interactive=True)
-
-            # map_if = gr.Interface(fn=plot_map, inputs=year_input, outputs=map_plot)
-
-    with gr.Row():
-        with gr.Column():
-            input_audio = gr.Audio(
-                type="numpy",sources=["microphone"], label="Input audio", elem_id="input_audio"
-            )
-            input_text = gr.Textbox(
-                value="How is the weather?", label="Input text", interactive=True
-            )
-            vehicle_status = gr.JSON(
-                value=vehicle.model_dump_json(), label="Vehicle status"
-            )
-        with gr.Column():
-            output_audio = gr.Audio(label="output audio", autoplay=True)
-            output_text = gr.TextArea(value="", label="Output text", interactive=False)
-    # iface = gr.Interface(
-    #     fn=transcript,
-    #     inputs=[
-    #         gr.Textbox(value=initial_context, visible=False),
-    #         gr.Audio(type="filepath", label="input audio", elem_id="recorder"),
-    #         voice_character,
-    #         emotion,
-    #         place,
-    #         time_picker,
-    #         history,
-    #         gr.State(),  # This will keep track of the context state across interactions.
-    #     ],
-    #     outputs=[gr.Audio(label="output audio"), gr.Textbox(visible=False), gr.State()],
-    #     head=shortcut_js,
-    # )
-
-    # Update plot based on the origin and destination
-    # Sets the current location and destination
-    origin.submit(
-        fn=calculate_route_gradio,
-        inputs=[origin, destination],
-        outputs=[map_plot, vehicle_status],
-    )
-    destination.submit(
-        fn=calculate_route_gradio,
-        inputs=[origin, destination],
-        outputs=[map_plot, vehicle_status],
-    )
+# close all interfaces open to make the port available
+gr.close_all()
+
 
-    # Update time based on the time picker
-    time_picker.select(fn=set_time, inputs=[time_picker], outputs=[vehicle_status])
+demo = create_demo(False, "llama3")
+demo.launch(
+    debug=True,
+    server_name="0.0.0.0",
+    server_port=7860,
+    ssl_verify=False,
+    share=False,
+)
+app = typer.Typer()
 
-    # Run the model if the input text is changed
-    input_text.submit(fn=run_model, inputs=[input_text, voice_character], outputs=[output_text, output_audio])
 
-    # Set the vehicle status based on the trip progress
-    trip_progress.release(
-        fn=update_vehicle_status, inputs=[trip_progress], outputs=[vehicle_status]
+@app.command()
+def run(tts_server: bool = False):
+    global demo
+    demo = create_demo(tts_server)
+    demo.launch(
+        debug=True, server_name="0.0.0.0", server_port=7860, ssl_verify=True, share=True
     )
 
-    # Save and transcribe the audio
-    input_audio.stop_recording(
-        fn=save_and_transcribe_audio, inputs=[input_audio], outputs=[input_text]
+
+@app.command()
+def dev(tts_server: bool = False, model: str = "llama3"):
+    demo = create_demo(tts_server, model)
+    demo.launch(
+        debug=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+        ssl_verify=False,
+        share=False,
     )
 
-# close all interfaces open to make the port available
-gr.close_all()
-# Launch the interface.
 
 if __name__ == "__main__":
-    # demo.launch(debug=True, server_name="0.0.0.0", server_port=7860, ssl_verify=False)
-    demo.launch(debug=True, server_name="0.0.0.0", server_port=7860, ssl_verify=True, share=True)
-
-# iface.launch(debug=True, share=False, server_name="0.0.0.0", server_port=7860, ssl_verify=False)
+    app()

pyproject.toml

@@ -0,0 +1,18 @@
+[tool.poetry]
+name = "kitt"
+version = "0.1.0"
+description = "LLM-based Voice Assistant for Cars"
+authors = ["Sasan <[email protected]>"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+
+
+[tool.poetry.scripts]
+kitt = 'main:app'
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

skills/__init__.py

@@ -1,43 +0,0 @@
-from datetime import datetime
-import inspect
-
-from .common import execute_function_call, extract_func_args, vehicle as vehicle_obj
-from .weather import get_weather, get_forecast
-from .routing import find_route
-from .poi import search_points_of_interests, search_along_route_w_coordinates
-from .vehicle import vehicle_status
-
-
-
-def date_time_info():
-    """Get the current date and time."""
-    time = getattr(vehicle_obj, "time")
-    date = getattr(vehicle_obj, "date")
-    datetime_obj = datetime.fromisoformat(f"{date}T{time}")
-    human_readable_datetime = datetime_obj.strftime("%I:%M %p %A, %B %d, %Y")
-    return f"It is {human_readable_datetime}."
-
-
-def do_anything_else():
-    """If the user wants to do anything else call this function. If the question doesn't match any of the functions use this one."""
-    return True
-
-
-
-def format_functions_for_prompt_raven(*functions):
-    """Format functions for use in Prompt Raven.
-    
-    Args:
-    *functions (function): One or more functions to format.
-    """
-    formatted_functions = []
-    for func in functions:
-        signature = f"{func.__name__}{inspect.signature(func)}"
-        docstring = inspect.getdoc(func)
-        formatted_functions.append(
-            f"Function:\n<func_start>{signature}<func_end>\n<docstring_start>\n{docstring}\n<docstring_end>"
-        )
-    return "\n".join(formatted_functions)
-
-
-SKILLS_PROMPT = format_functions_for_prompt_raven(get_weather, get_forecast, find_route, search_points_of_interests)

skills/common.py

@@ -1,62 +0,0 @@
-import re
-from typing import Union
-
-
-from pydantic_settings import BaseSettings, SettingsConfigDict
-from pydantic import BaseModel
-
-import skills
-
-class Settings(BaseSettings):
-    WEATHER_API_KEY: str
-    TOMTOM_API_KEY: str
-
-    model_config = SettingsConfigDict(env_file=".env")
-
-
-class VehicleStatus(BaseModel):
-    location: str
-    location_coordinates: tuple[float, float] # (latitude, longitude)
-    date: str
-    time: str
-    destination: str
-
-
-def execute_function_call(text: str, dry_run=False) -> str:
-    function_name_match = re.search(r"Call: (\w+)", text)
-    function_name = function_name_match.group(1) if function_name_match else None
-    arguments = eval(f"dict{text.split(function_name)[1].strip()}")
-    function = getattr(skills, function_name) if function_name else None
-
-    if dry_run:
-        print(f"{function_name}(**{arguments})")
-        return "Dry run successful"
-
-    if function:
-        out = function(**arguments)
-    try:
-        if function:
-            out = function(**arguments)
-    except Exception as e:
-        out = str(e)
-    return out
-
-
-def extract_func_args(text: str) -> tuple[str, dict]:
-    function_name_match = re.search(r"Call: (\w+)", text)
-    function_name = function_name_match.group(1) if function_name_match else None
-    if not function_name:
-        raise ValueError("No function name found in text")
-    arguments = eval(f"dict{text.split(function_name)[1].strip()}")
-    return function_name, arguments
-
-
-config = Settings() # type: ignore
-
-vehicle = VehicleStatus(
-    location="Rue Alphonse Weicker, Luxembourg",
-    location_coordinates=(49.505, 6.28111),
-    date="2025-05-06",
-    time="08:00:00",
-    destination="Rue Alphonse Weicker, Luxembourg"
-)