feat: Update skills package and add vehicle status functionality

apis.py

@@ -1,5 +1,3 @@
-import requests
-
 from geopy.geocoders import Nominatim
 
 
@@ -53,287 +51,4 @@ def check_city_coordinates(lat = "", lon = "", city = "", **kwargs):
             lon = coord.longitude
     return lat, lon, city
 
-# Select coordinates at equal distance, including the last one
-def select_equally_spaced_coordinates(coords, number_of_points=10):
-    n = len(coords)
-    selected_coords = []
-    interval = max((n - 1) / (number_of_points - 1), 1)
-    for i in range(number_of_points):
-        # Calculate the index, ensuring it doesn't exceed the bounds of the list
-        index = int(round(i * interval))
-        if index < n:
-            selected_coords.append(coords[index])
-    return selected_coords
-
-def find_points_of_interest(lat="0", lon="0", city="", type_of_poi="restaurant", **kwargs):
-    """
-    Return some of the closest points of interest for a specific location and type of point of interest. The more parameters there are, the more precise.
-    :param lat (string):  latitude
-    :param lon (string):  longitude
-    :param city (string): Required. city
-    :param type_of_poi (string): Required. type of point of interest depending on what the user wants to do.
-    """
-    lat, lon, city = check_city_coordinates(lat,lon,city)
-
-    r = requests.get(f'https://api.tomtom.com/search/2/search/{type_of_poi}'
-                     '.json?key={0}&lat={1}&lon={2}&radius=10000&idxSet=POI&limit=100'.format(
-                        TOMTOM_KEY,
-                        lat,
-                        lon
-    ))
-
-    # Parse JSON from the response
-    data = r.json()
-    #print(data)
-    # Extract results
-    results = data['results']
-
-    # Sort the results based on distance
-    sorted_results = sorted(results, key=lambda x: x['dist'])
-    #print(sorted_results)
-
-    # Format and limit to top 5 results
-    formatted_results = [
-        f"The {type_of_poi} {result['poi']['name']} is {int(result['dist'])} meters away"
-        for result in sorted_results[:5]
-    ]
-
-
-    return ". ".join(formatted_results)
-
-def find_route(lat_depart="0", lon_depart="0", city_depart="", address_destination="", depart_time ="", **kwargs):
-    """
-    Return the distance and the estimated time to go to a specific destination from the current place, at a specified depart time.
-    :param lat_depart (string):  latitude of depart
-    :param lon_depart (string):  longitude of depart
-    :param city_depart (string): Required. city of depart
-    :param address_destination (string): Required. The destination
-    :param depart_time (string):  departure hour, in the format '08:00:20'.
-    """
-    print(address_destination)
-    date = "2025-03-29T"
-    departure_time = '2024-02-01T' + depart_time
-    lat, lon, city = check_city_coordinates(lat_depart,lon_depart,city_depart)
-    lat_dest, lon_dest = find_coordinates(address_destination)
-    #print(lat_dest, lon_dest)
-    
-    #print(departure_time)
-
-    r = requests.get('https://api.tomtom.com/routing/1/calculateRoute/{0},{1}:{2},{3}/json?key={4}&departAt={5}'.format(
-                        lat_depart,
-                        lon_depart,
-                        lat_dest,
-                        lon_dest,
-                        TOMTOM_KEY,
-                        departure_time
-    ))
-
-    # Parse JSON from the response
-    data = r.json()
-    #print(data)
-    
-    #print(data)
-    
-    result = data['routes'][0]['summary']
-
-    # Calculate distance in kilometers (1 meter = 0.001 kilometers)
-    distance_km = result['lengthInMeters'] * 0.001
-
-    # Calculate travel time in minutes (1 second = 1/60 minutes)
-    time_minutes = result['travelTimeInSeconds'] / 60
-    if time_minutes < 60:
-        time_display = f"{time_minutes:.0f} minutes"
-    else:
-        hours = int(time_minutes / 60)
-        minutes = int(time_minutes % 60)
-        time_display = f"{hours} hours" + (f" and {minutes} minutes" if minutes > 0 else "")
-        
-    # Extract arrival time from the JSON structure
-    arrival_time_str = result['arrivalTime']
-
-    # Convert string to datetime object
-    arrival_time = datetime.fromisoformat(arrival_time_str)
-
-    # Extract and display the arrival hour in HH:MM format
-    arrival_hour_display = arrival_time.strftime("%H:%M")
-
-
-    # return the distance and time
-    return(f"The route to go to {address_destination} is {distance_km:.2f} km and {time_display}. Leaving now, the arrival time is estimated at {arrival_hour_display} " )
-
-    
-    # Sort the results based on distance
-    #sorted_results = sorted(results, key=lambda x: x['dist'])
-
-    #return ". ".join(formatted_results)
-
-
-def search_along_route(latitude_depart, longitude_depart, city_destination, type_of_poi):
-    """
-    Return some of the closest points of interest along the route from the depart point, specified by its coordinates and a city destination.
-    :param latitude_depart (string):  Required. Latitude of depart location
-    :param longitude_depart (string):  Required. Longitude of depart location
-    :param city_destination (string): Required. City destination
-    :param type_of_poi (string): Required. type of point of interest depending on what the user wants to do.
-    """
-    
-    lat_dest, lon_dest = find_coordinates(city_destination)
-    print(lat_dest)
-    
-    r = requests.get('https://api.tomtom.com/routing/1/calculateRoute/{0},{1}:{2},{3}/json?key={4}'.format(
-                        latitude_depart,
-                        longitude_depart,
-                        lat_dest,
-                        lon_dest,
-                        TOMTOM_KEY
-    ))
-    
-    coord_route = select_equally_spaced_coordinates(r.json()['routes'][0]['legs'][0]['points'])
-
-    # The API endpoint for searching along a route
-    url = f'https://api.tomtom.com/search/2/searchAlongRoute/{type_of_poi}.json?key={TOMTOM_KEY}&maxDetourTime=700&limit=20&sortBy=detourTime'
-
-    # The data payload
-    payload = {
-      "route": {
-        "points": [
-          {"lat": float(latitude_depart), "lon": float(longitude_depart)},
-          {"lat": float(coord_route[1]['latitude']), "lon": float(coord_route[1]['longitude'])},
-          {"lat": float(coord_route[2]['latitude']), "lon": float(coord_route[2]['longitude'])},
-          {"lat": float(coord_route[3]['latitude']), "lon": float(coord_route[3]['longitude'])},
-          {"lat": float(coord_route[4]['latitude']), "lon": float(coord_route[4]['longitude'])},
-          {"lat": float(coord_route[5]['latitude']), "lon": float(coord_route[5]['longitude'])},
-          {"lat": float(coord_route[6]['latitude']), "lon": float(coord_route[6]['longitude'])},
-          {"lat": float(coord_route[7]['latitude']), "lon": float(coord_route[7]['longitude'])},
-          {"lat": float(coord_route[8]['latitude']), "lon": float(coord_route[8]['longitude'])},
-          {"lat": float(lat_dest), "lon": float(lon_dest)},
-        ]
-      }
-    }
-
-    # Make the POST request
-    response = requests.post(url, json=payload)
-
-    # Check if the request was successful
-    if response.status_code == 200:
-        # Parse the JSON response
-        data = response.json()
-        print(json.dumps(data, indent=4))
-    else:
-        print('Failed to retrieve data:', response.status_code)
-    answer = ""
-    for result in data['results']:
-        name = result['poi']['name']
-        address = result['address']['freeformAddress']
-        detour_time = result['detourTime']
-        answer = answer + f" \nAlong the route to {city_destination}, there is the {name} at {address} that would represent a detour of {int(detour_time/60)} minutes."
-        
-    return answer
-
-
-#current weather API
-def get_weather(city_name:str= "", **kwargs):
-    """
-    Returns the CURRENT weather in a specified city.
-    Args:
-    city_name (string) : Required. The name of the city.
-    """
-    # The endpoint URL provided by WeatherAPI
-    url = f"http://api.weatherapi.com/v1/current.json?key={WEATHER_API_KEY}&q={city_name}&aqi=no"
-
-    # Make the API request
-    response = requests.get(url)
-
-    if response.status_code == 200:
-        # Parse the JSON response
-        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']
-        wind_mph = weather_data['current']['wind_mph']
-        humidity = weather_data['current']['humidity']
-        feelslike_c = weather_data['current']['feelslike_c']
-
-        # Formulate the sentences
-        weather_sentences = (
-            f"The current weather in {location}, {region}, {country} is {condition_text} "
-            f"with a temperature of {temperature_c}°C that feels like {feelslike_c}°C. "
-            f"Humidity is at {humidity}%. "
-            f"Wind speed is {wind_mph} mph."
-        )
-        return weather_sentences
-    else:
-        # Handle errors
-        return f"Failed to get weather data: {response.status_code}, {response.text}"
-
-
-
-#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
-    # 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)
-    
-
-        # Extract the 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')
-            
-            if when == 1:
-                number_str = 'today'
-            elif when == 2:
-                number_str = 'tomorrow'
-            else:
-                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
-            # 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}'
-    
 

car_assistant_eta.ipynb

@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -11,14 +11,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
     "from langchain_community.llms import Ollama\n",
     "from langchain.tools.base import StructuredTool\n",
     "\n",
-    "from skills import get_weather, find_route, get_forecast, vehicle_status, vehicle\n",
+    "from skills import get_weather, find_route, get_forecast, vehicle_status, search_points_of_interests, vehicle, search_along_route_w_coordinates\n",
     "from skills import extract_func_args\n",
     "\n",
     "# llm = Ollama(model=\"new-nexus\")\n",
@@ -27,7 +27,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -35,12 +35,13 @@
     "    StructuredTool.from_function(get_weather),\n",
     "    StructuredTool.from_function(find_route),\n",
     "    StructuredTool.from_function(vehicle_status),\n",
+    "    StructuredTool.from_function(search_points_of_interests),\n",
     "]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -56,7 +57,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -71,7 +72,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -91,7 +92,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 78,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -104,16 +105,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
-    "pp = get_prompt(RAVEN_PROMPT_FUNC, \"What is the weather like in New York?\", \"\", tools)"
+    "pp = get_prompt(RAVEN_PROMPT_FUNC, \"Are there any italian restaurants nearby?\", \"\", tools)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -122,7 +123,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 63,
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"Call: search_points_of_interests(search_query='italian restaurant') \""
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "llm_response"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -133,41 +154,43 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 79,
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('search_points_of_interests', {'search_query': 'italian restaurant'})"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "func_name, kwargs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "http://api.weatherapi.com/v1/current.json?key=d1c4d0d8ef6847339a0125737240903&q=New York&aqi=no\n"
+      "POI search vehicle's lat: 49.6002, lon: 6.1296\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "('The current weather in New York, New York, United States of America is Partly cloudy with a temperature of 13.9°C that feels like 12.5°C. Humidity is at 57%. Wind speed is 3.6 kph.',\n",
-       " {'location': {'name': 'New York',\n",
-       "   'region': 'New York',\n",
-       "   'country': 'United States of America',\n",
-       "   'lat': 40.71,\n",
-       "   'lon': -74.01,\n",
-       "   'tz_id': 'America/New_York',\n",
-       "   'localtime_epoch': 1714856966,\n",
-       "   'localtime': '2024-05-04 17:09'},\n",
-       "  'current': {'last_updated': '2024-05-04 17:00',\n",
-       "   'temp_c': 13.9,\n",
-       "   'condition': {'text': 'Partly cloudy'},\n",
-       "   'wind_kph': 3.6,\n",
-       "   'wind_dir': 'N',\n",
-       "   'precip_mm': 0.0,\n",
-       "   'precip_in': 0.0,\n",
-       "   'humidity': 57,\n",
-       "   'cloud': 75,\n",
-       "   'feelslike_c': 12.5}})"
+       "'There are 30 options in the vicinity. The most relevant are: Luci-Italian Restaurant is 823 meters away.\\n La Briscola is 171 meters away.\\n Casa Giuditta is 92 meters away'"
       ]
      },
-     "execution_count": 79,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -178,13 +201,130 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
     "#getattr(skills, func_name)(*args)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Categories POI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import requests\n",
+    "from skills.common import config"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "res = requests.get(f\"https://api.tomtom.com/search/2/poiCategories.json?key={config.TOMTOM_API_KEY}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = res.json()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = data[\"poiCategories\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "categories = [dict(id=category[\"id\"],name=category[\"name\"]) for category in data]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def search_categories(categories, search_term):\n",
+    "    return [category for category in categories if search_term.lower() in category[\"name\"].lower()]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[{'id': 7315044, 'name': 'Spanish Restaurant'}]"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "search_categories(categories, \"spa\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test POI Along Route"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "lat_dest: 49.5206, lon_dest: 6.29716\n",
+      "lat_depart: 49.6002, lon_depart: 6.1296\n"
+     ]
+    }
+   ],
+   "source": [
+    "output, points = find_route(\"Ellange, Luxembourg\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "search"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},

skills/__init__.py

@@ -3,6 +3,7 @@ import inspect
 from .common import execute_function_call, extract_func_args, vehicle
 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
 
 
@@ -22,4 +23,4 @@ def format_functions_for_prompt_raven(*functions):
     return "\n".join(formatted_functions)
 
 
-SKILLS_PROMPT = format_functions_for_prompt_raven(get_weather, get_forecast, find_route)
+SKILLS_PROMPT = format_functions_for_prompt_raven(get_weather, get_forecast, find_route, search_points_of_interests)

skills/common.py

@@ -59,4 +59,4 @@ vehicle = VehicleStatus(
     date="2025-03-29",
     time="08:00:20",
     destination="Kirchberg Campus, Kirchberg"
-)
+)

skills/poi.py

@@ -0,0 +1,143 @@
+import json
+import requests
+from .common import config, vehicle
+
+
+# Select coordinates at equal distance, including the last one
+def select_equally_spaced_coordinates(coords, number_of_points=10):
+    n = len(coords)
+    selected_coords = []
+    interval = max((n - 1) / (number_of_points - 1), 1)
+    for i in range(number_of_points):
+        # Calculate the index, ensuring it doesn't exceed the bounds of the list
+        index = int(round(i * interval))
+        if index < n:
+            selected_coords.append(coords[index])
+    return selected_coords
+
+
+def search_points_of_interests(search_query="french restaurant"):
+    """
+    Return some of the closest points of interest matching the query.
+    :param search_query (string): Required. Describing the type of point of interest depending on what the user wants to do. Make sure to include the type of POI you are looking for. For example italian restaurant, grocery shop, etc.
+    """
+
+    # Extract the latitude and longitude of the vehicle
+    vehicle_coordinates = getattr(vehicle, "location_coordinates")
+    lat, lon = vehicle_coordinates
+    print(f"POI search vehicle's lat: {lat}, lon: {lon}")
+
+    # https://developer.tomtom.com/search-api/documentation/search-service/search
+    r = requests.get(
+        f"https://api.tomtom.com/search/2/search/{search_query}.json?key={config.TOMTOM_API_KEY}&lat={lat}&lon={lon}&category&radius=1000&limit=100",
+        timeout=5,
+    )
+
+    # Parse JSON from the response
+    data = r.json()
+    # Extract results
+    results = data["results"]
+
+    # TODO: Handle the no results case.
+    if not results:
+        return "No results found in the vicinity."
+
+    # Sort the results based on distance
+    # sorted_results = sorted(results, key=lambda x: x["dist"])
+    # print(sorted_results)
+
+    # Format and limit to top 5 results
+    formatted_results = [
+        f"{result['poi']['name']} is {int(result['dist'])} meters away"
+        for result in results[:3]
+    ]
+
+    output = (
+        f"There are {len(results)} options in the vicinity. The most relevant are: "
+    )
+    return output + ".\n ".join(formatted_results)
+
+
+def find_points_of_interest(lat="0", lon="0", type_of_poi="restaurant"):
+    """
+    Return some of the closest points of interest for a specific location and type of point of interest. The more parameters there are, the more precise.
+    :param lat (string):  latitude
+    :param lon (string):  longitude
+    :param city (string): Required. city
+    :param type_of_poi (string): Required. type of point of interest depending on what the user wants to do.
+    """
+    # https://developer.tomtom.com/search-api/documentation/search-service/points-of-interest-search
+    r = requests.get(
+        f"https://api.tomtom.com/search/2/search/{type_of_poi}"
+        ".json?key={0}&lat={1}&lon={2}&radius=10000&vehicleTypeSet=Car&idxSet=POI&limit=100".format(
+            config.TOMTOM_API_KEY, lat, lon
+        )
+    )
+
+    # Parse JSON from the response
+    data = r.json()
+    # print(data)
+    # Extract results
+    results = data["results"]
+
+    # Sort the results based on distance
+    sorted_results = sorted(results, key=lambda x: x["dist"])
+    # print(sorted_results)
+
+    # Format and limit to top 5 results
+    formatted_results = [
+        f"The {type_of_poi} {result['poi']['name']} is {int(result['dist'])} meters away"
+        for result in sorted_results[:5]
+    ]
+
+    return ". ".join(formatted_results)
+
+
+def search_along_route_w_coordinates(points: list[tuple[float, float]], query: str):
+    """
+    Return some of the closest points of interest along the route from the depart point, specified by its coordinates.
+    :param points (list[tuple(float, float)]): Required. List of tuples of latitude and longitude of the points along the route.
+    :param query (string): Required. type of point of interest depending on what the user wants to do.
+    """
+
+    # The API endpoint for searching along a route
+    url = f"https://api.tomtom.com/search/2/searchAlongRoute/{query}.json?key={config.TOMTOM_API_KEY}&maxDetourTime=360&limit=20&sortBy=detourTime"
+
+    points = select_equally_spaced_coordinates(points, number_of_points=20)
+
+    # The data payload
+    payload = {
+        "route": {
+            "points": [{"lat": pt["latitude"], "lon": pt["longitude"]} for pt in points]
+        }
+    }
+
+    # Make the POST request
+    response = requests.post(url, json=payload, timeout=5)
+
+    # Check if the request was successful
+    if response.status_code == 200:
+        # Parse the JSON response
+        data = response.json()
+        # print(json.dumps(data, indent=4))
+    else:
+        print("Failed to retrieve data:", response.status_code)
+        return "Failed to retrieve data. Please try again."
+    answer = ""
+    if not data["results"]:
+        return "No results found along the way."
+
+    if len(data["results"]) == 20:
+        answer = "There more than 20 results along the way. Here are the top 3 results:"
+    elif len(data["results"]) > 3:
+        answer = f"There are {len(data['results'])} results along the way. Here are the top 3 results:"
+    for result in data["results"][:3]:
+        name = result["poi"]["name"]
+        address = result["address"]["freeformAddress"]
+        detour_time = result["detourTime"]
+        answer = (
+            answer
+            + f" \n{name} at {address} would require a detour of {int(detour_time/60)} minutes."
+        )
+
+    return answer

skills/routing.py

@@ -1,7 +1,5 @@
 from datetime import datetime
-
 import requests
-
 from .common import config, vehicle
 
 
@@ -10,6 +8,7 @@ def find_coordinates(address):
     Find the coordinates of a specific address.
     :param address (string): Required. The address
     """
+    # https://developer.tomtom.com/geocoding-api/documentation/geocode
     url = f"https://api.tomtom.com/search/2/geocode/{address}.json?key={config.TOMTOM_API_KEY}"
     response = requests.get(url)
     data = response.json()
@@ -19,11 +18,10 @@ def find_coordinates(address):
 
 
 def calculate_route():
-    api_key = "api_key"
     origin = "49.631997,6.171029"
     destination = "49.586745,6.140002"
 
-    url = f"https://api.tomtom.com/routing/1/calculateRoute/{origin}:{destination}/json?key={api_key}"
+    url = f"https://api.tomtom.com/routing/1/calculateRoute/{origin}:{destination}/json?key={config.TOMTOM_API_KEY}"
     response = requests.get(url)
     data = response.json()
 
@@ -65,7 +63,8 @@ def find_route_tomtom(
     :param lon_dest (string):  longitude of destination
     :param depart_time (string):  departure hour, in the format '08:00:20'.
     """
-
+    # https://developer.tomtom.com/routing-api/documentation/routing/calculate-route
+    # https://developer.tomtom.com/routing-api/documentation/routing/guidance-instructions
     r = requests.get(
         f"https://api.tomtom.com/routing/1/calculateRoute/{lat_depart},{lon_depart}:{lat_dest},{lon_dest}/json?key={config.TOMTOM_API_KEY}&departAt={depart_datetime}",
         timeout=5,
@@ -132,4 +131,4 @@ def find_route(destination=""):
     arrival_hour_display = arrival_time.strftime("%H:%M")
 
     # return the distance and time
-    return f"This is the answer you must copy exactly as is: The route to {destination} is {distance_km:.2f} km and {time_display}. Leaving now, the arrival time is estimated at {arrival_hour_display} "
+    return f"The route to {destination} is {distance_km:.2f} km and {time_display}. Leaving now, the arrival time is estimated at {arrival_hour_display}.", raw_response["routes"][0]["legs"][0]["points"]

skills/vehicle.py

@@ -1,4 +1,4 @@
-from skills import vehicle
+from .common import vehicle
 
 
 STATUS_TEMPLATE = """We are at {location}, current time: {time}, current date: {date} and our destination is: {destination}.