Switch to Streamlit with clickable map and heat map overlay

README.md

@@ -3,8 +3,8 @@ title: HappySardines
 emoji: 🐟
 colorFrom: blue
 colorTo: blue
-sdk: gradio
-sdk_version: 4.44.0
+sdk: streamlit
+sdk_version: 1.28.0
 app_file: app.py
 pinned: false
 license: mit
@@ -15,11 +15,18 @@ short_description: Predict bus crowding levels in Östergötland, Sweden
 
 **How packed are buses in Östergötland?**
 
-Drop a pin on the map, pick a time, and find out how crowded buses typically are in that area. Built with ML using historical transit data from Östgötatrafiken.
+Click on the map to select a location, pick a time, and see predicted crowding levels. Toggle the heat map to see crowding patterns across the entire region.
+
+## Features
+
+- 🗺️ **Interactive map** - Click to select any location
+- 🔥 **Heat map overlay** - See predicted crowding across the region
+- 🌡️ **Real-time weather** - Forecasts from Open-Meteo
+- 📅 **Holiday awareness** - Swedish red days and work-free days
 
 ## How it works
 
-This tool predicts typical bus crowding levels based on:
+This tool predicts bus crowding levels based on:
 - **Location** - Different areas have different ridership patterns
 - **Time** - Rush hours vs. off-peak
 - **Day of week** - Weekdays vs. weekends
@@ -28,22 +35,16 @@ This tool predicts typical bus crowding levels based on:
 
 ## Data sources
 
-- Historical bus occupancy data from Östgötatrafiken (GTFS-RT, Nov-Dec 2025)
+- Bus occupancy data from Östgötatrafiken (GTFS-RT)
 - Weather forecasts from [Open-Meteo](https://open-meteo.com/)
 - Swedish holiday calendar from [Svenska Dagar API](https://sholiday.faboul.se/)
 
-## Limitations
-
-- Predictions are based on historical patterns, not real-time data
-- Accuracy varies by location and time
-- The model predicts general area crowding, not specific bus lines
-
 ## Technical details
 
-- **Model**: XGBoost Classifier trained on ~6M trip records
+- **Model**: XGBoost Classifier
 - **Features**: Location, time, weather, holidays
 - **Feature Store**: Hopsworks
-- **Framework**: Gradio
+- **Framework**: Streamlit + Folium
 
 ## Credits
 

app.py

@@ -1,42 +1,35 @@
 """
-HappySardines - Bus Occupancy Predictor UI
+HappySardines - Bus Occupancy Predictor UI (Streamlit version)
 
-A Gradio app that predicts how crowded buses are in Östergötland based on
-location, time, weather, and holidays.
+A Streamlit app with clickable map and heat map overlay for predicting
+bus crowding in Östergötland.
 """
 
 import os
-import gradio as gr
+import streamlit as st
 import folium
+from folium.plugins import HeatMap
+from streamlit_folium import st_folium
+import numpy as np
 from datetime import datetime, timedelta
 
 # Import prediction and data fetching modules
-from predictor import predict_occupancy, predict_occupancy_mock, OCCUPANCY_LABELS
+from predictor import predict_occupancy, load_model, OCCUPANCY_LABELS
 from weather import get_weather_for_prediction
 from holidays import get_holiday_features
 
-# Try to load model on startup, fall back to mock
-USE_MOCK = os.environ.get("USE_MOCK", "false").lower() == "true"
+# Page config
+st.set_page_config(
+    page_title="HappySardines",
+    page_icon="🐟",
+    layout="wide"
+)
 
-if not USE_MOCK:
-    try:
-        from predictor import load_model
-        load_model()
-        print("Model loaded successfully - using real predictions")
-    except Exception as e:
-        print(f"Could not load model: {e}")
-        print("Using mock predictions for testing")
-        USE_MOCK = True
-
-# Select predictor function
-_predict_fn = predict_occupancy_mock if USE_MOCK else predict_occupancy
-
-# Default map center: Linköping
+# Constants
 DEFAULT_LAT = 58.4108
 DEFAULT_LON = 15.6214
-DEFAULT_ZOOM = 11
+DEFAULT_ZOOM = 10
 
-# Östergötland bounds (roughly)
 BOUNDS = {
     "min_lat": 57.8,
     "max_lat": 58.9,
@@ -44,335 +37,299 @@ BOUNDS = {
     "max_lon": 16.8
 }
 
-# Preset locations for quick selection
-PRESET_LOCATIONS = {
-    "Linköping Central": (58.4158, 15.6253),
-    "Norrköping Central": (58.5942, 16.1826),
-    "Linköping University": (58.3980, 15.5762),
-    "Mjärdevi Science Park": (58.4027, 15.5672),
-    "Motala": (58.5375, 15.0364),
-    "Finspång": (58.7050, 15.7700),
+# Color scheme for occupancy levels
+OCCUPANCY_COLORS = {
+    0: "#22c55e",  # Empty - green
+    1: "#22c55e",  # Many seats - green
+    2: "#eab308",  # Few seats - yellow
+    3: "#f97316",  # Standing - orange
+    4: "#ef4444",  # Crushed - red
+    5: "#ef4444",  # Full - red
+    6: "#6b7280",  # Not accepting - gray
 }
 
 
-def create_map(lat=DEFAULT_LAT, lon=DEFAULT_LON):
-    """Create a Folium map centered on location with marker."""
+@st.cache_resource
+def get_model():
+    """Load model once and cache it."""
+    try:
+        return load_model()
+    except Exception as e:
+        st.error(f"Failed to load model: {e}")
+        return None
+
+
+def generate_heatmap_data(hour, day_of_week, weather, holidays):
+    """Generate heat map data by predicting crowding across a grid."""
+    model = get_model()
+    if model is None:
+        return []
+
+    # Create grid of points across Östergötland
+    lat_steps = 15
+    lon_steps = 20
+    lats = np.linspace(BOUNDS["min_lat"], BOUNDS["max_lat"], lat_steps)
+    lons = np.linspace(BOUNDS["min_lon"], BOUNDS["max_lon"], lon_steps)
+
+    heatmap_data = []
+
+    for lat in lats:
+        for lon in lons:
+            try:
+                pred_class, confidence, _ = predict_occupancy(
+                    lat=lat, lon=lon, hour=hour, day_of_week=day_of_week,
+                    weather=weather, holidays=holidays
+                )
+                # Weight by occupancy level (higher = more crowded = more intense)
+                intensity = pred_class / 5.0  # Normalize to 0-1
+                if intensity > 0.1:  # Only show if there's some crowding
+                    heatmap_data.append([lat, lon, intensity])
+            except Exception:
+                pass
+
+    return heatmap_data
+
+
+def create_map(selected_lat=None, selected_lon=None, show_heatmap=False,
+               heatmap_data=None):
+    """Create a Folium map with optional marker and heatmap."""
+    center_lat = selected_lat if selected_lat else DEFAULT_LAT
+    center_lon = selected_lon if selected_lon else DEFAULT_LON
+
     m = folium.Map(
-        location=[lat, lon],
+        location=[center_lat, center_lon],
         zoom_start=DEFAULT_ZOOM,
         tiles="CartoDB positron"
     )
 
-    # Add marker at selected location
-    folium.Marker(
-        [lat, lon],
-        popup=f"Selected: {lat:.4f}, {lon:.4f}",
-        icon=folium.Icon(color="blue", icon="bus", prefix="fa")
-    ).add_to(m)
-
-    # Add a rectangle showing the coverage area
+    # Add coverage area rectangle
     folium.Rectangle(
         bounds=[[BOUNDS["min_lat"], BOUNDS["min_lon"]],
                 [BOUNDS["max_lat"], BOUNDS["max_lon"]]],
         color="#3388ff",
         fill=False,
-        weight=1,
-        opacity=0.3,
+        weight=2,
+        opacity=0.5,
         popup="Coverage area"
     ).add_to(m)
 
-    return m._repr_html_()
-
-
-def make_prediction(lat, lon, date_choice, hour):
-    """
-    Make occupancy prediction for given inputs.
-
-    Returns formatted result HTML.
-    """
+    # Add heatmap if enabled
+    if show_heatmap and heatmap_data:
+        HeatMap(
+            heatmap_data,
+            min_opacity=0.3,
+            radius=25,
+            blur=15,
+            gradient={0.2: 'green', 0.4: 'yellow', 0.6: 'orange', 0.8: 'red'}
+        ).add_to(m)
+
+    # Add marker if location selected
+    if selected_lat and selected_lon:
+        folium.Marker(
+            [selected_lat, selected_lon],
+            popup=f"Selected: {selected_lat:.4f}, {selected_lon:.4f}",
+            icon=folium.Icon(color="blue", icon="bus", prefix="fa")
+        ).add_to(m)
+
+    return m
+
+
+def make_prediction(lat, lon, selected_datetime):
+    """Make prediction and return formatted result."""
     if lat is None or lon is None:
-        return create_result_card(
-            "Please select a location",
-            "Use the preset buttons or enter coordinates.",
-            "gray",
-            None
-        )
+        return None, None, None
 
-    # Validate coordinates are in Östergötland
+    # Check bounds
     if not (BOUNDS["min_lat"] <= lat <= BOUNDS["max_lat"] and
             BOUNDS["min_lon"] <= lon <= BOUNDS["max_lon"]):
-        return create_result_card(
-            "Location outside coverage area",
-            f"Please select a location within Östergötland. Selected: {lat:.4f}, {lon:.4f}",
-            "gray",
-            None
-        )
-
-    # Determine date
-    today = datetime.now().date()
-    if date_choice == "Today":
-        selected_date = today
-    else:  # Tomorrow
-        selected_date = today + timedelta(days=1)
-
-    selected_datetime = datetime.combine(selected_date, datetime.min.time().replace(hour=int(hour)))
+        return None, None, "Location outside coverage area"
 
     try:
-        # Get weather forecast
         weather = get_weather_for_prediction(lat, lon, selected_datetime)
-
-        # Get holiday features
         holidays = get_holiday_features(selected_datetime)
 
-        # Make prediction
-        prediction, confidence, probabilities = _predict_fn(
-            lat=lat,
-            lon=lon,
-            hour=int(hour),
-            day_of_week=selected_date.weekday(),
+        pred_class, confidence, probs = predict_occupancy(
+            lat=lat, lon=lon,
+            hour=selected_datetime.hour,
+            day_of_week=selected_datetime.weekday(),
             weather=weather,
             holidays=holidays
         )
 
-        # Format result
-        label_info = OCCUPANCY_LABELS[prediction]
+        return pred_class, confidence, {
+            "weather": weather,
+            "holidays": holidays,
+            "datetime": selected_datetime
+        }
+    except Exception as e:
+        return None, None, str(e)
 
-        # Build context string
-        day_name = selected_date.strftime("%A")
-        day_type = "Holiday" if holidays.get("is_red_day") else ("Work-free day" if holidays.get("is_work_free") else "Regular day")
-        temp = weather.get("temperature_2m", "?")
 
-        context = f"{temp:.0f}°C  •  {day_name}  •  {day_type}"
+# Initialize session state
+if "selected_lat" not in st.session_state:
+    st.session_state.selected_lat = DEFAULT_LAT
+if "selected_lon" not in st.session_state:
+    st.session_state.selected_lon = DEFAULT_LON
 
-        return create_result_card(
-            label_info["label"],
-            label_info["message"],
-            label_info["color"],
-            context,
-            confidence
-        )
+# Header
+st.title("🐟 HappySardines")
+st.markdown("*How packed are buses in Östergötland?*")
 
-    except Exception as e:
-        return create_result_card(
-            "Prediction failed",
-            f"Error: {str(e)}",
-            "gray",
-            None
-        )
+# Check if model is available
+model = get_model()
+if model is None:
+    st.error("⚠️ Could not load prediction model. Please check the configuration.")
+    st.stop()
 
+# Sidebar controls
+with st.sidebar:
+    st.header("Settings")
 
-def create_result_card(title, message, color, context, confidence=None):
-    """Create HTML result card."""
-    color_map = {
-        "green": "#22c55e",
-        "yellow": "#eab308",
-        "orange": "#f97316",
-        "red": "#ef4444",
-        "gray": "#6b7280"
-    }
-    bg_color = color_map.get(color, "#6b7280")
-
-    confidence_html = ""
-    if confidence is not None:
-        confidence_html = f'<div style="font-size: 0.9em; opacity: 0.8;">Confidence: {confidence:.0%}</div>'
-
-    context_html = ""
-    if context:
-        context_html = f'<div style="margin-top: 15px; font-size: 0.9em; opacity: 0.7;">{context}</div>'
-
-    return f"""
-    <div style="
-        background: linear-gradient(135deg, {bg_color}22, {bg_color}11);
-        border-left: 4px solid {bg_color};
-        border-radius: 12px;
-        padding: 24px;
-        margin: 10px 0;
-    ">
-        <div style="
-            font-size: 1.4em;
-            font-weight: 600;
-            color: {bg_color};
-            margin-bottom: 8px;
-        ">{title}</div>
-        <div style="
-            font-size: 1.1em;
-            color: #374151;
-            line-height: 1.5;
-        ">{message}</div>
-        {confidence_html}
-        {context_html}
-    </div>
-    """
-
-
-# Custom CSS
-CUSTOM_CSS = """
-.main-title {
-    text-align: center;
-    margin-bottom: 0;
-}
-.subtitle {
-    text-align: center;
-    color: #6b7280;
-    margin-top: 5px;
-    margin-bottom: 20px;
-}
-.location-btn {
-    margin: 2px !important;
-}
-"""
+    # Date/time selection
+    st.subheader("When?")
+    date_option = st.radio("Date", ["Today", "Tomorrow"], horizontal=True)
+    hour = st.slider("Hour", 5, 23, 8)
 
-# Build Gradio interface
-with gr.Blocks(
-    title="HappySardines",
-    theme=gr.themes.Soft(primary_hue="blue", secondary_hue="cyan"),
-    css=CUSTOM_CSS
-) as app:
-
-    # Header
-    gr.Markdown("# 🐟 HappySardines", elem_classes=["main-title"])
-    gr.Markdown("*How packed are buses in Östergötland?*", elem_classes=["subtitle"])
-
-    with gr.Row():
-        # Left column: Map and location
-        with gr.Column(scale=2):
-            gr.Markdown("### Select Location")
-
-            # Quick location buttons
-            gr.Markdown("**Quick select:**")
-            with gr.Row():
-                location_buttons = []
-                for name in list(PRESET_LOCATIONS.keys())[:3]:
-                    btn = gr.Button(name, size="sm", elem_classes=["location-btn"])
-                    location_buttons.append((name, btn))
-            with gr.Row():
-                for name in list(PRESET_LOCATIONS.keys())[3:]:
-                    btn = gr.Button(name, size="sm", elem_classes=["location-btn"])
-                    location_buttons.append((name, btn))
-
-            # Coordinate inputs
-            with gr.Row():
-                lat_input = gr.Number(
-                    label="Latitude",
-                    value=DEFAULT_LAT,
-                    precision=4,
-                    minimum=BOUNDS["min_lat"],
-                    maximum=BOUNDS["max_lat"]
-                )
-                lon_input = gr.Number(
-                    label="Longitude",
-                    value=DEFAULT_LON,
-                    precision=4,
-                    minimum=BOUNDS["min_lon"],
-                    maximum=BOUNDS["max_lon"]
-                )
+    today = datetime.now().date()
+    selected_date = today if date_option == "Today" else today + timedelta(days=1)
+    selected_datetime = datetime.combine(selected_date, datetime.min.time().replace(hour=hour))
 
-            # Map display
-            map_display = gr.HTML(value=create_map())
+    st.markdown(f"**{selected_datetime.strftime('%A, %B %d at %H:00')}**")
 
-        # Right column: Time and predict
-        with gr.Column(scale=1):
-            gr.Markdown("### When?")
+    st.divider()
 
-            date_choice = gr.Radio(
-                choices=["Today", "Tomorrow"],
-                value="Today",
-                label="Date"
-            )
+    # View mode
+    st.subheader("View Mode")
+    show_heatmap = st.toggle("Show Crowding Forecast", value=False,
+                              help="Display predicted crowding across the region")
 
-            hour_slider = gr.Slider(
-                minimum=5,
-                maximum=23,
-                value=8,
-                step=1,
-                label="Hour",
-                info="Select time of day (24h format)"
-            )
+    if show_heatmap:
+        st.info("🔥 Heat map shows predicted crowding levels. Red = busy, Green = quiet.")
 
-            time_display = gr.Markdown("**Selected: 08:00**")
+        if st.button("Generate Heat Map", type="primary"):
+            with st.spinner("Generating predictions across region..."):
+                weather = get_weather_for_prediction(DEFAULT_LAT, DEFAULT_LON, selected_datetime)
+                holidays = get_holiday_features(selected_datetime)
+                st.session_state.heatmap_data = generate_heatmap_data(
+                    hour, selected_date.weekday(), weather, holidays
+                )
 
-            predict_btn = gr.Button("Predict Crowding", variant="primary", size="lg")
+    st.divider()
 
-    # Result section
-    gr.Markdown("### Prediction")
-    result_display = gr.HTML(
-        value=create_result_card(
-            "Select location and time",
-            "Then click 'Predict Crowding' to see the forecast.",
-            "gray",
-            None
-        )
-    )
-
-    # About section
-    with gr.Accordion("About this tool", open=False):
-        gr.Markdown("""
+    # About
+    with st.expander("About this tool"):
+        st.markdown("""
         **How it works:**
 
-        This tool predicts typical bus crowding levels based on:
-        - **Location** - Different areas have different ridership patterns
-        - **Time** - Rush hours vs. off-peak
-        - **Day of week** - Weekdays vs. weekends
-        - **Weather** - Temperature, precipitation, etc.
-        - **Holidays** - Swedish red days and work-free days
+        This tool predicts bus crowding levels based on:
+        - 📍 Location
+        - 🕐 Time of day
+        - 📅 Day of week
+        - 🌡️ Weather conditions
+        - 🎉 Holidays
 
         **Data sources:**
-        - Historical bus occupancy data from Östgötatrafiken (GTFS-RT, Nov-Dec 2025)
-        - Weather forecasts from Open-Meteo
-        - Swedish holiday calendar from Svenska Dagar API
-
-        **Limitations:**
-        - Accuracy varies by location and time
-        - The model predicts general area crowding, not specific bus lines
+        - Bus occupancy data from Östgötatrafiken
+        - Weather from Open-Meteo
+        - Holidays from Svenska Dagar API
 
-        **Built for KTH ID2223 - Scalable Machine Learning and Deep Learning**
+        **Built for KTH ID2223**
         """)
 
-    # Event handlers
-    def update_time_display(hour):
-        return f"**Selected: {int(hour):02d}:00**"
+# Main content
+col1, col2 = st.columns([2, 1])
 
-    def update_location(name):
-        lat, lon = PRESET_LOCATIONS[name]
-        return lat, lon, create_map(lat, lon)
+with col1:
+    st.subheader("📍 Click on the map to select a location")
 
-    def update_map_from_coords(lat, lon):
-        if lat is not None and lon is not None:
-            return create_map(lat, lon)
-        return create_map()
+    # Get heatmap data if available
+    heatmap_data = st.session_state.get("heatmap_data", [])
 
-    hour_slider.change(
-        fn=update_time_display,
-        inputs=[hour_slider],
-        outputs=[time_display]
+    # Create and display map
+    m = create_map(
+        selected_lat=st.session_state.selected_lat,
+        selected_lon=st.session_state.selected_lon,
+        show_heatmap=show_heatmap,
+        heatmap_data=heatmap_data
     )
 
-    # Connect location buttons
-    for name, btn in location_buttons:
-        btn.click(
-            fn=lambda n=name: update_location(n),
-            outputs=[lat_input, lon_input, map_display]
-        )
-
-    # Update map when coordinates change
-    lat_input.change(
-        fn=update_map_from_coords,
-        inputs=[lat_input, lon_input],
-        outputs=[map_display]
-    )
-    lon_input.change(
-        fn=update_map_from_coords,
-        inputs=[lat_input, lon_input],
-        outputs=[map_display]
+    map_data = st_folium(
+        m,
+        height=500,
+        width=None,
+        returned_objects=["last_clicked"],
+        key="map"
     )
 
-    predict_btn.click(
-        fn=make_prediction,
-        inputs=[lat_input, lon_input, date_choice, hour_slider],
-        outputs=[result_display]
+    # Handle map clicks
+    if map_data and map_data.get("last_clicked"):
+        clicked = map_data["last_clicked"]
+        st.session_state.selected_lat = clicked["lat"]
+        st.session_state.selected_lon = clicked["lng"]
+        st.rerun()
+
+with col2:
+    st.subheader("🔮 Prediction")
+
+    # Show selected coordinates
+    st.markdown(f"**Location:** {st.session_state.selected_lat:.4f}, {st.session_state.selected_lon:.4f}")
+
+    # Make prediction
+    pred_class, confidence, result = make_prediction(
+        st.session_state.selected_lat,
+        st.session_state.selected_lon,
+        selected_datetime
     )
 
+    if pred_class is not None:
+        label_info = OCCUPANCY_LABELS[pred_class]
+        color = OCCUPANCY_COLORS[pred_class]
+
+        # Result card
+        st.markdown(f"""
+        <div style="
+            background: linear-gradient(135deg, {color}22, {color}11);
+            border-left: 4px solid {color};
+            border-radius: 12px;
+            padding: 20px;
+            margin: 10px 0;
+        ">
+            <div style="font-size: 1.3em; font-weight: 600; color: {color};">
+                {label_info['icon']} {label_info['label']}
+            </div>
+            <div style="margin-top: 8px; color: #374151;">
+                {label_info['message']}
+            </div>
+            <div style="margin-top: 12px; font-size: 0.9em; opacity: 0.8;">
+                Confidence: {confidence:.0%}
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+
+        # Context info
+        if isinstance(result, dict):
+            weather = result["weather"]
+            holidays = result["holidays"]
+
+            day_type = "🎉 Holiday" if holidays.get("is_red_day") else (
+                "🏖️ Work-free day" if holidays.get("is_work_free") else "📅 Regular day"
+            )
 
-# For local testing
-if __name__ == "__main__":
-    app.launch()
+            st.markdown(f"""
+            **Conditions:**
+            - 🌡️ {weather.get('temperature_2m', '?'):.0f}°C
+            - {day_type}
+            - {selected_datetime.strftime('%A')}
+            """)
+
+    elif isinstance(result, str):
+        st.error(result)
+    else:
+        st.info("Click on the map to select a location")
+
+# Footer
+st.divider()
+st.markdown(
+    "<div style='text-align: center; opacity: 0.6;'>Built for KTH ID2223 - Scalable Machine Learning</div>",
+    unsafe_allow_html=True
+)

predictor.py

@@ -102,7 +102,7 @@ def load_model():
     # Check for API key before attempting connection
     api_key = os.environ.get("HOPSWORKS_API_KEY")
     if not api_key:
-        raise ValueError("HOPSWORKS_API_KEY not set - using mock predictions")
+        raise ValueError("HOPSWORKS_API_KEY environment variable not set. Please add it in Space settings.")
 
     try:
         import hopsworks
@@ -189,39 +189,3 @@ def predict_occupancy(lat, lon, hour, day_of_week, weather, holidays):
     confidence = float(probabilities[predicted_class])
 
     return predicted_class, confidence, probabilities.tolist()
-
-
-# Mock prediction for testing without Hopsworks
-def predict_occupancy_mock(lat, lon, hour, day_of_week, weather, holidays):
-    """
-    Mock prediction for testing UI without model.
-    """
-    # Simple heuristic based on time
-    if 7 <= hour <= 9 or 16 <= hour <= 18:
-        # Rush hour
-        if holidays.get("is_work_free") or holidays.get("is_red_day"):
-            predicted_class = 1  # Holiday rush hour = many seats
-        else:
-            predicted_class = 2 if hour < 8 or hour > 17 else 3  # Peak = standing
-    elif 10 <= hour <= 15:
-        predicted_class = 1  # Midday = many seats
-    else:
-        predicted_class = 0  # Early/late = empty
-
-    # Mock probabilities
-    probabilities = [0.1] * 7
-    probabilities[predicted_class] = 0.6
-    confidence = 0.6
-
-    return predicted_class, confidence, probabilities
-
-
-# For testing - use mock if model not available
-def get_predictor():
-    """Get the appropriate predictor function."""
-    try:
-        load_model()
-        return predict_occupancy
-    except Exception as e:
-        print(f"Using mock predictor: {e}")
-        return predict_occupancy_mock

requirements.txt

@@ -1,5 +1,6 @@
-gradio==4.44.0
-huggingface_hub>=0.24.0,<1.0.0
+streamlit>=1.28.0
+streamlit-folium>=0.15.0
+folium>=0.15.0
 hopsworks==4.2.*
 xgboost>=2.0.0
 scikit-learn
@@ -7,4 +8,3 @@ pandas
 numpy
 requests
 python-dotenv
-folium>=0.15.0