Update app.py

app.py

@@ -1,292 +1,3 @@
-# '''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 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)
-
-
-# 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_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
-#     }
-
-
-#     # Construct the payload
-#     payload = {
-#         "inputs": {
-#             "query": question,
-#             "table": table_data,
-#         }
-#     }
-
-#     # 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("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
-
-# # 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
-# # )
-
-# # # 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
-# #             )
-            
-# #             # 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)
-        
-# #         except Exception as e:
-# #             st.error(f"An error occurred: {e}")
-
-
 '''Copyright 2024 Ashok Kumar
 
 Licensed under the Apache License, Version 2.0 (the "License");
@@ -305,10 +16,8 @@ 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
@@ -383,35 +92,79 @@ def fetch_flight_data(lat_min, lat_max, lon_min, lon_max):
         st.error(f"Unexpected error: {str(e)}")
         return {'states': [], 'time': 0}
 
-
-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)
-
 # Hugging Face model configuration
-HF_API_URL = "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.2"
-headers = {"Authorization": f"Bearer {hf_token}"}
+HF_API_URL = "https://api-inference.huggingface.co/models/google/flan-t5-large"
+HF_TOKEN = os.getenv("HF_TOKEN")
+headers = {"Authorization": f"Bearer {HF_TOKEN}"}
 
 def query_llm(prompt):
     try:
         payload = {
             "inputs": prompt,
             "parameters": {
-                "max_new_tokens": 250,
+                "max_length": 250,
                 "temperature": 0.1,
                 "top_p": 0.95,
-                "return_full_text": False
+                "do_sample": False
             }
         }
         
         response = requests.post(HF_API_URL, headers=headers, json=payload)
         response.raise_for_status()
         return response.json()[0]['generated_text']
+    except requests.exceptions.HTTPError as e:
+        if e.response.status_code == 403:
+            st.warning("Language model access is currently restricted. Using direct flight data display instead.")
+        else:
+            st.error(f"Error querying language model: {str(e)}")
+        return None
     except Exception as e:
         st.error(f"Error querying language model: {str(e)}")
         return None
 
+def create_flight_embeddings(geo_df):
+    """Create embeddings for flight data to enable semantic search"""
+    try:
+        from sentence_transformers import SentenceTransformer
+        model = SentenceTransformer('all-MiniLM-L6-v2')
+        
+        # Create text representations of flight data
+        flight_texts = []
+        for _, row in geo_df.iterrows():
+            text = f"Flight {row['callsign']} from {row['origin_country']} "
+            text += f"at altitude {row['baro_altitude']}m, speed {row['velocity']}m/s, "
+            text += f"heading {row['true_track']}°"
+            flight_texts.append(text)
+        
+        # Generate embeddings
+        embeddings = model.encode(flight_texts)
+        return embeddings, flight_texts
+    except Exception as e:
+        st.warning(f"Could not create embeddings: {str(e)}")
+        return None, None
+
+def find_similar_flights(identifier, geo_df, embeddings, flight_texts, threshold=0.7):
+    """Find similar flights using semantic search"""
+    try:
+        from sentence_transformers import SentenceTransformer
+        model = SentenceTransformer('all-MiniLM-L6-v2')
+        
+        # Create query embedding
+        query_embedding = model.encode([identifier])
+        
+        # Calculate similarities
+        from sklearn.metrics.pairwise import cosine_similarity
+        similarities = cosine_similarity(query_embedding, embeddings)[0]
+        
+        # Find similar flights
+        similar_indices = [i for i, sim in enumerate(similarities) if sim > threshold]
+        if similar_indices:
+            return geo_df.iloc[similar_indices]
+        return None
+    except Exception as e:
+        st.warning(f"Error in semantic search: {str(e)}")
+        return None
+
 def query_flight_data(geo_df, question):
     # Preprocess the question to extract key information
     question = question.lower().strip()
@@ -443,17 +196,61 @@ def query_flight_data(geo_df, question):
     if not identifier:
         return "Please specify a flight identifier (callsign or ICAO code) in your question."
     
-    # Try to find the flight by callsign or icao
+    # Clean and normalize the identifier
+    identifier = identifier.strip().upper()
+    
+    # Try to find the flight by callsign or icao (case-insensitive)
     flight_data = None
-    if identifier in geo_df['callsign'].values:
-        flight_data = geo_df[geo_df['callsign'] == identifier]
-    elif identifier in geo_df['icao24'].values:
-        flight_data = geo_df[geo_df['icao24'] == identifier]
     
+    # First try exact match
+    if identifier in geo_df['callsign'].str.upper().values:
+        flight_data = geo_df[geo_df['callsign'].str.upper() == identifier]
+    elif identifier in geo_df['icao24'].str.upper().values:
+        flight_data = geo_df[geo_df['icao24'].str.upper() == identifier]
+    
+    # If no exact match, try partial match
     if flight_data is None or flight_data.empty:
-        return f"Could not find flight information for {identifier}. Please check the flight identifier and try again."
+        # Try matching without spaces or special characters
+        clean_identifier = ''.join(filter(str.isalnum, identifier))
+        if not geo_df['callsign'].empty:
+            clean_callsigns = geo_df['callsign'].fillna('').apply(lambda x: ''.join(filter(str.isalnum, str(x).upper())))
+            matches = clean_callsigns == clean_identifier
+            if matches.any():
+                flight_data = geo_df[matches]
     
-    # Prepare flight data for the LLM
+    # If still no match, try fuzzy matching
+    if flight_data is None or flight_data.empty:
+        try:
+            from difflib import get_close_matches
+            all_callsigns = geo_df['callsign'].fillna('').str.upper().unique()
+            close_matches = get_close_matches(identifier, all_callsigns, n=1, cutoff=0.8)
+            if close_matches:
+                flight_data = geo_df[geo_df['callsign'].str.upper() == close_matches[0]]
+        except:
+            pass
+    
+    # If still no match, try semantic search using RAG
+    if flight_data is None or flight_data.empty:
+        try:
+            # Create embeddings for all flights
+            embeddings, flight_texts = create_flight_embeddings(geo_df)
+            if embeddings is not None:
+                # Try to find similar flights
+                similar_flights = find_similar_flights(identifier, geo_df, embeddings, flight_texts)
+                if similar_flights is not None and not similar_flights.empty:
+                    flight_data = similar_flights
+                    st.info(f"Found similar flight(s) to {identifier}")
+        except Exception as e:
+            st.warning(f"Semantic search failed: {str(e)}")
+    
+    if flight_data is None or flight_data.empty:
+        # If still no match, show available flights
+        available_flights = geo_df['callsign'].dropna().unique()
+        if len(available_flights) > 0:
+            return f"Could not find flight {identifier}. Available flights: {', '.join(available_flights[:10])}..."
+        return f"Could not find flight {identifier}. No flights currently available in the selected area."
+    
+    # Prepare flight data for display
     flight_info = {}
     for col in flight_data.columns:
         if col in flight_data.columns:
@@ -471,33 +268,75 @@ def query_flight_data(geo_df, question):
                     flight_info[col] = f"{value}° N"
                 elif col == 'longitude':
                     flight_info[col] = f"{value}° E"
-                else:
+    else:
                     flight_info[col] = str(value)
     
     if not flight_info:
         return f"No information available for flight {identifier}."
     
-    # Create a prompt for the LLM
-    prompt = f"""You are a flight information assistant. Answer the following question about flight {identifier} using the provided flight data.
-
-Question: {question}
+    # Try to get LLM response, but fall back to direct display if it fails
+    try:
+        # Create a prompt for the LLM
+        prompt = f"""Answer this question about flight {identifier}: {question}
 
-Flight Data:
+Available flight data:
 {json.dumps(flight_info, indent=2)}
 
-Please provide a clear and concise answer focusing on the specific information requested in the question. If the question asks for information not available in the data, say so clearly."""
+Provide a clear and concise answer focusing on the specific information requested."""
+        
+        llm_response = query_llm(prompt)
+        if llm_response:
+            return llm_response
+    except:
+        pass
+    
+    # Fallback to direct data display
+    response = f"Flight Information for {identifier}:\n"
+    for key, value in flight_info.items():
+        response += f"- {key.replace('_', ' ').title()}: {value}\n"
+    return response
 
-    # Get response from LLM
-    llm_response = query_llm(prompt)
+@st.cache_data(ttl=60)  # Cache for 1 minute
+def get_traffic_gdf(lat_min, lat_max, lon_min, lon_max, local_time_zone, loc, flight_info):
+    # Get cached flight data
+    json_dict = fetch_flight_data(lat_min, lat_max, lon_min, lon_max)
     
-    if llm_response:
-        return llm_response
-    else:
-        # Fallback to direct data response if LLM fails
-        response = f"Flight Information for {identifier}:\n"
-        for key, value in flight_info.items():
-            response += f"- {key.replace('_', ' ').title()}: {value}\n"
-        return response
+    if not json_dict or not json_dict.get('states'):
+        st.warning("No flight data available for the selected area.")
+        return None
+
+    try:
+        unix_timestamp = int(json_dict["time"])
+        local_timezone = pytz.timezone(local_time_zone)
+        local_time = datetime.fromtimestamp(unix_timestamp, local_timezone).strftime('%Y-%m-%d %H:%M:%S')
+        
+        # Optimize DataFrame creation
+        state_df = pd.DataFrame(json_dict["states"], columns=columns)
+        state_df['time'] = local_time
+        
+        # Create GeoDataFrame more efficiently
+        gdf = gpd.GeoDataFrame(
+            state_df,
+            geometry=gpd.points_from_xy(state_df.longitude, state_df.latitude),
+            crs="EPSG:4326"
+        )
+        
+        # Display information
+        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
+        
+    except Exception as e:
+        st.error(f"Error processing flight data: {str(e)}")
+        return None
 
 def flight_tracking(flight_view_level, country, local_time_zone, flight_info, airport, color):
     # Get cached location data
@@ -526,51 +365,10 @@ def flight_tracking(flight_view_level, country, local_time_zone, flight_info, ai
                                             (airport_country_loc['Latitude'] >= lat_min) &
                                             (airport_country_loc['Latitude'] <= lat_max) & 
                                             (airport_country_loc['Longitude'] >= lon_min) &
-                                            (airport_country_loc['Longitude'] <= lon_max)]
+                            (airport_country_loc['Longitude'] <= lon_max)]
     
-    def get_traffic_gdf():
-        # Get cached flight data
-        json_dict = fetch_flight_data(lat_min, lat_max, lon_min, lon_max)
-        
-        if not json_dict or not json_dict.get('states'):
-            st.warning("No flight data available for the selected area.")
-            return None
-
-        try:
-            unix_timestamp = int(json_dict["time"])
-            local_timezone = pytz.timezone(local_time_zone)
-            local_time = datetime.fromtimestamp(unix_timestamp, local_timezone).strftime('%Y-%m-%d %H:%M:%S')
-            
-            # Optimize DataFrame creation
-            state_df = pd.DataFrame(json_dict["states"], columns=columns)
-            state_df['time'] = local_time
-            
-            # Create GeoDataFrame more efficiently
-            gdf = gpd.GeoDataFrame(
-                state_df,
-                geometry=gpd.points_from_xy(state_df.longitude, state_df.latitude),
-                crs="EPSG:4326"
-            )
-            
-            # Display information
-            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
-            
-        except Exception as e:
-            st.error(f"Error processing flight data: {str(e)}")
-            return None
-
     # Get traffic data
-    geo_df = get_traffic_gdf()
+    geo_df = get_traffic_gdf(lat_min, lat_max, lon_min, lon_max, local_time_zone, loc, flight_info)
     if geo_df is None:
         return