1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

from geopy.geocoders import Nominatim
import pandas as pd
import requests
import uuid

# gets latitude and longitude
def get_lat_long(location):
    geolocator = Nominatim(user_agent="my_application_" + str(uuid.uuid4()))
    location = geolocator.geocode(location)
    return (location.latitude, location.longitude)

# gets weather data for the enxt five days - returns a dataframe
def get_weather(location_response, location):
    api_key = YOUR_OPEN_WEATHER_MAP_API_KEY   # Replace with your API key from Open Weather Map
    base_url = "https://api.openweathermap.org/data/2.5/forecast"
    params = {
        'lat': location_response[0],  # latitude
        'lon': location_response[1],  # longitude
        'appid': api_key,
        'units': 'metric'   # change 'metric' to 'imperial' for Fahrenheit
    }
    response = requests.get(base_url, params=params)
    weather_data = response.json()
    df = pd.json_normalize(weather_data['list']).drop(columns='weather')
    df['location'] = location
        
    return df

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

import openai
import pandas as pd
import json

def parse_location(query):
    
    # OpenAI function calling
    
    function_call = [
    {
      "name": "get_lat_long",
      "description": "Takes the location as an argument. Returns a tuple (latiude, longitude)",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {
            "type": "string",
            "description": '''Do not answer the question. Only respond with the location, or the location of the landmark/tourist attraction mentioned.
      Location must be in the form City name, state code (only for the US) and country code divided by comma.
      Please use ISO 3166 country codes.'''
          }
        },
        "required": ["location"]
      }
    }
    ]
    
    # Open AI API Call
    openai.api_key = YOUR_OPEN_AI_API_KEY  # Replace this with your openAI API key

    message = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "system", "content": query}],
        functions = function_call,
        function_call = 'auto',
        temperature=0
    )
    
    arguments = message["choices"][0]["message"]["function_call"]["arguments"]
    arguments_dict = json.loads(arguments)
    location = arguments_dict['location'] 
    
    print(f"LOCATION!: {location}")

    return location

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

<OpenAIObject chat.completion id=chatcmpl-7byJmyUNMNeYIIQhrBQ295u4JqM4C at 0x1f654544680> JSON: {
  "id": "chatcmpl-7byJmyUNMNeYIIQhrBQ295u4JqM4C",
  "object": "chat.completion",
  "created": 1689284354,
  "model": "gpt-4-0613",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "{\n  \"location\": \"Paris, FR\"\n}"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 124,
    "completion_tokens": 12,
    "total_tokens": 136
  }
}
    }
  ],
  "usage": {
    "prompt_tokens": 132,
    "completion_tokens": 19,
    "total_tokens": 151
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from sqlalchemy import create_engine
import openai
import pandas as pd
from langchain import OpenAI, SQLDatabase, SQLDatabaseChain

# load data in memeory to sql lite database
def load_data(df):
  engine = create_engine('sqlite:///:memory:')

  # Write the data to the SQLite database
  df.to_sql('weather', engine, if_exists='replace', index=False)

  # Check if the data was loaded correctly
  df_loaded = pd.read_sql('SELECT * FROM weather', engine)
  db = SQLDatabase(engine)
  return db

# run langchain sql database chain 
def run_query(query, db):
  openai_token = YOUR_OPENAI_KEY
  llm = OpenAI(temperature=0, verbose=True, openai_api_key=openai_token)
  db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True, use_query_checker=True)
  response = db_chain.run(query)
  return response

1
2
3

query = "What's the best day to visit the Eiffel Tower for the best view of the city?"
query_1 = f"{query} Return an explanation alongside your response, and a description of the relevant weather conditions"