Update app.py

app.py

@@ -5,61 +5,90 @@ import plotly.express as px
 import folium
 import numpy as np
 import geopandas as gpd
-from branca.element import Element
+from folium.plugins import MarkerCluster, Search
+from sklearn.neighbors import BallTree
+from geopy.geocoders import Nominatim
+from geopy.extra.rate_limiter import RateLimiter
+import math
 import os
-import openrouteservice
-from folium.plugins import MarkerCluster
-from folium.plugins import Search
-
-import matplotlib.pyplot as plt
-import io
-import base64
-import logfire
 
 # Logger setup
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+# ORS client setup (if needed for additional functionalities)
+# ORS_API_KEY = os.getenv('ors')
+# if not ORS_API_KEY:
+#     raise ValueError("OpenRouteService API key not found. Please set the 'ors' environment variable.")
+# client = openrouteservice.Client(key=ORS_API_KEY)
 
-logfire.configure()  
-# ORS client setup
-ORS_API_KEY = os.getenv('ors')
-if not ORS_API_KEY:
-    raise ValueError("OpenRouteService API key not found. Please set the 'ors' environment variable.")
-
-client = openrouteservice.Client(key=ORS_API_KEY)
-
-# Function to create isochrones around Autozone locations
-def create_isochrone_map():
-    m = folium.Map(location=[35.8601, -86.6602], zoom_start=7)
-    autozone_df = df_md_final1[df_md_final1['business_type'] == 'Autozone']
-    
-    for idx, row in autozone_df.iterrows():
-        coords = (row['md_x'], row['md_y'])
-        try:
-            isochrone = client.isochrones(locations=[coords], profile='driving-car', range=[1800])
-            folium.GeoJson(isochrone, name='Isochrones').add_to(m)
-        except openrouteservice.exceptions.HTTPError as e:
-            print(f"HTTPError: {e}")
-            continue
-        except Exception as e:
-            print(f"An error occurred: {e}")
-            continue
-    
-    folium.LayerControl().add_to(m)
-    return m._repr_html_()
+# Load datasets
+df_md_final1 = pd.read_csv("data/location-of-auto-businesses.csv")
+cbg_geographic_data = pd.read_csv("data/cbg_geographic_data.csv")
 
-# Data for 2020 Tennessee population by county
+# Create DataFrames for the 2020 and 2010 populations
 population_2020_data = {
     'County': ['Shelby', 'Davidson', 'Knox', 'Hamilton', 'Rutherford', 'Williamson', 'Montgomery', 'Sumner', 'Blount', 'Washington', 
                'Madison', 'Sevier', 'Maury', 'Wilson', 'Bradley'],
     'Population_2020': [929744, 715884, 478971, 366207, 341486, 247726, 220069, 196281, 135280, 133001, 
                         98823, 98380, 100974, 147737, 108620]
 }
-
-# Create a DataFrame for the top 15 counties
 df_population_2020 = pd.DataFrame(population_2020_data)
 
+df_population_2010 = cbg_geographic_data.groupby('cntyname')['pop10'].sum().reset_index().sort_values(by='pop10', ascending=False)
+df_population_2010.rename(columns={'cntyname': 'County', 'pop10': 'Population_2010'}, inplace=True)
+
+# Merge the 2010 and 2020 population data for side-by-side comparison
+df_population_comparison = pd.merge(df_population_2010, df_population_2020, on='County')
+
+# Define Business Types
+df_md_final1['business_type'] = np.where(df_md_final1['name'].str.contains("Autozone", case=False, na=False), "Autozone", 
+                        np.where(df_md_final1['name'].str.contains("Napa Auto Parts", case=False, na=False), "Napa Auto", 
+                            np.where(df_md_final1['name'].str.contains("Firestone Complete Auto Care", case=False, na=False), "Firestone",                                 
+                                 np.where(df_md_final1['name'].str.contains("O'Reilly Auto Parts", case=False, na=False), "O'Reilly Auto",
+                                      np.where(df_md_final1['name'].str.contains("Advance Auto Parts", case=False, na=False), "Advance Auto",
+                                           np.where(df_md_final1['name'].str.contains("Toyota|Honda|Kia|Nissan|Chevy|Ford|Carmax|GMC", case=False, na=False), 
+                                                    "Car Dealership", 
+                                                    "Other Auto Repair Shops")
+                                              )
+                                     )
+                            )
+                        ))
+
+# Load the County shapefile
+county_shapefile_path = "data/county/01_county-shape-file.shp"
+if not os.path.exists(county_shapefile_path):
+    raise FileNotFoundError(f"County shapefile not found at {county_shapefile_path}. Please ensure the file exists.")
+    
+counties_geo = gpd.read_file(county_shapefile_path)
+counties_geo = counties_geo[counties_geo['statefp'] == '47']  # Tennessee FIPS code
+
+# Load the HSA shapefile
+hsa_shapefile_path = "data/hsa/01_hsa-shape-file.shp"
+if not os.path.exists(hsa_shapefile_path):
+    raise FileNotFoundError(f"HSA shapefile not found at {hsa_shapefile_path}. Please ensure the file exists.")
+    
+hsa_geo = gpd.read_file(hsa_shapefile_path)
+if 'hsastate' in hsa_geo.columns:
+    hsa_geo = hsa_geo[hsa_geo['hsastate'].isin(['TN'])]
+elif 'STATEFP' in hsa_geo.columns:
+    hsa_geo = hsa_geo[hsa_geo['STATEFP'].isin(['47'])]
+else:
+    raise KeyError("Column to filter state in HSA shapefile not found.")
+
+# Load the HRR shapefile
+hrr_shapefile_path = "data/hrr/01_hrr-shape-file.shp"
+if not os.path.exists(hrr_shapefile_path):
+    raise FileNotFoundError(f"HRR shapefile not found at {hrr_shapefile_path}. Please ensure the file exists.")
+    
+hrr_geo = gpd.read_file(hrr_shapefile_path)
+if 'hrrstate' in hrr_geo.columns:
+    hrr_geo = hrr_geo[hrr_geo['hrrstate'].isin(['TN'])]
+elif 'STATEFP' in hrr_geo.columns:
+    hrr_geo = hrr_geo[hrr_geo['STATEFP'].isin(['47'])]
+else:
+    raise KeyError("Column to filter state in HRR shapefile not found.")
+
 # Function to create a Folium map with selected geographical boundaries and markers
 def create_map(geo_layer="Counties", business_filters=["All"]):
     logger.info(f"Creating map with geo_layer: {geo_layer} and business_filters: {business_filters}")
@@ -70,8 +99,6 @@ def create_map(geo_layer="Counties", business_filters=["All"]):
         # Select the appropriate GeoDataFrame based on geo_layer
         if geo_layer == "Counties":
             geo_data = counties_geo
-        elif geo_layer == "Zip Codes":
-            geo_data = zcta_geo
         elif geo_layer == "HSAs":
             geo_data = hsa_geo
         elif geo_layer == "HRRs":
@@ -100,7 +127,8 @@ def create_map(geo_layer="Counties", business_filters=["All"]):
     for _, row in filtered_df.iterrows():
         folium.Marker(
             location=[row['md_y'], row['md_x']],
-            popup=f"<b>{row['name']}</b>"
+            popup=f"<b>{row['name']}</b><br>{row['address']}, {row['city']}, TN {row['postal_code']}",
+            icon=folium.Icon(color='blue', icon='info-sign')
         ).add_to(marker_cluster)
     
     folium.LayerControl().add_to(m)
@@ -108,56 +136,23 @@ def create_map(geo_layer="Counties", business_filters=["All"]):
     logger.info("Map creation completed.")
     return m._repr_html_()
 
-
 # Function to create the bar plot for 2020 Tennessee population (top 15 counties)
 def plot_2020_population_top15():
     fig = px.bar(df_population_2020, 
                  x='County', 
                  y='Population_2020', 
                  title='Tennessee Population 2020', 
-                 labels={'County': 'County', 'Population_2020': ''},
+                 labels={'County': 'County', 'Population_2020': 'Population'},
                  color='Population_2020',
                  color_continuous_scale='Blues')
     
     fig.update_layout(xaxis={'categoryorder':'total descending'}, template='plotly_white')
     return fig
 
-# Function to create the population distribution plot
-def plot_population_distribution():
-    print(cbg_geographic_data.head())
-    county_data = cbg_geographic_data.groupby('cntyname')['pop10'].sum().reset_index().sort_values(by='pop10', ascending=False)
-    
-    fig = px.bar(county_data.head(15), 
-                 x="cntyname", 
-                 y="pop10", 
-                 title="2010 Population by County", 
-                 labels={"cntyname": "County", "pop10": "2010 Population"},
-                 color='pop10',
-                 color_continuous_scale='Viridis')
-    fig.update_layout(xaxis={'categoryorder':'total descending'}, template='plotly_white')
-    return fig
-
-# Load datasets
-df_md_final1 = pd.read_csv("data/location-of-auto-businesses.csv")
-print(df_md_final1.columns)
-print(df_md_final1.info)
-cbg_geographic_data = pd.read_csv("data/cbg_geographic_data.csv")
-print(cbg_geographic_data.columns)
-print(cbg_geographic_data.info)
-
-# Create DataFrames for the 2020 and 2010 populations
-df_population_2010 = cbg_geographic_data.groupby('cntyname')['pop10'].sum().reset_index().sort_values(by='pop10', ascending=False)
-df_population_2010.rename(columns={'cntyname': 'County', 'pop10': 'Population_2010'}, inplace=True)
-
-
-# Merge the 2010 and 2020 population data for side-by-side comparison
-df_population_comparison = pd.merge(df_population_2010, df_population_2020, on='County')
-
 # Function to create a side-by-side bar chart for the 2010 and 2020 Tennessee population by county
 def plot_population_comparison():
     df_melted = df_population_comparison.melt(id_vars='County', value_vars=['Population_2010', 'Population_2020'],
                                               var_name='Year', value_name='Population')
-    print(df_melted)
     fig = px.bar(df_melted, 
                  x='County', 
                  y='Population', 
@@ -170,155 +165,61 @@ def plot_population_comparison():
     fig.update_layout(xaxis={'categoryorder': 'total descending'}, template='plotly_white')
     return fig
 
+# Nearest Neighbor Search Setup
+# Prepare the data for nearest neighbor search
+def prepare_nearest_neighbor():
+    # Convert coordinates to radians for BallTree
+    coords = df_md_final1[['md_y', 'md_x']].to_numpy()
+    radians_coords = np.radians(coords)
+    tree = BallTree(radians_coords, metric='haversine')
+    return tree, radians_coords
+
+tree, radians_coords = prepare_nearest_neighbor()
+
+# Geocoder setup
+geolocator = Nominatim(user_agent="tn_auto_shops_app")
+geocode = RateLimiter(geolocator.geocode, min_delay_seconds=1)
+
+# Function to find the nearest shop
+def find_nearest_shop(address=None, latitude=None, longitude=None):
+    if address:
+        location = geocode(address)
+        if not location:
+            return "Address not found. Please try a different address.", None
+        latitude, longitude = location.latitude, location.longitude
+    elif latitude is not None and longitude is not None:
+        pass  # Coordinates are provided directly
+    else:
+        return "Please provide an address or select a location on the map.", None
 
-# Load the County shapefile
-county_shapefile_path = "data/county/01_county-shape-file.shp"
-if not os.path.exists(county_shapefile_path):
-    raise FileNotFoundError(f"County shapefile not found at {county_shapefile_path}. Please ensure the file exists.")
-    
-counties_geo = gpd.read_file(county_shapefile_path)
-
-print("County Shapefile Columns:", counties_geo.info())  # Debugging line
-print("County Shapefile Columns:", counties_geo.head())  # Debugging line
-
-counties_geo = counties_geo[counties_geo['statefp'] == '47']  # Ensure correct column name for state FIPS
-
-
-
-# Define FIPS codes and abbreviations for TN, KY, IN, and AR
-state_fips = ['47']  # TN, KY, IN, AR FIPS codes
-state_abbr = ['TN']
-
-# Load the HSA shapefile
-hsa_shapefile_path = "data/hsa/01_hsa-shape-file.shp"
-if not os.path.exists(hsa_shapefile_path):
-    raise FileNotFoundError(f"HSA shapefile not found at {hsa_shapefile_path}. Please ensure the file exists.")
-    
-
-hsa_geo = gpd.read_file(hsa_shapefile_path)
-# Update the column name based on your shapefile
-if 'hsastate' in hsa_geo.columns:
-    hsa_geo = hsa_geo[hsa_geo['hsastate'].isin(state_abbr)]
-elif 'STATEFP' in hsa_geo.columns:
-    hsa_geo = hsa_geo[hsa_geo['STATEFP'].isin(state_fips)]
-else:
-    raise KeyError("Column to filter state in HSA shapefile not found.")
-
-# Load the HRR shapefile
-hrr_shapefile_path = "data/hrr/01_hrr-shape-file.shp"
-if not os.path.exists(hrr_shapefile_path):
-    raise FileNotFoundError(f"HRR shapefile not found at {hrr_shapefile_path}. Please ensure the file exists.")
-    
-hrr_geo = gpd.read_file(hrr_shapefile_path)
-# Update the column name based on your shapefile
-if 'hrrstate' in hrr_geo.columns:
-    hrr_geo = hrr_geo[hrr_geo['hrrstate'].isin(state_abbr)]
-elif 'STATEFP' in hrr_geo.columns:
-    hrr_geo = hrr_geo[hrr_geo['STATEFP'].isin(state_fips)]
-else:
-    raise KeyError("Column to filter state in HRR shapefile not found.")
-
+    # Convert to radians
+    point = np.radians([latitude, longitude]).reshape(1, -1)
+    dist, idx = tree.query(point, k=1)
+    nearest_idx = idx[0][0]
+    nearest_shop = df_md_final1.iloc[nearest_idx]
+    distance_km = dist[0][0] * 6371  # Earth's radius in kilometers
 
-# Define Business 
-df_md_final1['business_type'] = np.where(df_md_final1['name'].str.contains("Autozone", case=False, na=False), "Autozone", 
-                        np.where(df_md_final1['name'].str.contains("Napa Auto Parts", case=False, na=False), "Napa Auto", 
-                            np.where(df_md_final1['name'].str.contains("Firestone Complete Auto Care", case=False, na=False), "Firestone",                                 
-                                 np.where(df_md_final1['name'].str.contains("O'Reilly Auto Parts", case=False, na=False), "O'Reilly Auto",
-                                          np.where(df_md_final1['name'].str.contains("Advance Auto Parts", case=False, na=False), "Advance Auto",
-                                                   np.where(df_md_final1['name'].str.contains("Toyota|Honda|Kia|Nissan|Chevy|Ford|Carmax|GMC", case=False, na=False), 
-                                                            "Car Dealership", 
-                                                            "Other Auto Repair Shops")
-                                                  )
-                                         )
-                                )
-                                        ))
+    # Create a Folium map showing the user location and the nearest shop
+    m = folium.Map(location=[latitude, longitude], zoom_start=12)
 
-# Prepare data for modeling
-def prepare_model_data():
-    # Aggregate number of businesses per county
-    business_counts = df_md_final1.groupby('county').size().reset_index(name='business_count')
-    
-    # Merge with population data
-    df_model = pd.merge(df_population_2020, business_counts, left_on='County', right_on='county', how='left')
-    df_model['business_count'] = df_model['business_count'].fillna(0)
-    
-    # Drop redundant columns
-    df_model = df_model.drop(columns=['county'])  # Assuming 'county' is the same as 'County'
-    
-    # Additional feature engineering can be done here
-    
-    return df_model
+    # Add user location marker
+    folium.Marker(
+        location=[latitude, longitude],
+        popup="Your Location",
+        icon=folium.Icon(color='red', icon='user')
+    ).add_to(m)
 
-# Train Random Forest model
-def train_random_forest():
-    df_model = prepare_model_data()
-    
-    # Features and target
-    X = df_model[['Population_2020']]
-    y = df_model['business_count']
-    
-    # Handle any missing values or additional preprocessing if necessary
-    # For this example, we assume data is clean
-    
-    # Split the data
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-    
-    # Initialize and train the model
-    rf = RandomForestRegressor(n_estimators=100, random_state=42)
-    rf.fit(X_train, y_train)
-    
-    # Predictions
-    y_pred = rf.predict(X_test)
-    
-    # Metrics
-    mse = mean_squared_error(y_test, y_pred)
-    r2 = r2_score(y_test, y_pred)
-    
-    # SHAP explanation
-    explainer = shap.Explainer(rf, X_train)
-    shap_values = explainer(X_test)
-    
-    # Feature importance
-    feature_importances = pd.DataFrame({
-        'feature': X.columns,
-        'importance': rf.feature_importances_
-    }).sort_values(by='importance', ascending=False)
-    
-    return {
-        'model': rf,
-        'X_test': X_test,
-        'y_test': y_test,
-        'y_pred': y_pred,
-        'mse': mse,
-        'r2': r2,
-        'shap_values': shap_values,
-        'feature_importances': feature_importances
-    }
+    # Add nearest shop marker
+    folium.Marker(
+        location=[nearest_shop['md_y'], nearest_shop['md_x']],
+        popup=f"Nearest Shop: {nearest_shop['name']}<br>{nearest_shop['address']}, {nearest_shop['city']}, TN {nearest_shop['postal_code']}<br>Distance: {distance_km:.2f} km",
+        icon=folium.Icon(color='green', icon='shopping-cart')
+    ).add_to(m)
 
-# Function to generate SHAP summary plot as a base64 string
-def get_shap_summary_plot(shap_values, X):
-    plt.figure()
-    shap.summary_plot(shap_values, X, show=False)
-    buf = io.BytesIO()
-    plt.savefig(buf, format="png", bbox_inches='tight')
-    plt.close()
-    buf.seek(0)
-    img_base64 = base64.b64encode(buf.read()).decode('utf-8')
-    return f"data:image/png;base64,{img_base64}"
+    # Draw a line between the user location and the nearest shop
+    folium.PolyLine(locations=[[latitude, longitude], [nearest_shop['md_y'], nearest_shop['md_x']]], color='blue').add_to(m)
 
-# Function to generate Feature Importance plot as a base64 string
-def get_feature_importance_plot(feature_importances):
-    fig = px.bar(feature_importances, 
-                 x='feature', 
-                 y='importance', 
-                 title='Feature Importance from Random Forest',
-                 labels={'feature': 'Feature', 'importance': 'Importance'},
-                 color='importance',
-                 color_continuous_scale='Blues')
-    fig.update_layout(template='plotly_white')
-    img_bytes = fig.to_image(format="png")
-    img_base64 = base64.b64encode(img_bytes).decode('utf-8')
-    return f"data:image/png;base64,{img_base64}"
+    return "", m._repr_html_()
 
 # Gradio Interface
 with gr.Blocks(theme=gr.themes.Default()) as app:
@@ -332,47 +233,21 @@ with gr.Blocks(theme=gr.themes.Default()) as app:
                 gr.Markdown("### 2020 Population by County")
                 pop_dist = gr.Plot(plot_2020_population_top15)
             
+            with gr.Column():
+                gr.Markdown("### 2010 vs 2020 Population Comparison")
+                pop_comp = gr.Plot(plot_population_comparison)
+        
         gr.Markdown("### 🛠️ Auto Businesses in Tennessee")
         manual_table = gr.Dataframe(
-            headers=["Location Name", "Street Address", "City", "State", "Postal Code"],
+            headers=["Name", "Address", "City", "State", "Postal Code"],
             datatype=["str", "str", "str", "str", "str"],
-            value=[
-                ["AutoZone", "257 Wears Valley Rd", "Pigeon Forge", "Tennessee", "37863"],
-                ["Sterling Auto", "2064 Wilma Rudolph Blvd", "Clarksville", "Tennessee", "37040"],
-                ["AutoZone", "257 Wears Valley Rd", "Pigeon Forge", "Tennessee", "37863"],
-                ["Sterling Auto", "2064 Wilma Rudolph Blvd", "Clarksville", "Tennessee", "37040"],
-                ["Advance Auto Parts", "2124 N Highland Ave", "Jackson", "Tennessee", "38305"],
-                ["FRIENDSHIP HYUNDAI OF BRISTOL", "1841 Volunteer Pkwy", "Bristol", "Tennessee", "37620"],
-                ["Advance Auto Parts", "45 Main St", "Savannah", "Tennessee", "38372"],
-                ["O'Reilly Auto Parts", "493 Craighead St", "Nashville", "Tennessee", "37204"],
-                ["O'Reilly Auto Parts", "864 Highway 51 N", "Covington", "Tennessee", "38019"],
-                ["NAPA Auto Parts", "711 Murfreesboro Pike", "Nashville", "Tennessee", "37210"],
-                ["Goodyear Auto Service Centers", "5407 Highway 153", "Hixson", "Tennessee", "37343"],
-                ["NAPA Auto Parts", "100 Center St", "Johnson City", "Tennessee", "37615"],
-                ["Cadillac,Buick,Chevrolet,GMC", "960 John R Rice Blvd", "Murfreesboro", "Tennessee", "37129"],
-                ["AutoZone", "9760 Highway 64", "Lakeland", "Tennessee", "38002"],
-                ["Honda", "1408 Highway 45 Byp", "Jackson", "Tennessee", "38305"],
-                ["National Tire & Battery (NTB)", "532 Robert Rose Dr", "Murfreesboro", "Tennessee", "37129"],
-                ["NAPA Auto Parts", "711 Murfreesboro Pike", "Nashville", "Tennessee", "37210"],
-                ["Advance Auto Parts", "160 W Broadway", "Gallatin", "Tennessee", "37066"],
-                ["Southern Tire Mart (STM)", "1551 S Wilcox Dr", "Kingsport", "Tennessee", "37660"],
-                ["Chevrolet", "310 E 20th St", "Chattanooga", "Tennessee", "37408"],
-                ["O'Reilly Auto Parts", "7534 Oak Ridge Hwy", "Knoxville", "Tennessee", "37931"],
-                ["Goodyear Auto Service Centers", "971 Eastgate Loop", "Chattanooga", "Tennessee", "37411"],
-                ["Firestone Complete Auto Care", "15127 Old Hickory Blvd", "Nashville", "Tennessee", "37211"],
-                ["Christian Brothers Automotive", "10406 Kingston Pike", "Knoxville", "Tennessee", "37922"],
-                ["Christian Brothers Automotive", "563 E Main St", "Hendersonville", "Tennessee", "37075"],
-                ["O'Reilly Auto Parts", "101 Village Square Ln", "Mountain City", "Tennessee", "37683"],
-                ["O'Reilly Auto Parts", "4219 Fort Henry Dr Ste A", "Kingsport", "Tennessee", "37663"],
-                ["Precision Tune Auto Care", "4710 N Broadway St", "Knoxville", "Tennessee", "37918"],
-                ["National Tire & Battery (NTB)", "234 Old Hickory Blvd", "Nashville", "Tennessee", "37221"]
-            ],  # Data values
-            row_count=27,  # Adjusted total number of rows
+            value=df_md_final1[['name', 'address', 'city', 'state', 'postal_code']].head(10).values.tolist(),  # Display first 10 for brevity
+            row_count=10,
             interactive=False
         )
     
         gr.Markdown("### 📍 Interactive Map")
-        map_output_overview = gr.HTML(lambda: create_map(geo_layer="Counties", business_filters=["All"]))
+        map_output_overview = gr.HTML(create_map(geo_layer="Counties", business_filters=["All"]))
     
     with gr.Tab("📍 Shops in TN Counties"):
         with gr.Row():
@@ -411,7 +286,7 @@ with gr.Blocks(theme=gr.themes.Default()) as app:
         business_filter_hsa.change(fn=update_hsa_map, inputs=[business_filter_hsa], outputs=[shops_hsa_map])
         reset_button_hsa.click(fn=lambda: (["All"], create_map(geo_layer="HSAs", business_filters=["All"])),
                                inputs=None, outputs=[business_filter_hsa, shops_hsa_map])
-        
+    
     with gr.Tab("📍 Shops in TN HRRs"):
         with gr.Row():
             with gr.Column(scale=1):
@@ -431,20 +306,70 @@ with gr.Blocks(theme=gr.themes.Default()) as app:
         reset_button_hrr.click(fn=lambda: (["All"], create_map(geo_layer="HRRs", business_filters=["All"])),
                                inputs=None, outputs=[business_filter_hrr, shops_hrr_map])
     
+    with gr.Tab("🔍 Nearest Shop Finder"):
+        gr.Markdown("## Find the Nearest Auto Shop in Tennessee")
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### Input Your Location")
+                address_input = gr.Textbox(label="Enter Address", placeholder="e.g., 123 Main St, Nashville, TN")
+                gr.Markdown("**OR**")
+                location_input = gr.Button("Click on Map to Select Location")
+            with gr.Column(scale=4):
+                nearest_map = gr.HTML()
+        
+        # Hidden inputs to capture latitude and longitude from map clicks
+        lat_input = gr.Number(label="Latitude", visible=False)
+        lon_input = gr.Number(label="Longitude", visible=False)
+        
+        # Function to handle map clicks and update latitude and longitude
+        def map_click_event(location):
+            latitude, longitude = location
+            return latitude, longitude
+        
+        # Initialize the map for nearest shop finder
+        def initialize_nearest_map():
+            m = folium.Map(location=[35.8601, -86.6602], zoom_start=7)
+            folium.TileLayer('cartodbpositron').add_to(m)
+            folium.Marker(
+                location=[35.8601, -86.6602],
+                popup="Click on the map to select your location",
+                icon=folium.Icon(color='red', icon='info-sign')
+            ).add_to(m)
+            m.add_child(folium.LatLngPopup())
+            return m._repr_html_()
+        
+        nearest_map.initial_value = initialize_nearest_map()
+        
+        # Function to update the map based on user input
+        def update_nearest_map(address, latitude, longitude):
+            message, updated_map = find_nearest_shop(address, latitude, longitude)
+            return updated_map
+        
+        # When the user submits an address
+        address_input.submit(fn=update_nearest_map, inputs=[address_input, lat_input, lon_input], outputs=[nearest_map])
+        
+        # Note: Capturing map clicks directly in Gradio is non-trivial. As an alternative, users can enter their address.
+        # For more advanced interactivity, a custom frontend might be required.
+    
     with gr.Tab("🔍 Help"):
         gr.Markdown("""
         ## How to Use This Dashboard
         
         - **Overview Tab:** Provides population statistics and a summary map of all auto businesses in Tennessee.
         
-        - **Shops in TN Counties/Zip Codes/HSAs/HRRs Tabs:**
-            - **Filter by Business Type:** Use the checkboxes to select one or multiple Business  to display on the map.
-            - **Filter by Geographical Area:** Depending on the tab, you can filter businesses based on Counties, Zip Codes, HSAs, or HRRs.
+        - **Shops in TN Counties/HSAs/HRRs Tabs:**
+            - **Filter by Business Type:** Use the checkboxes to select one or multiple business types to display on the map.
+            - **Filter by Geographical Area:** Depending on the tab, you can filter businesses based on Counties, HSAs, or HRRs.
             - **Reset Filters:** Click the reset button to clear all selected filters and view all businesses.
             - **Interactive Map:** Zoom in/out, click on markers to view business details, and use the search bar to find specific businesses.
-    
+        
+        - **Nearest Shop Finder Tab:**
+            - **Enter Address:** Type your address in the textbox and press Enter to find the nearest auto shop.
+            - **Select Location on Map:** (Feature under development) Click on the map to select your location and find the nearest shop.
+            - **View Results:** The map will display your location and the nearest auto shop with a line connecting them.
+        
         """)
     
     gr.Markdown("### 📄 Source: Yellow Pages")
-
+    
 app.launch(server_name="0.0.0.0", server_port=7860, share=True)