Update app.py

app.py

@@ -25,32 +25,37 @@ from examples import (
 repo_id = "mistralai/Mixtral-8x7B-Instruct-v0.1"
 llm_client = InferenceClient(model=repo_id, timeout=180)
 
+end_sequence = "I hope that helps!"
 
 def generate_key_points(text):
     prompt = f"""             
-    Please generate a set of key geographical points for the following description: {text}, as a json list of less than 10 dictionnaries with the following keys: 'name', 'description'. Precise the full location in the 'name' if there is a possible ambiguity.
-    Generally try to minimze the distance between locations. Always think of the transportation means that you want to use, and the timing: morning, afternoon, where to sleep.
-    Only generate a 'Thought:' and a 'Key points:' sections, nothing else.
+    Please generate a set of key geographical points for the following description: {text}, as a json list of less than 10 dictionnaries with the following keys: 'name', 'description'.
+    Precise the full location in the 'name' if there is a possible ambiguity: for instance given that there are Chinatowns in several US cities, give the city name to disambiguate.
+    Generally try to minimize the distance between locations. Always think of the transportation means that you want to use, and the timing: morning, afternoon, where to sleep.
+    Only generate two sections: 'Thought:' provides your rationale for generating the points, then you list the locations in 'Key points:'.
+    Then generate '{end_sequence}' to indicate the end of the response.
 
     For instance:
     Description: {description_sf}
     Thought: {output_example_sf}
+    {end_sequence}
 
     Description: {description_loire}
     Thought: {output_example_loire}
+    {end_sequence}
 
     Now begin. You can make the descriptions a bit more verbose than in the examples.
 
     Description: {text}
     Thought: 
     """
-    return llm_client.text_generation(prompt, max_new_tokens=2000, stream=True)
+    return llm_client.text_generation(prompt, max_new_tokens=2000, stream=True, stop_sequences=[end_sequence])
 
 
 def parse_llm_output(output):
     rationale = "Thought: " + output.split("Key points:")[0]
     key_points = output.split("Key points:")[1]
-    output = key_points.replace("    ", "")
+    output = key_points.replace("    ", "").replace(end_sequence, "").strip()
     parsed_output = literal_eval(output)
     dataframe = pd.DataFrame.from_dict(parsed_output)
     return dataframe, rationale
@@ -67,17 +72,41 @@ class AsyncLRUCache:
         self.cache.move_to_end(key)
         return self.cache[key]
 
-    async def set(self, key, value):
+    async def aset(self, key, value):
+        self.set(key, value)
+
+    def set(self, key, value):
         if key in self.cache:
             self.cache.move_to_end(key)
         self.cache[key] = value
         if len(self.cache) > self.maxsize:
             self.cache.popitem(last=False)
 
-
 # Instantiate the cache
 cache = AsyncLRUCache(maxsize=500)
 
+preset_values = {
+    "Fisherman's Wharf, San Francisco": {'lat': 37.808332, 'lon': -122.415715},
+    'Ghirardelli Square, San Francisco': {'lat': 37.80587075, 'lon': -122.42294914207058},
+    'Cable Car Museum, San Francisco': {'lat': 37.79476015, 'lon': -122.41185284314184},
+    'Union Square, San Francisco': {'lat': 37.7875138, 'lon': -122.407159},
+    'Chinatown, San Francisco': {'lat': 37.7943011, 'lon': -122.4063757},
+    'Coit Tower, San Francisco': {'lat': 37.80237905, 'lon': -122.40583435461313},
+    'Chinatown, San Francisco, California': {'lat': 37.7943011, 'lon': -122.4063757},
+    'Chinatown, New York City, New York': {'lat': 40.7164913, 'lon': -73.9962504},
+    'Chinatown, Los Angeles, California': {'lat': 34.0638402, 'lon': -118.2358676},
+    'Chinatown, Philadelphia, Pennsylvania': {'lat': 39.9534461, 'lon': -75.1546218},
+    'Chinatown, Chicago, Illinois': {'lat': 41.8516579, 'lon': -87.6331383},
+    'Chinatown, Boston, Massachusetts': {'lat': 42.3513291, 'lon': -71.0626228},
+    'Chinatown, Honolulu, Hawaii': {'lat': 21.3129031, 'lon': -157.8628003},
+    'Chinatown, Seattle, Washington': {'lat': 47.5980601, 'lon': -122.3245246},
+    'Chinatown, Portland, Oregon': {'lat': 45.5251092, 'lon': -122.6744481},
+    'Chinatown, Las Vegas, Nevada': {'lat': 36.2823279, 'lon': -115.3310655}
+}
+for key, value in preset_values.items():
+    cache.set(key, value)
+
+
 async def geocode_address(address):
     # Check if the result is in cache
     cached_location = await cache.get(address)
@@ -91,10 +120,12 @@ async def geocode_address(address):
     ) as geolocator:
         location = await geolocator.geocode(address, timeout=10)
         if location:
+            coords = {'lat': location.latitude, "lon": location.longitude}
             # Save the result in cache for future use
-            await cache.set(address, location)
-        return location
-    
+            await cache.aset(address, coords)
+            return coords
+        return None
+
 async def ageocode_addresses(addresses):
     tasks = [geocode_address(address) for address in addresses]
     locations = await asyncio.gather(*tasks)
@@ -107,9 +138,9 @@ def geocode_addresses(addresses):
 
 
 def create_map_from_markers(dataframe):
-    locations = geocode_addresses(dataframe["name"])
-    dataframe["lat"] = [location.latitude if location else None for location in locations]
-    dataframe["lon"] = [location.longitude if location else None for location in locations]
+    coordinates = geocode_addresses(dataframe["name"])
+    dataframe["lat"] = [coords['lat'] if coords else None for coords in coordinates]
+    dataframe["lon"] = [coords['lon'] if coords else None for coords in coordinates]
 
     f_map = Map(
         location=[dataframe["lat"].mean(), dataframe["lon"].mean()],