Update app.py

app.py

@@ -1,285 +1,287 @@
-# '''Copyright 2024 Ashok Kumar
+'''Copyright 2024 Ashok Kumar
 
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
 
-#     http://www.apache.org/licenses/LICENSE-2.0
+    http://www.apache.org/licenses/LICENSE-2.0
 
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.'''
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.'''
 
-# import os
-# import requests
-# import json
-# import pandas as pd
-# import numpy as np
-# import requests
-# import geopandas as gpd
-# import contextily as ctx
-# import tzlocal
-# import pytz 
-# from PIL import Image
-# from datetime import datetime
-# import matplotlib.pyplot as plt
-# from geopy.exc import GeocoderTimedOut
-# from geopy.geocoders import Nominatim
-# import warnings
-# warnings.filterwarnings('ignore')
-# from plotly.graph_objs import Marker
-# import plotly.express as px
-# import streamlit as st
-# from data import flight_data
-# from huggingface_hub import InferenceApi, login, InferenceClient
+import os
+import requests
+import json
+import pandas as pd
+import numpy as np
+import requests
+import geopandas as gpd
+import contextily as ctx
+import tzlocal
+import pytz 
+from PIL import Image
+from datetime import datetime
+import matplotlib.pyplot as plt
+from geopy.exc import GeocoderTimedOut
+from geopy.geocoders import Nominatim
+import warnings
+warnings.filterwarnings('ignore')
+from plotly.graph_objs import Marker
+import plotly.express as px
+import streamlit as st
+from data import flight_data
+from huggingface_hub import InferenceApi, login, InferenceClient
 
 
-# hf_token = os.getenv("HF_TOKEN")
-# if hf_token is None:
-#     raise ValueError("Hugging Face token not found. Please set the HF_TOKEN environment variable.")
-# login(hf_token)
+hf_token = os.getenv("HF_TOKEN")
+if hf_token is None:
+    raise ValueError("Hugging Face token not found. Please set the HF_TOKEN environment variable.")
+login(hf_token)
 
 
-# API_URL = "https://api-inference.huggingface.co/models/google/tapas-base-finetuned-wtq"
-# headers = {"Authorization": f"Bearer {hf_token}"}
+API_URL = "https://api-inference.huggingface.co/models/google/tapas-base-finetuned-wtq"
+headers = {"Authorization": f"Bearer {hf_token}"}
 
-# def query(payload):
-#     response = requests.post(API_URL, headers=headers, json=payload)
-#     return response.json()
+def query(payload):
+    response = requests.post(API_URL, headers=headers, json=payload)
+    return response.json()
 
-# def query_flight_data(geo_df, question):
+def query_flight_data(geo_df, question):
 
 
-#     table_data = {
-#         "icao24": geo_df["icao24"].astype(str).iloc[:100].tolist(),
-#         "callsign": geo_df["callsign"].astype(str).replace({np.nan: None, np.inf: '0'}).iloc[:100].tolist(),
-#         "origin_country": geo_df["origin_country"].astype(str).replace({np.nan: None, np.inf: '0'}).iloc[:100].tolist(),
-#         "time_position": geo_df["time_position"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
-#         "last_contact": geo_df["last_contact"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
-#         "longitude": geo_df["longitude"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
-#         "latitude": geo_df["latitude"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
-#         "baro_altitude": geo_df["baro_altitude"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
-#         "on_ground": geo_df["on_ground"].astype(str).iloc[:100].tolist(),  # Assuming on_ground is boolean or categorical
-#         "velocity": geo_df["velocity"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
-#         "true_track": geo_df["true_track"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
-#         "vertical_rate": geo_df["vertical_rate"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
-#         "sensors": geo_df["sensors"].astype(str).replace({np.nan: None, np.inf: '0'}).iloc[:100].tolist(), # Assuming sensors can be None
-#         "geo_altitude": geo_df["geo_altitude"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
-#         "squawk": geo_df["squawk"].astype(str).replace({np.nan: None, np.inf: '0'}).iloc[:100].tolist(), # Assuming squawk can be None
-#         "spi": geo_df["spi"].astype(str).iloc[:100].tolist(),  # Assuming spi is boolean or categorical
-#         "position_source": geo_df["position_source"].astype(str).iloc[:100].tolist(),  # Assuming position_source is categorical
-#         "time": geo_df["time"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
-#         "geometry": geo_df["geometry"].astype(str).replace({np.nan: None, np.inf: '0'}).iloc[:100].tolist() # Assuming geometry can be None
-#     }
+    table_data = {
+        "icao24": geo_df["icao24"].astype(str).iloc[:100].tolist(),
+        "callsign": geo_df["callsign"].astype(str).replace({np.nan: None, np.inf: '0'}).iloc[:100].tolist(),
+        "origin_country": geo_df["origin_country"].astype(str).replace({np.nan: None, np.inf: '0'}).iloc[:100].tolist(),
+        "time_position": geo_df["time_position"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
+        "last_contact": geo_df["last_contact"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
+        "longitude": geo_df["longitude"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
+        "latitude": geo_df["latitude"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
+        "baro_altitude": geo_df["baro_altitude"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
+        "on_ground": geo_df["on_ground"].astype(str).iloc[:100].tolist(),  # Assuming on_ground is boolean or categorical
+        "velocity": geo_df["velocity"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
+        "true_track": geo_df["true_track"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
+        "vertical_rate": geo_df["vertical_rate"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
+        "sensors": geo_df["sensors"].astype(str).replace({np.nan: None, np.inf: '0'}).iloc[:100].tolist(), # Assuming sensors can be None
+        "geo_altitude": geo_df["geo_altitude"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
+        "squawk": geo_df["squawk"].astype(str).replace({np.nan: None, np.inf: '0'}).iloc[:100].tolist(), # Assuming squawk can be None
+        "spi": geo_df["spi"].astype(str).iloc[:100].tolist(),  # Assuming spi is boolean or categorical
+        "position_source": geo_df["position_source"].astype(str).iloc[:100].tolist(),  # Assuming position_source is categorical
+        "time": geo_df["time"].astype(str).replace({np.nan: '0', np.inf: '0'}).iloc[:100].tolist(),
+        "geometry": geo_df["geometry"].astype(str).replace({np.nan: None, np.inf: '0'}).iloc[:100].tolist() # Assuming geometry can be None
+    }
 
 
-#     # Construct the payload
-#     payload = {
-#         "inputs": {
-#             "query": question,
-#             "table": table_data,
-#         }
-#     }
+    # Construct the payload
+    payload = {
+        "inputs": {
+            "query": question,
+            "table": table_data,
+        }
+    }
 
-#     # Get the model response
-#     response = query(payload)
+    # Get the model response
+    response = query(payload)
 
-#     # Check if 'answer' is in response and return it as a sentence
-#     if 'answer' in response:
-#         answer = response['answer']
-#         return f"The answer to your question '{question}': :orange[{answer}]"
-#     else:
-#         return "The model could not find an answer to your question."
+    # Check if 'answer' is in response and return it as a sentence
+    if 'answer' in response:
+        answer = response['answer']
+        return f"The answer to your question '{question}': :orange[{answer}]"
+    else:
+        return "The model could not find an answer to your question."
 
 
-# def flight_tracking(flight_view_level, country, local_time_zone, flight_info, airport, color):
-#     geolocator = Nominatim(user_agent="flight_tracker")
-#     loc = geolocator.geocode(country)
-#     loc_box = loc[1]
-#     extend_left =+12*flight_view_level
-#     extend_right =+10*flight_view_level
-#     extend_top =+10*flight_view_level
-#     extend_bottom =+ 18*flight_view_level
-#     lat_min, lat_max = (loc_box[0] - extend_left), loc_box[0]+extend_right
-#     lon_min, lon_max = (loc_box[1] - extend_bottom), loc_box[1]+extend_top
+def flight_tracking(flight_view_level, country, local_time_zone, flight_info, airport, color):
+    geolocator = Nominatim(user_agent="flight_tracker")
+    loc = geolocator.geocode(country)
+    loc_box = loc[1]
+    extend_left =+12*flight_view_level
+    extend_right =+10*flight_view_level
+    extend_top =+10*flight_view_level
+    extend_bottom =+ 18*flight_view_level
+    lat_min, lat_max = (loc_box[0] - extend_left), loc_box[0]+extend_right
+    lon_min, lon_max = (loc_box[1] - extend_bottom), loc_box[1]+extend_top
     
-#     tile_zoom = 8 # zoom of the map loaded by contextily
-#     figsize = (15, 15)
-#     columns = ["icao24","callsign","origin_country","time_position","last_contact","longitude","latitude",
-#             "baro_altitude","on_ground","velocity","true_track","vertical_rate","sensors","geo_altitude",
-#             "squawk","spi","position_source",]
-#     data_url = "https://raw.githubusercontent.com/ashok2216-A/ashok_airport-data/main/data/airports.dat"
-#     column_names = ["Airport ID", "Name", "City", "Country", "IATA/FAA", "ICAO", "Latitude", "Longitude",
-#                     "Altitude", "Timezone", "DST", "Tz database time zone", "Type", "Source"]
-#     airport_df = pd.read_csv(data_url, header=None, names=column_names)
-#     airport_locations = airport_df[["Name", "City", "Country", "IATA/FAA", "Latitude", "Longitude"]]
-#     airport_country_loc = airport_locations[airport_locations['Country'] == str(loc)]
-#     airport_country_loc = airport_country_loc[(airport_country_loc['Country'] == str(loc)) & (airport_country_loc['Latitude'] >= lat_min) &
-#                             (airport_country_loc['Latitude'] <= lat_max) & (airport_country_loc['Longitude'] >= lon_min) &
-#                             (airport_country_loc['Longitude'] <= lon_max)]
-#     def get_traffic_gdf():
-#         url_data = (
-#                 f"https://@opensky-network.org/api/states/all?"
-#                 f"lamin={str(lat_min)}"
-#                 f"&lomin={str(lon_min)}"
-#                 f"&lamax={str(lat_max)}"
-#                 f"&lomax={str(lon_max)}")
-#         json_dict = requests.get(url_data).json()
-
-#         unix_timestamp = int(json_dict["time"])
-#         local_timezone = pytz.timezone(local_time_zone) # get pytz timezone
-#         local_time = datetime.fromtimestamp(unix_timestamp, local_timezone).strftime('%Y-%m-%d %H:%M:%S')
-#         time = []
-#         for i in range(len(json_dict['states'])):
-#             time.append(local_time)
-#         df_time = pd.DataFrame(time,columns=['time'])
-#         state_df = pd.DataFrame(json_dict["states"],columns=columns)
-#         state_df['time'] = df_time
-#         gdf = gpd.GeoDataFrame(
-#                 state_df,
-#                 geometry=gpd.points_from_xy(state_df.longitude, state_df.latitude),
-#                 crs={"init": "epsg:4326"},  # WGS84
-#             )
-#         # banner_image = Image.open('banner.png')
-#         # st.image(banner_image, width=300)
-#         st.title("Live Flight Tracker")
-#         st.subheader('Flight Details', divider='rainbow')
-#         st.write('Location: {0}'.format(loc))
-#         st.write('Current Local Time: {0}-{1}:'.format(local_time, local_time_zone))
-#         st.write("Minimum_latitude is {0} and Maximum_latitude is {1}".format(lat_min, lat_max))
-#         st.write("Minimum_longitude is {0} and Maximum_longitude is {1}".format(lon_min, lon_max))
-#         st.write('Number of Visible Flights: {}'.format(len(json_dict['states'])))
-#         st.write('Plotting the flight: {}'.format(flight_info))
-#         st.subheader('Map Visualization', divider='rainbow')
-#         st.write('****Click ":orange[Update Map]" Button to Refresh the Map****')
-#         return gdf
+    tile_zoom = 8 # zoom of the map loaded by contextily
+    figsize = (15, 15)
+    columns = ["icao24","callsign","origin_country","time_position","last_contact","longitude","latitude",
+            "baro_altitude","on_ground","velocity","true_track","vertical_rate","sensors","geo_altitude",
+            "squawk","spi","position_source",]
+    data_url = "https://raw.githubusercontent.com/ashok2216-A/ashok_airport-data/main/data/airports.dat"
+    column_names = ["Airport ID", "Name", "City", "Country", "IATA/FAA", "ICAO", "Latitude", "Longitude",
+                    "Altitude", "Timezone", "DST", "Tz database time zone", "Type", "Source"]
+    airport_df = pd.read_csv(data_url, header=None, names=column_names)
+    airport_locations = airport_df[["Name", "City", "Country", "IATA/FAA", "Latitude", "Longitude"]]
+    airport_country_loc = airport_locations[airport_locations['Country'] == str(loc)]
+    airport_country_loc = airport_country_loc[(airport_country_loc['Country'] == str(loc)) & (airport_country_loc['Latitude'] >= lat_min) &
+                            (airport_country_loc['Latitude'] <= lat_max) & (airport_country_loc['Longitude'] >= lon_min) &
+                            (airport_country_loc['Longitude'] <= lon_max)]
+    def get_traffic_gdf():
+        url_data = (
+                f"https://@opensky-network.org/api/states/all?"
+                f"lamin={str(lat_min)}"
+                f"&lomin={str(lon_min)}"
+                f"&lamax={str(lat_max)}"
+                f"&lomax={str(lon_max)}")
+        json_dict = requests.get(url_data).json()
 
-#     geo_df = get_traffic_gdf()
-#     if airport == 0:
-#         fig = px.scatter_mapbox(geo_df, lat="latitude", lon="longitude",color=flight_info,
-#                             color_continuous_scale=color, zoom=4,width=1200, height=600,opacity=1,
-#                             hover_name ='origin_country',hover_data=['callsign', 'baro_altitude',
-#         'on_ground', 'velocity', 'true_track', 'vertical_rate', 'geo_altitude'], template='plotly_dark')
-#     elif airport == 1:
-#         fig = px.scatter_mapbox(geo_df, lat="latitude", lon="longitude",color=flight_info,
-#                             color_continuous_scale=color, zoom=4,width=1200, height=600,opacity=1,
-#                             hover_name ='origin_country',hover_data=['callsign', 'baro_altitude',
-#         'on_ground', 'velocity', 'true_track', 'vertical_rate', 'geo_altitude'], template='plotly_dark')
-#         fig.add_trace(px.scatter_mapbox(airport_country_loc, lat="Latitude", lon="Longitude",
-#                                         hover_name ='Name', hover_data=["City", "Country", "IATA/FAA"]).data[0])
-#     else: None
-#     fig.update_layout(mapbox_style="carto-darkmatter")
-#     fig.update_layout(margin={"r": 0, "t": 0, "l": 0, "b": 0})
-#     # out = fig.show())
-#     out = st.plotly_chart(fig, theme=None)
-#     return out
-# st.set_page_config(
-#     layout="wide"
-# )
-# image = Image.open('logo.png')
-# add_selectbox = st.sidebar.image(
-#     image, width=150
-# )
-# add_selectbox = st.sidebar.subheader(
-#     "Configure Map",divider='rainbow'
-# )
-# with st.sidebar:
-#     Refresh = st.button('Update Map', key=1)
-#     on = st.toggle('View Airports')
-#     if on:
-#         air_port = 1
-#         st.write(':rainbow[Nice Work Buddy!]')
-#         st.write('Now Airports are Visible')
-#     else:
-#         air_port=0
-#     view = st.slider('Increase Flight Visibility',1,6,2)
-#     st.write("You Selected:", view)
-#     cou = st.text_input('Type Country Name', 'north america')
-#     st.write('The current Country name is', cou)
-#     time = st.text_input('Type Time Zone Name (Ex: America/Toronto, Europe/Berlin)', 'Asia/Kolkata')
-#     st.write('The current Time Zone is', time)
-#     info = st.selectbox(
-#     'Select Flight Information',
-#     ('baro_altitude',
-#         'on_ground', 'velocity',
-#         'geo_altitude'))
-#     st.write('Plotting the data of Flight:', info)
-#     clr = st.radio('Pick A Color for Scatter Plot',["rainbow","ice","hot"])
-#     if clr == "rainbow":
-#         st.write('The current color is', "****:rainbow[Rainbow]****")
-#     elif clr == 'ice':
-#         st.write('The current color is', "****:blue[Ice]****")
-#     elif clr == 'hot':
-#         st.write('The current color is', "****:red[Hot]****")
-#     else: None
-# # with st.spinner('Wait!, We Requesting API Data...'):
-# # try:
-# flight_tracking(flight_view_level=view, country=cou,flight_info=info,
-#             local_time_zone=time, airport=air_port, color=clr)
-# st.subheader('Ask your Questions!', divider='rainbow')
-# st.write("Google's TAPAS base LLM model 🤖")
-# geo_df = flight_data(flight_view_level = view, country= cou, flight_info=info, local_time_zone=time, airport=1)
-# question = st.text_input('Type your questions here', "What is the squawk code for SWR9XD?")
-# result = query_flight_data(geo_df, question)
-# st.markdown(result)
-# # except TypeError:
-# #     st.error(':red[Error: ] Please Re-run this page.', icon="🚨")
-# #     st.button('Re-run', type="primary")
-# # st.snow()
- 
-import streamlit as st
-from huggingface_hub import InferenceClient
-import os
+        unix_timestamp = int(json_dict["time"])
+        local_timezone = pytz.timezone(local_time_zone) # get pytz timezone
+        local_time = datetime.fromtimestamp(unix_timestamp, local_timezone).strftime('%Y-%m-%d %H:%M:%S')
+        time = []
+        for i in range(len(json_dict['states'])):
+            time.append(local_time)
+        df_time = pd.DataFrame(time,columns=['time'])
+        state_df = pd.DataFrame(json_dict["states"],columns=columns)
+        state_df['time'] = df_time
+        gdf = gpd.GeoDataFrame(
+                state_df,
+                geometry=gpd.points_from_xy(state_df.longitude, state_df.latitude),
+                crs={"init": "epsg:4326"},  # WGS84
+            )
+        # banner_image = Image.open('banner.png')
+        # st.image(banner_image, width=300)
+        st.title("Live Flight Tracker")
+        st.subheader('Flight Details', divider='rainbow')
+        st.write('Location: {0}'.format(loc))
+        st.write('Current Local Time: {0}-{1}:'.format(local_time, local_time_zone))
+        st.write("Minimum_latitude is {0} and Maximum_latitude is {1}".format(lat_min, lat_max))
+        st.write("Minimum_longitude is {0} and Maximum_longitude is {1}".format(lon_min, lon_max))
+        st.write('Number of Visible Flights: {}'.format(len(json_dict['states'])))
+        st.write('Plotting the flight: {}'.format(flight_info))
+        st.subheader('Map Visualization', divider='rainbow')
+        st.write('****Click ":orange[Update Map]" Button to Refresh the Map****')
+        return gdf
 
-hf_token = os.getenv("HF_TOKEN")
-# Set up the Hugging Face Inference Client
-client = InferenceClient(
-    provider="together",  # Replace with the correct provider if needed
-    api_key= hf_token  # Replace with your Hugging Face API key
+    geo_df = get_traffic_gdf()
+    if airport == 0:
+        fig = px.scatter_mapbox(geo_df, lat="latitude", lon="longitude",color=flight_info,
+                            color_continuous_scale=color, zoom=4,width=1200, height=600,opacity=1,
+                            hover_name ='origin_country',hover_data=['callsign', 'baro_altitude',
+        'on_ground', 'velocity', 'true_track', 'vertical_rate', 'geo_altitude'], template='plotly_dark')
+    elif airport == 1:
+        fig = px.scatter_mapbox(geo_df, lat="latitude", lon="longitude",color=flight_info,
+                            color_continuous_scale=color, zoom=4,width=1200, height=600,opacity=1,
+                            hover_name ='origin_country',hover_data=['callsign', 'baro_altitude',
+        'on_ground', 'velocity', 'true_track', 'vertical_rate', 'geo_altitude'], template='plotly_dark')
+        fig.add_trace(px.scatter_mapbox(airport_country_loc, lat="Latitude", lon="Longitude",
+                                        hover_name ='Name', hover_data=["City", "Country", "IATA/FAA"]).data[0])
+    else: None
+    fig.update_layout(mapbox_style="carto-darkmatter")
+    fig.update_layout(margin={"r": 0, "t": 0, "l": 0, "b": 0})
+    # out = fig.show())
+    out = st.plotly_chart(fig, theme=None)
+    return out
+st.set_page_config(
+    layout="wide"
+)
+image = Image.open('logo.png')
+add_selectbox = st.sidebar.image(
+    image, width=150
 )
+add_selectbox = st.sidebar.subheader(
+    "Configure Map",divider='rainbow'
+)
+with st.sidebar:
+    Refresh = st.button('Update Map', key=1)
+    on = st.toggle('View Airports')
+    if on:
+        air_port = 1
+        st.write(':rainbow[Nice Work Buddy!]')
+        st.write('Now Airports are Visible')
+    else:
+        air_port=0
+    view = st.slider('Increase Flight Visibility',1,6,2)
+    st.write("You Selected:", view)
+    cou = st.text_input('Type Country Name', 'north america')
+    st.write('The current Country name is', cou)
+    time = st.text_input('Type Time Zone Name (Ex: America/Toronto, Europe/Berlin)', 'Asia/Kolkata')
+    st.write('The current Time Zone is', time)
+    info = st.selectbox(
+    'Select Flight Information',
+    ('baro_altitude',
+        'on_ground', 'velocity',
+        'geo_altitude'))
+    st.write('Plotting the data of Flight:', info)
+    clr = st.radio('Pick A Color for Scatter Plot',["rainbow","ice","hot"])
+    if clr == "rainbow":
+        st.write('The current color is', "****:rainbow[Rainbow]****")
+    elif clr == 'ice':
+        st.write('The current color is', "****:blue[Ice]****")
+    elif clr == 'hot':
+        st.write('The current color is', "****:red[Hot]****")
+    else: None
+# with st.spinner('Wait!, We Requesting API Data...'):
+# try:
+flight_tracking(flight_view_level=view, country=cou,flight_info=info,
+            local_time_zone=time, airport=air_port, color=clr)
+st.subheader('Ask your Questions!', divider='rainbow')
+st.write("Google's TAPAS base LLM model 🤖")
+geo_df = flight_data(flight_view_level = view, country= cou, flight_info=info, local_time_zone=time, airport=1)
+question = st.text_input('Type your questions here', "What is the squawk code for SWR9XD?")
+result = query_flight_data(geo_df, question)
+st.markdown(result)
+# except TypeError:
+#     st.error(':red[Error: ] Please Re-run this page.', icon="🚨")
+#     st.button('Re-run', type="primary")
+# st.snow()
 
-# Streamlit app title
-st.title("🤖 Deepseek R1 Chatbot")
-st.write("Chat with the Deepseek R1 model powered by Hugging Face Inference API.")
 
-# Initialize session state to store chat history
-if "messages" not in st.session_state:
-    st.session_state.messages = []
 
-# Display chat history
-for message in st.session_state.messages:
-    with st.chat_message(message["role"]):
-        st.markdown(message["content"])
+# import streamlit as st
+# from huggingface_hub import InferenceClient
+# import os
 
-# User input
-if prompt := st.chat_input("What would you like to ask?"):
-    # Add user message to chat history
-    st.session_state.messages.append({"role": "user", "content": prompt})
-    with st.chat_message("user"):
-        st.markdown(prompt)
+# hf_token = os.getenv("HF_TOKEN")
+# # Set up the Hugging Face Inference Client
+# client = InferenceClient(
+#     provider="together",  # Replace with the correct provider if needed
+#     api_key= hf_token  # Replace with your Hugging Face API key
+# )
 
-    # Generate response from Deepseek R1 model
-    with st.spinner("Thinking..."):
-        try:
-            # Prepare the messages for the model
-            messages = [{"role": m["role"], "content": m["content"]} for m in st.session_state.messages]
+# # Streamlit app title
+# st.title("🤖 Deepseek R1 Chatbot")
+# st.write("Chat with the Deepseek R1 model powered by Hugging Face Inference API.")
+
+# # Initialize session state to store chat history
+# if "messages" not in st.session_state:
+#     st.session_state.messages = []
+
+# # Display chat history
+# for message in st.session_state.messages:
+#     with st.chat_message(message["role"]):
+#         st.markdown(message["content"])
+
+# # User input
+# if prompt := st.chat_input("What would you like to ask?"):
+#     # Add user message to chat history
+#     st.session_state.messages.append({"role": "user", "content": prompt})
+#     with st.chat_message("user"):
+#         st.markdown(prompt)
+
+#     # Generate response from Deepseek R1 model
+#     with st.spinner("Thinking..."):
+#         try:
+#             # Prepare the messages for the model
+#             messages = [{"role": m["role"], "content": m["content"]} for m in st.session_state.messages]
             
-            # Call the Hugging Face Inference API
-            completion = client.chat.completions.create(
-                model="deepseek-ai/DeepSeek-R1",  # Replace with the correct model name
-                messages=messages,
-                max_tokens=500
-            )
+#             # Call the Hugging Face Inference API
+#             completion = client.chat.completions.create(
+#                 model="deepseek-ai/DeepSeek-R1",  # Replace with the correct model name
+#                 messages=messages,
+#                 max_tokens=500
+#             )
             
-            # Extract the model's response
-            response = completion.choices[0].message.content
+#             # Extract the model's response
+#             response = completion.choices[0].message.content
 
-            # Add model's response to chat history
-            st.session_state.messages.append({"role": "assistant", "content": response})
-            with st.chat_message("assistant"):
-                st.markdown(response)
+#             # Add model's response to chat history
+#             st.session_state.messages.append({"role": "assistant", "content": response})
+#             with st.chat_message("assistant"):
+#                 st.markdown(response)
         
-        except Exception as e:
-            st.error(f"An error occurred: {e}")
+#         except Exception as e:
+#             st.error(f"An error occurred: {e}")