Create app.py

app.py

@@ -0,0 +1,269 @@
+import streamlit as st
+import folium
+from streamlit_folium import folium_static
+import requests
+import json
+from datetime import datetime
+
+# API Keys
+GROQ_API_KEY = "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"
+HERE_API_KEY = "Z-INy7MKiZwfH6mAchEr0QPFaYuuo5QKqGxSnHxcKTY"
+
+# Initialize session states
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
+if 'user_input' not in st.session_state:
+    st.session_state.user_input = ""
+if 'location_history' not in st.session_state:
+    st.session_state.location_history = []
+if 'current_map' not in st.session_state:
+    st.session_state.current_map = None
+
+# Page configuration
+st.set_page_config(
+    page_title="TrafficWise AI Planner",
+    page_icon="🚦",
+    layout="wide"
+)
+
+def geocode_address(address):
+    """Convert address to coordinates using HERE Geocoding API"""
+    url = f"https://geocode.search.hereapi.com/v1/geocode"
+    params = {
+        'q': address,
+        'apiKey': HERE_API_KEY
+    }
+    try:
+        response = requests.get(url, params=params)
+        response.raise_for_status()
+        data = response.json()
+        if data['items']:
+            position = data['items'][0]['position']
+            address_label = data['items'][0].get('address', {}).get('label', address)
+            return position['lat'], position['lng'], address_label
+        return None, None, None
+    except Exception as e:
+        st.error(f"Geocoding error: {str(e)}")
+        return None, None, None
+
+def get_traffic_incidents(lat, lon, radius=1000):
+    """Fetch traffic incidents from HERE API"""
+    url = "https://data.traffic.hereapi.com/v7/incidents"
+    params = {
+        'apiKey': HERE_API_KEY,
+        'in': f"circle:{lat},{lon};r={radius}",
+        'locationReferencing': 'polyline'
+    }
+    try:
+        response = requests.get(url, params=params)
+        response.raise_for_status()
+        return response.json()
+    except Exception as e:
+        # st.warning(f"Note: Traffic data may be limited in this area")
+        return None
+
+def generate_traffic_map(center_lat=30.3753, center_lng=69.3451):
+    """Generate map with traffic data"""
+    m = folium.Map(location=[center_lat, center_lng], zoom_start=13)
+    
+    # Add marker for searched location
+    folium.Marker(
+        [center_lat, center_lng],
+        popup="Selected Location",
+        icon=folium.Icon(color='red', icon='info-sign')
+    ).add_to(m)
+    
+    # Add traffic incidents if available
+    incidents = get_traffic_incidents(center_lat, center_lng)
+    if incidents and 'results' in incidents:
+        for incident in incidents['results']:
+            try:
+                # Get incident details
+                description = incident.get('description', {}).get('value', 'Traffic Incident')
+                severity = incident.get('severity', {}).get('value', 'minor')
+                
+                # Color based on severity
+                color = {
+                    'minor': 'green',
+                    'moderate': 'orange',
+                    'major': 'red'
+                }.get(severity, 'blue')
+                
+                # Get location
+                location = incident.get('location', {})
+                if 'polyline' in location:
+                    coordinates = []
+                    points = location['polyline'].get('points', [])
+                    for point in points:
+                        lat = point.get('lat')
+                        lng = point.get('lng')
+                        if lat and lng:
+                            coordinates.append([lat, lng])
+                    
+                    if coordinates:
+                        # Add incident to map
+                        folium.PolyLine(
+                            coordinates,
+                            color=color,
+                            weight=4,
+                            opacity=0.8,
+                            tooltip=description
+                        ).add_to(m)
+                        
+                        # Add marker at start of incident
+                        folium.CircleMarker(
+                            coordinates[0],
+                            radius=8,
+                            color=color,
+                            fill=True,
+                            popup=description
+                        ).add_to(m)
+                
+            except Exception as e:
+                continue
+    
+    return m
+
+# Sidebar configuration
+st.sidebar.title("🚦 TrafficWise AI Planner")
+st.sidebar.markdown("Your AI Assistant for Traffic & Urban Planning")
+
+# Previous locations section
+if st.session_state.location_history:
+    st.sidebar.subheader("Recent Searches")
+    for idx, (loc, timestamp) in enumerate(reversed(st.session_state.location_history[-5:])):
+        if st.sidebar.button(f"📍 {loc} ({timestamp})", key=f"prev_loc_{idx}"):
+            coordinates = geocode_address(loc)
+            if coordinates[0]:
+                st.session_state.current_map = generate_traffic_map(coordinates[0], coordinates[1])
+
+# Location input
+st.sidebar.subheader("Search Location")
+location_input = st.sidebar.text_input(
+    "Enter city or address:",
+    key="location_input",
+    placeholder="e.g., London, New York, Tokyo"
+)
+
+# Map container
+map_container = st.sidebar.container()
+map_container.subheader("Traffic Map")
+
+if location_input:
+    lat, lng, address_label = geocode_address(location_input)
+    if lat and lng:
+        # Update location history
+        timestamp = datetime.now().strftime("%H:%M")
+        if address_label not in [loc for loc, _ in st.session_state.location_history]:
+            st.session_state.location_history.append((address_label, timestamp))
+        # Generate and store map
+        st.session_state.current_map = generate_traffic_map(lat, lng)
+        st.sidebar.success(f"📍 Showing Map for: {address_label}")
+    else:
+        st.sidebar.error("Location not found. Please try another address.")
+
+# Display current map
+with map_container:
+    if st.session_state.current_map:
+        folium_static(st.session_state.current_map, width=300, height=400)
+    else:
+        folium_static(generate_traffic_map(), width=300, height=400)
+
+# Temperature slider
+temperature = st.sidebar.slider(
+    "AI Response Variation:",
+    min_value=0.0,
+    max_value=1.0,
+    value=0.7,
+    step=0.1,
+    help="Higher values provide more varied suggestions, lower values offer more consistent advice"
+)
+
+# Main chat interface
+st.title("🚦 TrafficWise AI Planner")
+st.markdown("""
+### Your AI Assistant for:
+- 🚗 Traffic Route Optimization
+- 🌆 Urban Congestion Solutions
+- 🚦 Traffic Flow Analysis
+- 🛣 Infrastructure Planning
+""")
+
+def chat_with_traffic_planner(user_message, temperature):
+    """Send a message to Groq API's model and return the response."""
+    enhanced_prompt = f"""As a traffic and urban planning expert, help with the following question 
+    about traffic routes, urban congestion, or city planning: {user_message}
+    """
+    headers = {
+        "Authorization": f"Bearer {GROQ_API_KEY}",
+        "Content-Type": "application/json"
+    }
+    payload = {
+        "model": "llama3-8b-8192",
+        "messages": [{"role": "user", "content": enhanced_prompt}],
+        "temperature": temperature
+    }
+    try:
+        response = requests.post(
+            "https://api.groq.com/openai/v1/chat/completions",
+            headers=headers,
+            json=payload,
+            timeout=30
+        )
+        response.raise_for_status()
+        return response.json()["choices"][0]["message"]["content"]
+    except requests.exceptions.RequestException as e:
+        return f"Error: Unable to connect to the API - {str(e)}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def clear_chat():
+    st.session_state.chat_history = []
+
+for message in st.session_state.chat_history:
+    role = message["role"]
+    content = message["content"]
+    st.markdown(f"👤 You:** {content}" if role == "user" else f"🚦 TrafficWise:** {content}")
+    st.markdown("---")
+
+def submit_message():
+    if st.session_state.user_input:
+        user_message = st.session_state.user_input
+        st.session_state.chat_history.append({"role": "user", "content": user_message})
+        with st.spinner('Analyzing traffic patterns...'):
+            bot_response = chat_with_traffic_planner(user_message, temperature)
+        st.session_state.chat_history.append({"role": "assistant", "content": bot_response})
+        st.session_state.user_input = ""
+
+st.text_input(
+    "Ask about traffic routes, urban planning, or congestion solutions...",
+    key="user_input",
+    on_change=submit_message,
+    placeholder="Example: What are the best routes to reduce congestion during peak hours?"
+)
+
+if st.button("🗑 Clear Chat"):
+    clear_chat()
+
+st.sidebar.markdown("""
+### 🚗 Traffic Guidelines:
+1. 🕒 Peak Hours
+   - Morning: 7-9 AM
+   - Evening: 4-7 PM
+
+2. 🚸 Safety First
+   - Follow speed limits
+   - Watch for pedestrians
+
+3. 🌍 Eco-Friendly Options
+   - Consider public transport
+   - Use carpooling
+
+4. 🚦 Smart Route Planning
+   - Check traffic updates
+   - Use alternative routes
+
+5. 📱 Stay Informed
+   - Monitor traffic alerts
+   - Check weather conditions
+""")