Update app.py

app.py

@@ -229,231 +229,100 @@
 # #     st.button('Re-run', type="primary")
 # # st.snow()
  
-'''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
-
-    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.'''
-
-import os
-import requests
-import json
-import pandas as pd
-import numpy as np
-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 requests
+import os
+from huggingface_hub import login
 
+# Set up Hugging Face 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)
 
-
-# Replace with the correct model name for Deepseek r1
+# Hugging Face Inference API URL for Deepseek model
 API_URL = "https://api-inference.huggingface.co/models/deepseek-ai/deepseek-r1"
 headers = {"Authorization": f"Bearer {hf_token}"}
 
-def query(payload):
+# Function to query the Deepseek model
+def query_deepseek(payload):
+    """
+    Sends a query to the Deepseek model using Hugging Face Inference API.
+    """
     response = requests.post(API_URL, headers=headers, json=payload)
     return response.json()
 
-def query_flight_data(geo_df, question):
-    # Prepare the table data as a string or structured input depending on the model's requirements
-    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
+# Streamlit app configuration
+st.set_page_config(page_title="Deepseek Chatbot", page_icon="🤖", layout="wide")
+
+# Custom CSS for chatbot UI
+st.markdown("""
+    <style>
+    .chat-message {
+        padding: 10px;
+        border-radius: 10px;
+        margin: 5px 0;
+        max-width: 70%;
     }
-
-    # Construct the payload for Deepseek r1 model
-    payload = {
-        "inputs": {
-            "question": question,
-            "context": json.dumps(table_data),  # Convert table data to JSON string
-        }
+    .user-message {
+        background-color: #0078D4;
+        color: white;
+        margin-left: auto;
+        margin-right: 0;
     }
+    .bot-message {
+        background-color: #f1f1f1;
+        color: black;
+        margin-left: 0;
+        margin-right: auto;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+# Initialize session state for chat history
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
+
+# Streamlit app title
+st.title("🤖 Deepseek Chatbot")
+st.write("Welcome to the Deepseek Chatbot! Ask me anything, and I'll do my best to help.")
+
+# Chat input
+user_input = st.text_input("You:", placeholder="Type your message here...", key="user_input")
+
+# Send button
+if st.button("Send"):
+    if user_input.strip() != "":
+        # Add user message to chat history
+        st.session_state.chat_history.append({"role": "user", "content": user_input})
+
+        # Prepare payload for Deepseek model
+        payload = {
+            "inputs": {
+                "question": user_input,
+                "context": "",  # Add context if needed
+            }
+        }
 
-    # 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."
-
-
-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
-
-    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("Deepseek r1 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()
+        # Query the Deepseek model
+        with st.spinner("Thinking..."):
+            try:
+                response = query_deepseek(payload)
+                bot_response = response.get("answer", "Sorry, I couldn't understand that.")
+            except Exception as e:
+                bot_response = f"An error occurred: {str(e)}"
+
+        # Add bot response to chat history
+        st.session_state.chat_history.append({"role": "bot", "content": bot_response})
+
+# Display chat history
+for message in st.session_state.chat_history:
+    if message["role"] == "user":
+        st.markdown(f'<div class="chat-message user-message">{message["content"]}</div>', unsafe_allow_html=True)
+    elif message["role"] == "bot":
+        st.markdown(f'<div class="chat-message bot-message">{message["content"]}</div>', unsafe_allow_html=True)
+
+# Clear chat history button
+if st.button("Clear Chat"):
+    st.session_state.chat_history = []
+    st.experimental_rerun()