Update app.py

app.py

@@ -5,121 +5,98 @@ from folium.plugins import MarkerCluster
 import requests
 from io import BytesIO
 import streamlit as st
-import folium
-from streamlit.components.v1 import html
-import math
 
-# Load data from Excel (directly from the URL)
+# Load data from Excel
 def load_data(url):
-    # Request the file content
+    # Fetch the file from the URL
     response = requests.get(url)
-    
-    # Check if the content is an Excel file by inspecting the MIME type
-    if 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' not in response.headers['Content-Type']:
-        raise ValueError("The file is not a valid Excel file.")
-    
-    # Read the file content into a pandas dataframe with the engine specified
+    # Read the Excel file from the response content
     lat_long_data = pd.read_excel(BytesIO(response.content), sheet_name="lat long", engine='openpyxl')
     measurement_data = pd.read_excel(BytesIO(response.content), sheet_name="measurement data", engine='openpyxl')
-    
+
     # Merge data on school_id_giga
-    merged_data = pd.merge(
-        lat_long_data,
-        measurement_data,
-        left_on="school_id_giga",
-        right_on="school_id_giga",
-        how="inner"
-    )
-    
-    # Strip whitespace from all column names
-    merged_data.columns = merged_data.columns.str.strip()
-    
+    merged_data = pd.merge(lat_long_data, measurement_data, on="school_id_giga", how="inner")
     return merged_data
 
-# Haversine formula to calculate distance between two lat/long points
-def haversine(lat1, lon1, lat2, lon2):
-    # Convert latitude and longitude from degrees to radians
-    lat1, lon1, lat2, lon2 = map(math.radians, [lat1, lon1, lat2, lon2])
-    
-    # Haversine formula
-    dlat = lat2 - lat1
-    dlon = lon2 - lon1
-    a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2
-    c = 2 * math.asin(math.sqrt(a))
-    
-    # Radius of Earth in kilometers
-    R = 6371
-    return R * c
-
 # Perform clustering to find data center location
 def find_data_center(df, n_clusters=1):
     kmeans = KMeans(n_clusters=n_clusters, random_state=0).fit(df[["latitude", "longitude"]])
     return kmeans.cluster_centers_
 
-# Estimate latency and bandwidth based on distance from the data center (inverse relationship)
-def estimate_latency_bandwidth(df, data_center_lat, data_center_lon):
-    df["distance_to_data_center"] = df.apply(
-        lambda row: haversine(row["latitude"], row["longitude"], data_center_lat, data_center_lon),
-        axis=1
-    )
-    
-    # Latency estimation: Assuming latency decreases inversely with distance (this is just an example scale)
-    df["estimated_latency"] = df["distance_to_data_center"].apply(lambda x: max(10, 100 / (x + 1)))  # Max latency 100ms
-    
-    # Bandwidth estimation: Assuming bandwidth increases inversely with distance (again, an example scale)
-    df["estimated_bandwidth"] = df["distance_to_data_center"].apply(lambda x: max(10, 100 / (x + 1)))  # Max bandwidth 100 Mbps
-    
-    return df
-
 # Create a map and plot the points
 def plot_map(df, center):
-    # Create map centered on the data center location
     map = folium.Map(location=[center[0][0], center[0][1]], zoom_start=10)
     marker_cluster = MarkerCluster().add_to(map)
     
-    # Add school locations to the map
+    # Add school locations
     for idx, row in df.iterrows():
-        school_name = row.get("school_name", "No Name Provided")  # Ensure correct column access
-        
-        # Popup text showing original latency, estimated latency, bandwidth before and after
-        popup_text = (
-            f"School Name: {school_name}<br>"
-            f"Original Latency: {row['latency']} ms<br>"
-            f"Original Bandwidth: {row['download_speed']} Mbps<br>"
-            f"Estimated Latency After Data Center: {row['estimated_latency']} ms<br>"
-            f"Estimated Bandwidth After Data Center: {row['estimated_bandwidth']} Mbps"
-        )
-        
         folium.Marker(
             location=[row["latitude"], row["longitude"]],
-            popup=popup_text,
+            popup=(
+                f"School Name: {row['school_name']}<br>"
+                f"Download Speed: {row['download_speed']} Mbps<br>"
+                f"Upload Speed: {row['upload_speed']} Mbps<br>"
+                f"Latency: {row['latency']} ms"
+            ),
             icon=folium.Icon(color="blue", icon="info-sign")
         ).add_to(marker_cluster)
     
-    # Add data center location to the map
+    # Add data center
     folium.Marker(
         location=[center[0][0], center[0][1]],
         popup="Proposed Data Center",
         icon=folium.Icon(color="red", icon="cloud")
     ).add_to(map)
-
     return map
 
+# Calculate before and after data center metrics
+def calculate_metrics(df, center):
+    # Calculate distances to the data center for each school
+    df['distance_to_center'] = ((df['latitude'] - center[0][0])**2 + (df['longitude'] - center[0][1])**2)**0.5
+    
+    # Assuming that schools closer to the center represent the "after" data center scenario
+    before_data = df[df['distance_to_center'] > df['distance_to_center'].median()]
+    after_data = df[df['distance_to_center'] <= df['distance_to_center'].median()]
+    
+    # Calculate average bandwidth and latency
+    before_bandwidth = before_data[['download_speed', 'upload_speed']].mean()
+    before_latency = before_data['latency'].mean()
+    
+    after_bandwidth = after_data[['download_speed', 'upload_speed']].mean()
+    after_latency = after_data['latency'].mean()
+
+    return before_bandwidth, before_latency, after_bandwidth, after_latency
+
 # Main function to run the application
 def main():
-    url = "https://huggingface.co/spaces/engralimalik/lace/resolve/main/data%20barbados.xlsx"  # Correct raw file URL
+    url = "https://huggingface.co/spaces/engralimalik/lace/resolve/main/data%20barbados.xlsx"
     df = load_data(url)
+    
+    # Find the center for the data center location
     center = find_data_center(df)
-    df = estimate_latency_bandwidth(df, center[0][0], center[0][1])  # Estimate latency and bandwidth based on distance
     
+    # Plot the map
     map = plot_map(df, center)
-
-    # Embed the map directly in the Streamlit app
-    map_html = map._repr_html_()  # Render the folium map as HTML
-    html(map_html, width=700, height=500)  # Adjust the size of the embedded map
-
-    st.title("Impact of Data Center on Latency and Bandwidth")
-    st.write("This map shows school locations and proposed data center locations based on clustering. The latency and bandwidth values represent the potential improvements for schools closer to the data center.")
+    map.save("index.html")
+    
+    # Calculate before and after metrics
+    before_bandwidth, before_latency, after_bandwidth, after_latency = calculate_metrics(df, center)
+    
+    # Display the map in Streamlit
+    st.title("Impact of Data Center Addition")
+    st.markdown("Here’s the map of the schools and the proposed data center location.")
+    st.components.v1.html(open("index.html", "r").read(), height=500)
+    
+    # Display before and after metrics
+    st.subheader("Before Data Center Addition")
+    st.write(f"Average Download Speed: {before_bandwidth['download_speed']} Mbps")
+    st.write(f"Average Upload Speed: {before_bandwidth['upload_speed']} Mbps")
+    st.write(f"Average Latency: {before_latency} ms")
+    
+    st.subheader("After Data Center Addition")
+    st.write(f"Average Download Speed: {after_bandwidth['download_speed']} Mbps")
+    st.write(f"Average Upload Speed: {after_bandwidth['upload_speed']} Mbps")
+    st.write(f"Average Latency: {after_latency} ms")
 
 if __name__ == "__main__":
     main()