Update app.py (#8)

- Update app.py (a7e3df52fa5e792377b6e8c18ab743ae807cb09f)

app.py

@@ -1,74 +1,111 @@
-import streamlit as st 
+import streamlit as st
 import pandas as pd
-from datetime import datetime
+import random
+from datetime import datetime, timedelta
 import folium
 from streamlit_folium import folium_static
 import groq
 
-# Load bus data
-data_path = "pdp.csv"
+# --- 📂 Load Bus Data ---
+data_path = r"C:\Users\Muthuraja\OneDrive\Attachments\Desktop\second\pdp.csv"
 df = pd.read_csv(data_path)
 
-# Dummy user credentials
+# --- 🔐 Dummy User Credentials ---
 USER_CREDENTIALS = {
-    "Muthuraja":"virat",
-    "Praveen":"dhoni",
-    "Pandi":"kabadi",
+    "Muthuraja": "virat",
+    "Praveen": "dhoni",
+    "Pandi": "kabadi",
     "admin": "password123",
     "user": "buspass2025"
 }
 
-# Groq API Key
+# --- 🔑 Groq API Key ---
 GROQ_API_KEY = "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"
 groq.api_key = GROQ_API_KEY
 
-# User login
+
+# --- 🔓 Authenticate User ---
 def authenticate(username, password):
+    """Authenticate user."""
     if username in USER_CREDENTIALS and USER_CREDENTIALS[username] == password:
         return True
     return False
 
-# Generate bus prediction using Groq API
-def predict_bus_status(bus_number, city, area):
-    prompt = f"Predict the status and arrival time for bus {bus_number} in {city}, {area}."
+
+# --- 🔮 Predict Bus Status using Groq API ---
+def predict_bus_status(bus_number, city, source_area, destination_area):
+    """Predict bus arrival and status with Groq API."""
+    prompt = f"Predict the status, route, and arrival time for bus {bus_number} from {source_area} to {destination_area} in {city}."
     try:
         client = groq.Client(api_key=GROQ_API_KEY)
         response = client.chat.completions.create(
-            model="llama3-70b-8192",  # Correct model name for Groq  # Use Groq's model, adjust if needed
+            model="llama3-70b-8192",
             messages=[{"role": "system", "content": prompt}]
         )
         return response.choices[0].message.content.strip()
     except Exception as e:
         return f"Error: {e}"
 
-# Plot bus locations using Folium with real coordinates
-def plot_bus_map(area_df):
-    if area_df.empty:
-        st.warning("No bus data available for this area.")
-        return
 
-    if "latitude" not in area_df.columns or "longitude" not in area_df.columns:
-        st.error("Latitude and longitude columns missing. Please update CSV.")
-        return
+# --- 🕰️ Add Random Delay to Predicted Time ---
+def add_random_delay(arrival_time_str):
+    """Add 1 to 10 minutes delay to arrival time."""
+    try:
+        # Handle 'DD-MM-YYYY HH:MM' format
+        arrival_time = datetime.strptime(arrival_time_str, "%d-%m-%Y %H:%M")
+    except ValueError:
+        # Fallback to 'YYYY-MM-DD HH:MM:SS' if needed
+        arrival_time = datetime.strptime(arrival_time_str, "%Y-%m-%d %H:%M:%S")
+
+    delay_minutes = random.randint(1, 10)  # Add random delay of 1 to 10 minutes
+    new_arrival_time = arrival_time + timedelta(minutes=delay_minutes)
+    return new_arrival_time.strftime("%Y-%m-%d %H:%M:%S")
 
-    center_lat = area_df["latitude"].mean()
-    center_lon = area_df["longitude"].mean()
+
+# --- 🚌 Predict Upcoming Bus with Same Route ---
+def predict_upcoming_buses(bus_number, city, area_df):
+    """Predict upcoming buses on the same route."""
+    same_route_df = area_df[area_df["same_route_return"] == bus_number]
     
-    m = folium.Map(location=[center_lat, center_lon], zoom_start=12)
+    if not same_route_df.empty:
+        upcoming_buses = []
+        for _, row in same_route_df.iterrows():
+            upcoming_time = row['upcoming_arrival_time']
+            delayed_time = add_random_delay(upcoming_time)
+            upcoming_buses.append(f"🚌 Bus {row['upcoming_bus_number']} → {row['bus_route']} arriving at {delayed_time}")
+        return "\n".join(upcoming_buses)
+    return "⚠️ No upcoming buses available on the same route."
+
+
+# --- 🗺️ Plot Bus Route Map ---
+def plot_bus_route(source_area, destination_area, area_df):
+    """Plot bus route between source and destination with real-time location."""
+    source_df = area_df[area_df["area"] == source_area]
+    dest_df = area_df[area_df["area"] == destination_area]
+
+    if source_df.empty or dest_df.empty:
+        st.warning("❌ Invalid source or destination. Please try again.")
+        return
 
-    for _, row in area_df.iterrows():
-        folium.Marker(
-            location=[row["latitude"], row["longitude"]],
-            popup=f"{row['bus_number']} - {row['bus_route']}\nArrival: {row['arrival_time']}\nStatus: {row['status']}",
-            icon=folium.Icon(color="blue" if row["status"].lower() == "on time" else "red")
-        ).add_to(m)
+    source_lat, source_lon = source_df.iloc[0]["latitude"], source_df.iloc[0]["longitude"]
+    dest_lat, dest_lon = dest_df.iloc[0]["latitude"], dest_df.iloc[0]["longitude"]
+
+    m = folium.Map(location=[(source_lat + dest_lat) / 2, (source_lon + dest_lon) / 2], zoom_start=12)
+
+    # Mark Source & Destination
+    folium.Marker([source_lat, source_lon], popup=f"🚌 Source: {source_area}", icon=folium.Icon(color="green")).add_to(m)
+    folium.Marker([dest_lat, dest_lon], popup=f"🏁 Destination: {destination_area}", icon=folium.Icon(color="red")).add_to(m)
+
+    # Draw Route Line
+    folium.PolyLine([(source_lat, source_lon), (dest_lat, dest_lon)], color="blue", weight=5, opacity=0.8).add_to(m)
 
     folium_static(m)
 
-# Streamlit UI
+
+# --- 🚀 Streamlit App Interface ---
 st.title("🚍 Tamil Nadu Bus Tracking & Prediction System")
 
-# Login form
+# --- 🔐 Login System ---
 if "authenticated" not in st.session_state:
     st.session_state.authenticated = False
 
@@ -78,34 +115,44 @@ if not st.session_state.authenticated:
     if st.button("Login"):
         if authenticate(username, password):
             st.session_state.authenticated = True
-            st.success("Login successful!")
+            st.success("✅ Login successful!")
+            st.rerun()
         else:
-            st.error("Invalid username or password")
+            st.error("❌ Invalid username or password")
 
+# --- 🗺️ Main Content after Login ---
 if st.session_state.authenticated:
-    city = st.selectbox("Select City", df["city"].unique())
-    area = st.selectbox("Select Area", df[df["city"] == city]["area"].unique())
-
-    filtered_df = df[(df["city"] == city) & (df["area"] == area)]
+    st.sidebar.header("🌆 City, Source & Destination Selection")
     
-    st.subheader(f"🚌 Bus Details for {city}, {area}")
+    city = st.sidebar.selectbox("Select City", df["city"].unique())
+    area_df = df[df["city"] == city]
+
+    # Select Source & Destination Area
+    source_area = st.sidebar.selectbox("Select Source Area", area_df["area"].unique())
+    destination_area = st.sidebar.selectbox("Select Destination Area", area_df["area"].unique())
+
+    # --- 🚌 Show Bus Details ---
+    st.subheader(f"🚌 Bus Details for Route: {source_area} ➡️ {destination_area} in {city}")
+    filtered_df = area_df[(area_df["area"] == source_area) | (area_df["area"] == destination_area)]
     st.dataframe(filtered_df)
 
-    st.subheader("🗺️ Bus Map View")
-    plot_bus_map(filtered_df)
+    # --- 🗺️ Show Live Route Map ---
+    st.subheader("🗺️ Live Bus Route Map")
+    plot_bus_route(source_area, destination_area, area_df)
 
-    def predict_next_bus(area_df):
-        now = datetime.now()
-        upcoming_buses = area_df[area_df["arrival_time"] > now.strftime("%Y-%m-%d %H:%M:%S")]
-        if not upcoming_buses.empty:
-            next_bus = upcoming_buses.iloc[0]
-            prediction = predict_bus_status(next_bus['bus_number'], city, area)
-            return f"🚏 Next bus: {next_bus['bus_number']} arriving at {next_bus['arrival_time']}\n🔮 Prediction: {prediction}"
-        return "⚠️ No upcoming buses available."
+    # --- 🔮 Predict Bus and Same Route Buses ---
+    st.subheader("🔮 Bus Prediction & Same Route Upcoming Buses")
+    if not filtered_df.empty:
+        for _, row in filtered_df.iterrows():
+            bus_number = row['bus_number']
+            prediction = predict_bus_status(bus_number, city, source_area, destination_area)
+            st.success(f"🔮 Prediction for Bus {bus_number}: {prediction}")
 
-    prediction = predict_next_bus(filtered_df)
-    st.success(prediction)
+            # Predict upcoming buses for same route
+            upcoming_buses_info = predict_upcoming_buses(bus_number, city, area_df)
+            st.info(upcoming_buses_info)
 
+    # --- 🔓 Logout Option ---
     if st.button("Logout"):
         st.session_state.authenticated = False
-        st.experimental_rerun()
+        st.rerun()