Upload 7 files

chatbot_engine.py

@@ -0,0 +1,418 @@
+import re
+from typing import Dict, List, Any, Tuple
+from data_processor import DataProcessor
+import utils
+
+class FetiiChatbot:
+    """
+    GPT-style chatbot that can answer questions about Fetii rideshare data.
+    """
+    
+    def __init__(self, data_processor: DataProcessor):
+        """Initialize the chatbot with a data processor."""
+        self.data_processor = data_processor
+        self.conversation_history = []
+        
+        self.query_patterns = {
+            'location_stats': [
+                r'how many.*(?:groups?|trips?).*(?:went to|to|from)\s+([^?]+?)(?:\s+(?:last|this|yesterday|today|week|month|year).*?)?[?.]?$',
+                r'(?:trips?|groups?).*(?:to|from)\s+([^?]+?)(?:\s+(?:last|this|yesterday|today|week|month|year).*?)?[?.]?$',
+                r'tell me about\s+([^?]+?)(?:\s+(?:last|this|yesterday|today|week|month|year).*?)?[?.]?$',
+                r'stats for\s+([^?]+?)(?:\s+(?:last|this|yesterday|today|week|month|year).*?)?[?.]?$',
+                r'(?:show me|find|search)\s+([^?]+?)(?:\s+(?:trips?|data|stats))?(?:\s+(?:last|this|yesterday|today|week|month|year).*?)?[?.]?$'
+            ],
+            'time_patterns': [
+                r'when do.*groups?.*ride',
+                r'what time.*most popular',
+                r'peak hours?',
+                r'busiest time'
+            ],
+            'group_size': [
+                r'large groups?\s*\((\d+)\+?\)',
+                r'groups? of (\d+)\+? riders?',
+                r'(\d+)\+? passengers?',
+                r'group size'
+            ],
+            'top_locations': [
+                r'top.*(?:pickup|drop-?off).*spots?',
+                r'most popular.*locations?',
+                r'busiest.*locations?',
+                r'hottest spots?',
+                r'show.*(?:pickup|drop-?off|locations?)',
+                r'list.*locations?'
+            ],
+            'demographics': [
+                r'(\d+)[-–](\d+) year[- ]olds?',
+                r'age group',
+                r'demographics?'
+            ],
+            'general_stats': [
+                r'how many total',
+                r'average group size',
+                r'summary',
+                r'overview',
+                r'give me.*overview',
+                r'show me.*stats',
+                r'total trips'
+            ]
+        }
+        
+        self.time_patterns = [
+            r'\s+(?:last|this|yesterday|today)\s+(?:week|month|year|night)',
+            r'\s+(?:last|this)\s+(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday)',
+            r'\s+(?:in\s+)?(?:january|february|march|april|may|june|july|august|september|october|november|december)',
+            r'\s+(?:last|this|next)\s+\w+',
+            r'\s+(?:yesterday|today|tonight)',
+            r'\s+\d{1,2}\/\d{1,2}\/\d{2,4}',
+            r'\s+\d{1,2}-\d{1,2}-\d{2,4}'
+        ]
+    
+    def process_query(self, user_query: str) -> str:
+        """Process a user query and return an appropriate response."""
+        user_query = user_query.lower().strip()
+        
+        self.conversation_history.append({"role": "user", "content": user_query})
+        
+        try:
+            query_type, params = self._parse_query(user_query)
+            response = self._generate_response(query_type, params, user_query)
+            self.conversation_history.append({"role": "assistant", "content": response})
+            
+            return response
+            
+        except Exception as e:
+            error_response = ("I'm having trouble understanding that question. "
+                            "Try asking about specific locations, times, or group sizes. "
+                            "For example: 'How many groups went to The Aquarium on 6th?' or "
+                            "'What are the peak hours for large groups?'")
+            return error_response
+    
+    def _clean_location_from_query(self, location_text: str) -> str:
+        """Clean time references from location text."""
+        cleaned = location_text.strip()
+        
+        for pattern in self.time_patterns:
+            cleaned = re.sub(pattern, '', cleaned, flags=re.IGNORECASE)
+        
+        cleaned = re.sub(r'\s+', ' ', cleaned).strip()
+        
+        return cleaned
+    
+    def _parse_query(self, query: str) -> Tuple[str, Dict[str, Any]]:
+        """Parse the user query to determine intent and extract parameters."""
+        params = {}
+        
+        for pattern in self.query_patterns['location_stats']:
+            match = re.search(pattern, query, re.IGNORECASE)
+            if match:
+                location = match.group(1).strip()
+                location = self._clean_location_from_query(location)
+                if location:
+                    params['location'] = location
+                    return 'location_stats', params
+        
+        for pattern in self.query_patterns['time_patterns']:
+            if re.search(pattern, query, re.IGNORECASE):
+                group_match = re.search(r'(\d+)\+?', query)
+                if group_match:
+                    params['min_group_size'] = int(group_match.group(1))
+                return 'time_patterns', params
+        
+        for pattern in self.query_patterns['group_size']:
+            match = re.search(pattern, query, re.IGNORECASE)
+            if match:
+                if match.groups():
+                    params['group_size'] = int(match.group(1))
+                return 'group_size', params
+        
+        for pattern in self.query_patterns['top_locations']:
+            if re.search(pattern, query, re.IGNORECASE):
+                if 'pickup' in query or 'pick up' in query:
+                    params['location_type'] = 'pickup'
+                elif 'drop' in query:
+                    params['location_type'] = 'dropoff'
+                else:
+                    params['location_type'] = 'both'
+                return 'top_locations', params
+        
+        for pattern in self.query_patterns['demographics']:
+            match = re.search(pattern, query, re.IGNORECASE)
+            if match and match.groups():
+                if len(match.groups()) == 2:
+                    params['age_range'] = (int(match.group(1)), int(match.group(2)))
+                return 'demographics', params
+        
+        for pattern in self.query_patterns['general_stats']:
+            if re.search(pattern, query, re.IGNORECASE):
+                return 'general_stats', params
+        
+        return 'general_stats', params
+    
+    def _fuzzy_search_location(self, query_location: str) -> List[Tuple[str, int]]:
+        """Search for locations using fuzzy matching."""
+        all_pickups = self.data_processor.df['pickup_main'].value_counts()
+        all_dropoffs = self.data_processor.df['dropoff_main'].value_counts()
+        
+        all_locations = {}
+        for location, count in all_pickups.items():
+            all_locations[location] = all_locations.get(location, 0) + count
+        for location, count in all_dropoffs.items():
+            all_locations[location] = all_locations.get(location, 0) + count
+        
+        matches = []
+        query_lower = query_location.lower()
+        
+        # Exact match
+        for location, count in all_locations.items():
+            if query_lower == location.lower():
+                matches.append((location, count))
+        
+        # Partial match
+        if not matches:
+            for location, count in all_locations.items():
+                if query_lower in location.lower() or location.lower() in query_lower:
+                    matches.append((location, count))
+        
+        # Word match
+        if not matches:
+            query_words = query_lower.split()
+            for location, count in all_locations.items():
+                location_lower = location.lower()
+                if any(word in location_lower for word in query_words if len(word) > 2):
+                    matches.append((location, count))
+        
+        matches.sort(key=lambda x: x[1], reverse=True)
+        return matches[:5] 
+    
+    def _generate_response(self, query_type: str, params: Dict[str, Any], original_query: str) -> str:
+        """Generate a response based on the query type and parameters."""
+        
+        if query_type == 'location_stats':
+            return self._handle_location_stats(params, original_query)
+        elif query_type == 'time_patterns':
+            return self._handle_time_patterns(params)
+        elif query_type == 'group_size':
+            return self._handle_group_size(params)
+        elif query_type == 'top_locations':
+            return self._handle_top_locations(params)
+        elif query_type == 'demographics':
+            return self._handle_demographics(params)
+        elif query_type == 'general_stats':
+            return self._handle_general_stats()
+        else:
+            return self._handle_fallback(original_query)
+    
+    def _handle_location_stats(self, params: Dict[str, Any], original_query: str) -> str:
+        """Handle location-specific statistics queries."""
+        location = params.get('location', '')
+        
+        stats = self.data_processor.get_location_stats(location)
+        
+        if stats['pickup_count'] == 0 and stats['dropoff_count'] == 0:
+            matches = self._fuzzy_search_location(location)
+            
+            if matches:
+                best_match = matches[0][0]
+                stats = self.data_processor.get_location_stats(best_match)
+                
+                if stats['pickup_count'] > 0 or stats['dropoff_count'] > 0:
+                    response = f"<strong>Found results for '{best_match}'</strong> (closest match to '{location}'):\n\n"
+                else:
+                    response = f"I couldn't find exact data for '{location}'. Did you mean one of these?\n\n"
+                    for match_location, count in matches[:3]:
+                        response += f"• <strong>{match_location}</strong> ({count} total trips)\n"
+                    response += f"\nTry asking: 'Tell me about {matches[0][0]}'"
+                    return response
+            else:
+                return f"I couldn't find any trips associated with '{location}'. Try checking the spelling or asking about a different location like 'West Campus' or 'The Aquarium on 6th'."
+        else:
+            best_match = location.title()
+            response = f"<strong>Stats for {best_match}:</strong>\n\n"
+        
+        if stats['pickup_count'] > 0:
+            response += f"<strong>{stats['pickup_count']} pickup trips</strong> with an average group size of {stats['avg_group_size_pickup']:.1f}\n"
+            if stats['peak_hours_pickup']:
+                peak_hours = ', '.join([utils.format_time(h) for h in stats['peak_hours_pickup']])
+                response += f"Most popular pickup times: {peak_hours}\n"
+        
+        if stats['dropoff_count'] > 0:
+            response += f"<strong>{stats['dropoff_count']} drop-off trips</strong> with an average group size of {stats['avg_group_size_dropoff']:.1f}\n"
+            if stats['peak_hours_dropoff']:
+                peak_hours = ', '.join([utils.format_time(h) for h in stats['peak_hours_dropoff']])
+                response += f"Most popular drop-off times: {peak_hours}\n"
+        
+        total_trips = stats['pickup_count'] + stats['dropoff_count']
+        insights = self.data_processor.get_quick_insights()
+        percentage = (total_trips / insights['total_trips']) * 100
+        
+        response += f"\n<strong>Insight:</strong> This location accounts for {percentage:.1f}% of all Austin trips!"
+        
+        if any(word in original_query for word in ['last', 'this', 'month', 'week', 'yesterday', 'today']):
+            response += f"\n\n<strong>Note:</strong> This data covers our full Austin dataset. For specific time periods, the patterns shown represent typical activity for this location."
+        
+        return response
+    
+    def _handle_time_patterns(self, params: Dict[str, Any]) -> str:
+        """Handle time pattern queries."""
+        min_group_size = params.get('min_group_size', None)
+        
+        time_data = self.data_processor.get_time_patterns(min_group_size)
+        
+        response = "<strong>Peak Riding Times:</strong>\n\n"
+        
+        if min_group_size:
+            response += f"<em>For groups of {min_group_size}+ riders:</em>\n\n"
+        
+        hourly_counts = time_data['hourly_counts']
+        top_hours = sorted(hourly_counts.items(), key=lambda x: x[1], reverse=True)[:5]
+        
+        response += "<strong>Busiest Hours:</strong>\n"
+        for i, (hour, count) in enumerate(top_hours, 1):
+            time_label = utils.format_time(hour)
+            response += f"{i}. <strong>{time_label}</strong> - {count} trips\n"
+        
+        time_categories = time_data['time_category_counts']
+        response += "\n<strong>By Time Period:</strong>\n"
+        for period, count in sorted(time_categories.items(), key=lambda x: x[1], reverse=True):
+            response += f"• <strong>{period}:</strong> {count} trips\n"
+        
+        peak_hour = top_hours[0][0]
+        peak_count = top_hours[0][1]
+        response += f"\n<strong>Insight:</strong> {utils.format_time(peak_hour)} is the absolute peak with {peak_count} trips!"
+        
+        return response
+    
+    def _handle_group_size(self, params: Dict[str, Any]) -> str:
+        """Handle group size queries."""
+        target_size = params.get('group_size', 6)
+        
+        insights = self.data_processor.get_quick_insights()
+        group_distribution = insights['group_size_distribution']
+        
+        response = f"<strong>Group Size Analysis ({target_size}+ passengers):</strong>\n\n"
+        
+        large_group_trips = sum(count for size, count in group_distribution.items() if size >= target_size)
+        total_trips = insights['total_trips']
+        percentage = (large_group_trips / total_trips) * 100
+        
+        response += f"• <strong>{large_group_trips} trips</strong> had {target_size}+ passengers ({percentage:.1f}% of all trips)\n"
+        
+        response += f"\n<strong>Breakdown of {target_size}+ passenger groups:</strong>\n"
+        large_groups = {size: count for size, count in group_distribution.items() if size >= target_size}
+        for size, count in sorted(large_groups.items(), key=lambda x: x[1], reverse=True)[:8]:
+            group_pct = (count / large_group_trips) * 100 if large_group_trips > 0 else 0
+            response += f"• <strong>{size} passengers:</strong> {count} trips ({group_pct:.1f}%)\n"
+        
+        avg_size = insights['avg_group_size']
+        response += f"\n<strong>Insight:</strong> Average group size is {avg_size:.1f} passengers - most rides are group experiences!"
+        
+        return response
+    
+    def _handle_top_locations(self, params: Dict[str, Any]) -> str:
+        """Handle top locations queries."""
+        location_type = params.get('location_type', 'both')
+        insights = self.data_processor.get_quick_insights()
+        
+        response = "<strong>Most Popular Locations:</strong>\n\n"
+        
+        if location_type in ['pickup', 'both']:
+            response += "<strong>Top Pickup Spots:</strong>\n"
+            for i, (location, count) in enumerate(list(insights['top_pickups'])[:8], 1):
+                response += f"{i}. <strong>{location}</strong> - {count} pickups\n"
+        
+        if location_type in ['dropoff', 'both']:
+            if location_type == 'both':
+                response += "\n<strong>Top Drop-off Destinations:</strong>\n"
+            else:
+                response += "<strong>Top Drop-off Destinations:</strong>\n"
+            for i, (location, count) in enumerate(list(insights['top_dropoffs'])[:8], 1):
+                response += f"{i}. <strong>{location}</strong> - {count} drop-offs\n"
+        
+        if location_type in ['pickup', 'both']:
+            top_pickup = list(insights['top_pickups'])[0]
+            response += f"\n<strong>Insight:</strong> {top_pickup[0]} dominates pickups with {top_pickup[1]} trips!"
+        
+        return response
+    
+    def _handle_demographics(self, params: Dict[str, Any]) -> str:
+        """Handle demographics queries."""
+        age_range = params.get('age_range', (18, 24))
+        
+        response = f"<strong>Demographics Analysis ({age_range[0]}-{age_range[1]} year olds):</strong>\n\n"
+        response += "I'd love to help with demographic analysis, but I don't currently have access to rider age data in this dataset. "
+        response += "However, I can tell you about the locations and times that are popular with different group sizes!\n\n"
+        
+        insights = self.data_processor.get_quick_insights()
+        response += "<strong>Popular spots that might appeal to younger riders:</strong>\n"
+        
+        entertainment_spots = ['The Aquarium on 6th', 'Wiggle Room', "Shakespeare's", 'LUNA Rooftop', 'Green Light Social']
+        
+        for spot in entertainment_spots[:5]:
+            for location, count in insights['top_dropoffs']:
+                if spot.lower() in location.lower():
+                    response += f"• <strong>{location}</strong> - {count} drop-offs\n"
+                    break
+        
+        response += "\n<strong>Insight:</strong> Late night hours (10 PM - 1 AM) see the highest activity, which often correlates with younger demographics!"
+        
+        return response
+    
+    def _handle_general_stats(self) -> str:
+        """Handle general statistics queries."""
+        insights = self.data_processor.get_quick_insights()
+        
+        response = "<strong>Fetii Austin Overview:</strong>\n\n"
+        
+        response += f"<strong>Total Trips Analyzed:</strong> {insights['total_trips']:,}\n"
+        response += f"<strong>Average Group Size:</strong> {insights['avg_group_size']:.1f} passengers\n"
+        response += f"<strong>Peak Hour:</strong> {utils.format_time(insights['peak_hour'])}\n"
+        response += f"<strong>Large Groups (6+):</strong> {insights['large_groups_count']} trips ({insights['large_groups_pct']:.1f}%)\n\n"
+        
+        response += "<strong>Top Hotspots:</strong>\n"
+        top_pickup = list(insights['top_pickups'])[0]
+        top_dropoff = list(insights['top_dropoffs'])[0]
+        response += f"• Most popular pickup: <strong>{top_pickup[0]}</strong> ({top_pickup[1]} trips)\n"
+        response += f"• Most popular destination: <strong>{top_dropoff[0]}</strong> ({top_dropoff[1]} trips)\n\n"
+        
+        group_dist = insights['group_size_distribution']
+        most_common_size = max(group_dist.items(), key=lambda x: x[1])
+        response += f"<strong>Most Common Group Size:</strong> {most_common_size[0]} passengers ({most_common_size[1]} trips)\n\n"
+        
+        response += "<strong>Key Insights:</strong>\n"
+        response += f"• {insights['large_groups_pct']:.0f}% of all rides are large groups (6+ people)\n"
+        response += "• Peak activity happens late evening (10-11 PM)\n"
+        response += "• West Campus dominates as the top pickup location\n"
+        response += "• Entertainment venues are the most popular destinations"
+        
+        return response
+    
+    def _handle_fallback(self, query: str) -> str:
+        """Handle queries that don't match any specific pattern."""
+        response = "I'm not sure I understood that question perfectly. Here's what I can help you with:\n\n"
+        
+        response += "<strong>Location Questions:</strong>\n"
+        response += "• 'How many groups went to [location]?'\n"
+        response += "• 'Tell me about [location]'\n"
+        response += "• 'Top pickup/drop-off spots'\n\n"
+        
+        response += "<strong>Time Questions:</strong>\n"
+        response += "• 'When do large groups typically ride?'\n"
+        response += "• 'Peak hours for groups of 6+'\n"
+        response += "• 'Busiest times'\n\n"
+        
+        response += "<strong>Group Size Questions:</strong>\n"
+        response += "• 'How many trips had 10+ passengers?'\n"
+        response += "• 'Large group patterns'\n"
+        response += "• 'Average group size'\n\n"
+        
+        response += "Would you like to try asking one of these types of questions?"
+        
+        return response
+    
+    def get_conversation_history(self) -> List[Dict[str, str]]:
+        """Get the conversation history."""
+        return self.conversation_history
+    
+    def clear_history(self):
+        """Clear the conversation history."""
+        self.conversation_history = []

config.py

@@ -0,0 +1,249 @@
+"""
+Configuration settings for Fetii AI Chatbot
+"""
+
+# File settings
+CSV_FILE_PATH = "fetii_data.csv"
+SAMPLE_DATA_SIZE = 2000
+
+# App settings
+APP_TITLE = "Fetii AI Assistant"
+APP_ICON = "🚗"
+PAGE_LAYOUT = "wide"
+
+# Modern color palette
+COLORS = {
+    'primary': '#3b82f6',      # Blue-500
+    'primary_dark': '#1d4ed8',  # Blue-700
+    'secondary': '#10b981',     # Emerald-500
+    'success': '#059669',       # Emerald-600
+    'warning': '#f59e0b',       # Amber-500
+    'danger': '#ef4444',        # Red-500
+    'info': '#06b6d4',         # Cyan-500
+    'light': '#f8fafc',        # Slate-50
+    'dark': '#1e293b',         # Slate-800
+    'gray_100': '#f1f5f9',     # Slate-100
+    'gray_300': '#cbd5e1',     # Slate-300
+    'gray_500': '#64748b',     # Slate-500
+    'gray_700': '#334155',     # Slate-700
+    'gray_900': '#0f172a'      # Slate-900
+}
+
+# Chart configuration
+CHART_CONFIG = {
+    'height': 320,
+    'margin': dict(t=60, b=50, l=50, r=50),
+    'plot_bgcolor': 'rgba(0,0,0,0)',
+    'paper_bgcolor': 'rgba(0,0,0,0)',
+    'font_color': '#374151',
+    'font_family': 'Inter',
+    'grid_color': 'rgba(156, 163, 175, 0.2)',
+    'line_color': 'rgba(156, 163, 175, 0.3)'
+}
+
+# Chatbot configuration
+CHATBOT_CONFIG = {
+    'max_history': 50,
+    'response_delay': 0.5,
+    'example_questions': [
+        "How many groups went to The Aquarium on 6th last month?",
+        "What are the top drop-off spots for large groups on Saturday nights?",
+        "When do groups of 6+ riders typically ride downtown?",
+        "Show me the busiest pickup locations",
+        "What's the pattern for West Campus pickups?",
+        "How many trips had more than 10 passengers?"
+    ]
+}
+
+# Location categories for analysis
+LOCATION_CATEGORIES = {
+    'entertainment': [
+        'bar', 'club', 'lounge', 'aquarium', 'rooftop', 'social', 
+        'pub', 'restaurant', 'venue', 'hall', 'theater'
+    ],
+    'campus': [
+        'campus', 'university', 'drag', 'west campus', 'student',
+        'dorm', 'residence hall', 'fraternity', 'sorority'
+    ],
+    'residential': [
+        'house', 'apartment', 'residence', 'home', 'complex',
+        'condo', 'townhouse', 'manor'
+    ],
+    'business': [
+        'office', 'building', 'center', 'district', 'plaza',
+        'tower', 'corporate', 'business'
+    ],
+    'transport': [
+        'airport', 'station', 'terminal', 'stop', 'hub',
+        'depot', 'port'
+    ],
+    'retail': [
+        'mall', 'store', 'shop', 'market', 'center',
+        'plaza', 'outlet', 'galleria'
+    ]
+}
+
+# Time categories for analysis
+TIME_CATEGORIES = {
+    'early_morning': (0, 6),    # 12 AM - 6 AM
+    'morning': (6, 12),         # 6 AM - 12 PM
+    'afternoon': (12, 17),      # 12 PM - 5 PM
+    'evening': (17, 21),        # 5 PM - 9 PM
+    'night': (21, 24)           # 9 PM - 12 AM
+}
+
+# Group size categories
+GROUP_SIZE_CATEGORIES = {
+    'small': (1, 4),           # 1-4 passengers
+    'medium': (5, 8),          # 5-8 passengers  
+    'large': (9, 12),          # 9-12 passengers
+    'extra_large': (13, 20)    # 13+ passengers
+}
+
+# Analysis thresholds
+ANALYSIS_THRESHOLDS = {
+    'min_trips_for_pattern': 5,
+    'peak_hour_threshold': 0.8,
+    'popular_location_threshold': 10,
+    'large_group_threshold': 6,
+    'min_group_size_for_analysis': 3
+}
+
+# Export configuration
+EXPORT_CONFIG = {
+    'formats': ['csv', 'json', 'pdf'],
+    'max_export_rows': 10000,
+    'include_visualizations': True,
+    'compression': 'gzip'
+}
+
+# UI Icons (using simple unicode icons)
+ICONS = {
+    'trips': '📊',
+    'users': '👥', 
+    'time': '⏰',
+    'location': '📍',
+    'chart': '📈',
+    'chat': '💬',
+    'insights': '💡',
+    'pickup': '🚗',
+    'dropoff': '🎯',
+    'large_groups': '🎉',
+    'analytics': '📊',
+    'dashboard': '🏠'
+}
+
+# Font configuration
+FONTS = {
+    'primary': 'Inter',
+    'monospace': 'JetBrains Mono',
+    'sizes': {
+        'xs': '0.75rem',
+        'sm': '0.875rem', 
+        'base': '1rem',
+        'lg': '1.125rem',
+        'xl': '1.25rem',
+        '2xl': '1.5rem',
+        '3xl': '1.875rem',
+        '4xl': '2.25rem'
+    },
+    'weights': {
+        'light': 300,
+        'normal': 400,
+        'medium': 500,
+        'semibold': 600,
+        'bold': 700
+    }
+}
+
+# Spacing configuration
+SPACING = {
+    'xs': '0.25rem',
+    'sm': '0.5rem',
+    'md': '1rem',
+    'lg': '1.5rem',
+    'xl': '2rem',
+    '2xl': '2.5rem',
+    '3xl': '3rem'
+}
+
+# Border radius configuration
+BORDER_RADIUS = {
+    'sm': '4px',
+    'md': '8px',
+    'lg': '12px',
+    'xl': '16px',
+    '2xl': '20px',
+    'full': '9999px'
+}
+
+# Shadow configuration
+SHADOWS = {
+    'sm': '0 1px 3px rgba(0, 0, 0, 0.12), 0 1px 2px rgba(0, 0, 0, 0.24)',
+    'md': '0 4px 6px rgba(0, 0, 0, 0.07), 0 2px 4px rgba(0, 0, 0, 0.06)',
+    'lg': '0 10px 15px rgba(0, 0, 0, 0.1), 0 4px 6px rgba(0, 0, 0, 0.05)',
+    'xl': '0 20px 25px rgba(0, 0, 0, 0.1), 0 10px 10px rgba(0, 0, 0, 0.04)',
+    '2xl': '0 25px 50px rgba(0, 0, 0, 0.25)'
+}
+
+# Animation configuration
+ANIMATIONS = {
+    'duration': {
+        'fast': '0.15s',
+        'normal': '0.3s',
+        'slow': '0.5s'
+    },
+    'easing': {
+        'ease_in': 'cubic-bezier(0.4, 0, 1, 1)',
+        'ease_out': 'cubic-bezier(0, 0, 0.2, 1)',
+        'ease_in_out': 'cubic-bezier(0.4, 0, 0.2, 1)'
+    }
+}
+
+# Responsive breakpoints
+BREAKPOINTS = {
+    'sm': '640px',
+    'md': '768px', 
+    'lg': '1024px',
+    'xl': '1280px',
+    '2xl': '1536px'
+}
+
+# Data validation rules
+VALIDATION_RULES = {
+    'min_passengers': 1,
+    'max_passengers': 20,
+    'required_fields': ['Trip ID', 'Total Passengers', 'Trip Date and Time'],
+    'date_formats': ['%m/%d/%y %H:%M', '%m/%d/%Y %H:%M', '%Y-%m-%d %H:%M:%S'],
+    'coordinate_bounds': {
+        'lat_min': 30.0,
+        'lat_max': 30.5,
+        'lng_min': -98.0,
+        'lng_max': -97.5
+    }
+}
+
+# Performance settings
+PERFORMANCE = {
+    'max_rows_for_visualization': 10000,
+    'cache_timeout': 3600,  # 1 hour
+    'pagination_size': 50,
+    'max_memory_usage': '1GB'
+}
+
+# Error messages
+ERROR_MESSAGES = {
+    'file_not_found': 'Data file not found. Using sample data for demonstration.',
+    'invalid_data': 'Invalid data format detected. Please check your data.',
+    'no_results': 'No results found for your query. Try adjusting your filters.',
+    'processing_error': 'An error occurred while processing your request.',
+    'visualization_error': 'Unable to create visualization with current data.'
+}
+
+# Success messages
+SUCCESS_MESSAGES = {
+    'data_loaded': 'Data loaded successfully',
+    'export_complete': 'Export completed successfully',
+    'analysis_complete': 'Analysis completed',
+    'cache_updated': 'Cache updated successfully'
+}

data_processor.py

@@ -0,0 +1,228 @@
+import pandas as pd
+import numpy as np
+from typing import Dict, Any
+
+class DataProcessor:
+    """
+    Handles all data processing and analysis for Fetii rideshare data.
+    """
+    
+    def __init__(self, csv_file_path: str = "fetii_data.csv"):
+        """Initialize the data processor with the CSV file."""
+        self.csv_file_path = csv_file_path
+        self.df = None
+        self.insights = {}
+        self.load_and_process_data()
+    
+    def load_and_process_data(self):
+        """Load and process the Fetii trip data."""
+        try:
+            self.df = pd.read_csv(self.csv_file_path)
+            
+            self._clean_data()
+            self._extract_temporal_features()
+            self._extract_location_features()
+            self._calculate_insights()
+            
+            print(f"✅ Successfully loaded {len(self.df)} trips from Austin")
+            
+        except FileNotFoundError:
+            print("⚠️ CSV file not found. Creating sample data for demo...")
+            self._create_sample_data()
+    
+    def _create_sample_data(self):
+        """Create sample data based on the analysis patterns."""
+        np.random.seed(42)
+        
+        locations = {
+            'pickup': ['West Campus', 'The Drag', 'Market District', 'Sixth Street', 'East End', 
+                      'Downtown', 'Govalle', 'Hancock', 'South Lamar', 'Warehouse District'],
+            'dropoff': ['The Aquarium on 6th', 'Wiggle Room', "Shakespeare's", 'Mayfair Austin', 
+                       'Latchkey', '6013 Loyola Ln', "Buford's", 'Darrell K Royal Texas Memorial Stadium',
+                       'LUNA Rooftop', 'University of Texas KA house', 'Green Light Social', "The Cat's Pajamas"]
+        }
+        
+        passenger_choices = [14, 8, 7, 10, 9, 12, 11, 13, 6, 5, 4, 3, 2, 1]
+        passenger_weights = [0.173, 0.128, 0.120, 0.115, 0.113, 0.087, 0.085, 0.077, 0.063, 0.028, 0.007, 0.004, 0.001, 0.001]
+        
+        hour_choices = [22, 23, 21, 19, 0, 20, 18, 1, 2, 17, 16, 3]
+        hour_weights = [0.25, 0.23, 0.19, 0.11, 0.08, 0.06, 0.05, 0.03, 0.02, 0.01, 0.01, 0.01]
+        
+        sample_data = []
+        for i in range(2000):
+            passengers = np.random.choice(passenger_choices, p=passenger_weights)
+            hour = np.random.choice(hour_choices, p=hour_weights)
+            
+            pickup_lat = np.random.normal(30.2672, 0.02)
+            pickup_lng = np.random.normal(-97.7431, 0.02)
+            dropoff_lat = np.random.normal(30.2672, 0.02)
+            dropoff_lng = np.random.normal(-97.7431, 0.02)
+            
+            day = np.random.randint(1, 31)
+            minute = np.random.randint(0, 60)
+            
+            sample_data.append({
+                'Trip ID': 734889 - i,
+                'Booking User ID': np.random.randint(10000, 999999),
+                'Pick Up Latitude': pickup_lat,
+                'Pick Up Longitude': pickup_lng,
+                'Drop Off Latitude': dropoff_lat,
+                'Drop Off Longitude': dropoff_lng,
+                'Pick Up Address': f"{np.random.choice(locations['pickup'])}, Austin, TX",
+                'Drop Off Address': f"{np.random.choice(locations['dropoff'])}, Austin, TX",
+                'Trip Date and Time': f"9/{day}/25 {hour}:{minute:02d}",
+                'Total Passengers': passengers
+            })
+        
+        self.df = pd.DataFrame(sample_data)
+        self._clean_data()
+        self._extract_temporal_features()
+        self._extract_location_features()
+        self._calculate_insights()
+    
+    def _clean_data(self):
+        """Clean and standardize the data."""
+        self.df = self.df.dropna(subset=['Total Passengers', 'Trip Date and Time'])
+        
+        self.df['Total Passengers'] = self.df['Total Passengers'].astype(int)
+        
+        self.df['pickup_main'] = self.df['Pick Up Address'].apply(self._extract_main_location)
+        self.df['dropoff_main'] = self.df['Drop Off Address'].apply(self._extract_main_location)
+    
+    def _extract_main_location(self, address: str) -> str:
+        """Extract the main location name from an address."""
+        if pd.isna(address):
+            return "Unknown"
+        return address.split(',')[0].strip()
+    
+    def _extract_temporal_features(self):
+        """Extract temporal features from trip data."""
+        self.df['datetime'] = pd.to_datetime(self.df['Trip Date and Time'], format='%m/%d/%y %H:%M')
+        self.df['hour'] = self.df['datetime'].dt.hour
+        self.df['day_of_week'] = self.df['datetime'].dt.day_name()
+        self.df['date'] = self.df['datetime'].dt.date
+        
+        self.df['time_category'] = self.df['hour'].apply(self._categorize_time)
+    
+    def _categorize_time(self, hour: int) -> str:
+        """Categorize hour into time periods."""
+        if 6 <= hour < 12:
+            return "Morning"
+        elif 12 <= hour < 17:
+            return "Afternoon"
+        elif 17 <= hour < 21:
+            return "Evening"
+        elif 21 <= hour <= 23:
+            return "Night"
+        else:
+            return "Late Night"
+    
+    def _extract_location_features(self):
+        """Extract location-based features."""
+        self.df['group_category'] = self.df['Total Passengers'].apply(self._categorize_group_size)
+        
+        self.df['is_entertainment'] = self.df['dropoff_main'].apply(self._is_entertainment_venue)
+        self.df['is_campus'] = self.df['pickup_main'].apply(self._is_campus_location)
+    
+    def _categorize_group_size(self, passengers: int) -> str:
+        """Categorize group size."""
+        if passengers <= 4:
+            return "Small (1-4)"
+        elif passengers <= 8:
+            return "Medium (5-8)"
+        elif passengers <= 12:
+            return "Large (9-12)"
+        else:
+            return "Extra Large (13+)"
+    
+    def _is_entertainment_venue(self, location: str) -> bool:
+        """Check if location is an entertainment venue."""
+        entertainment_keywords = ['bar', 'club', 'lounge', 'aquarium', 'rooftop', 'social', 'pub']
+        return any(keyword in location.lower() for keyword in entertainment_keywords)
+    
+    def _is_campus_location(self, location: str) -> bool:
+        """Check if location is campus-related."""
+        campus_keywords = ['campus', 'university', 'drag', 'west campus']
+        return any(keyword in location.lower() for keyword in campus_keywords)
+    
+    def _calculate_insights(self):
+        """Calculate key insights from the data."""
+        self.insights = {
+            'total_trips': len(self.df),
+            'avg_group_size': self.df['Total Passengers'].mean(),
+            'peak_hour': self.df['hour'].mode().iloc[0],
+            'large_groups_count': len(self.df[self.df['Total Passengers'] >= 6]),
+            'large_groups_pct': (len(self.df[self.df['Total Passengers'] >= 6]) / len(self.df)) * 100,
+            'top_pickups': list(self.df['pickup_main'].value_counts().head(10).items()),
+            'top_dropoffs': list(self.df['dropoff_main'].value_counts().head(10).items()),
+            'hourly_distribution': self.df['hour'].value_counts().sort_index().to_dict(),
+            'group_size_distribution': self.df['Total Passengers'].value_counts().sort_index().to_dict()
+        }
+    
+    def get_quick_insights(self) -> Dict[str, Any]:
+        """Get quick insights for dashboard."""
+        return self.insights
+    
+    def query_data(self, query_params: Dict[str, Any]) -> pd.DataFrame:
+        """Query the data based on parameters."""
+        filtered_df = self.df.copy()
+        
+        if 'pickup_location' in query_params:
+            filtered_df = filtered_df[filtered_df['pickup_main'].str.contains(
+                query_params['pickup_location'], case=False, na=False)]
+        
+        if 'dropoff_location' in query_params:
+            filtered_df = filtered_df[filtered_df['dropoff_main'].str.contains(
+                query_params['dropoff_location'], case=False, na=False)]
+        
+        if 'hour_range' in query_params:
+            start_hour, end_hour = query_params['hour_range']
+            filtered_df = filtered_df[
+                (filtered_df['hour'] >= start_hour) & (filtered_df['hour'] <= end_hour)]
+        
+        if 'min_passengers' in query_params:
+            filtered_df = filtered_df[filtered_df['Total Passengers'] >= query_params['min_passengers']]
+        
+        if 'max_passengers' in query_params:
+            filtered_df = filtered_df[filtered_df['Total Passengers'] <= query_params['max_passengers']]
+        
+        if 'date_range' in query_params:
+            start_date, end_date = query_params['date_range']
+            filtered_df = filtered_df[
+                (filtered_df['date'] >= start_date) & (filtered_df['date'] <= end_date)]
+        
+        return filtered_df
+    
+    def get_location_stats(self, location: str, location_type: str = 'both') -> Dict[str, Any]:
+        """Get statistics for a specific location."""
+        if location_type in ['pickup', 'both']:
+            pickup_data = self.df[self.df['pickup_main'].str.contains(location, case=False, na=False)]
+        else:
+            pickup_data = pd.DataFrame()
+        
+        if location_type in ['dropoff', 'both']:
+            dropoff_data = self.df[self.df['dropoff_main'].str.contains(location, case=False, na=False)]
+        else:
+            dropoff_data = pd.DataFrame()
+        
+        return {
+            'pickup_count': len(pickup_data),
+            'dropoff_count': len(dropoff_data),
+            'avg_group_size_pickup': pickup_data['Total Passengers'].mean() if len(pickup_data) > 0 else 0,
+            'avg_group_size_dropoff': dropoff_data['Total Passengers'].mean() if len(dropoff_data) > 0 else 0,
+            'peak_hours_pickup': pickup_data['hour'].mode().tolist() if len(pickup_data) > 0 else [],
+            'peak_hours_dropoff': dropoff_data['hour'].mode().tolist() if len(dropoff_data) > 0 else []
+        }
+    
+    def get_time_patterns(self, group_size_filter: int = None) -> Dict[str, Any]:
+        """Get time-based patterns."""
+        data = self.df.copy()
+        
+        if group_size_filter:
+            data = data[data['Total Passengers'] >= group_size_filter]
+        
+        return {
+            'hourly_counts': data['hour'].value_counts().sort_index().to_dict(),
+            'daily_counts': data['day_of_week'].value_counts().to_dict(),
+            'time_category_counts': data['time_category'].value_counts().to_dict()
+        }

requirements.txt

@@ -0,0 +1,5 @@
+gradio
+pandas
+plotly
+numpy
+python-dateutil

utils.py

@@ -0,0 +1,251 @@
+"""
+Utility functions for Fetii AI Chatbot
+"""
+
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import re
+from typing import List, Dict, Any, Tuple, Optional
+import config
+
+def clean_location_name(location: str) -> str:
+    """Clean and standardize location names."""
+    if pd.isna(location) or not location:
+        return "Unknown"
+    
+    cleaned = location.strip().title()
+    
+    suffixes_to_remove = [", Austin, TX", ", Austin, Texas", ", USA", ", United States"]
+    for suffix in suffixes_to_remove:
+        if cleaned.endswith(suffix):
+            cleaned = cleaned[:-len(suffix)]
+    
+    return cleaned
+
+def categorize_location(location: str) -> str:
+    """Categorize location type based on keywords."""
+    location_lower = location.lower()
+    
+    for category, keywords in config.LOCATION_CATEGORIES.items():
+        if any(keyword in location_lower for keyword in keywords):
+            return category.title()
+    
+    return "Other"
+
+def calculate_distance(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    """Calculate approximate distance between two coordinates in kilometers."""
+    lat_diff = lat2 - lat1
+    lon_diff = lon2 - lon1
+    distance = np.sqrt(lat_diff**2 + lon_diff**2) * 111
+    return round(distance, 2)
+
+def format_time(hour: int) -> str:
+    """Format hour as readable time string."""
+    if hour == 0:
+        return "12:00 AM"
+    elif hour < 12:
+        return f"{hour}:00 AM"
+    elif hour == 12:
+        return "12:00 PM"
+    else:
+        return f"{hour-12}:00 PM"
+
+def get_time_category(hour: int) -> str:
+    """Get time category for a given hour."""
+    for category, (start, end) in config.TIME_CATEGORIES.items():
+        if start <= hour < end:
+            return category.replace('_', ' ').title()
+    return "Unknown"
+
+def get_group_size_category(passengers: int) -> str:
+    """Get group size category for passenger count."""
+    for category, (min_size, max_size) in config.GROUP_SIZE_CATEGORIES.items():
+        if min_size <= passengers <= max_size:
+            return category.replace('_', ' ').title()
+    return "Unknown"
+
+def extract_numbers_from_text(text: str) -> List[int]:
+    """Extract all numbers from text."""
+    numbers = re.findall(r'\d+', text)
+    return [int(num) for num in numbers]
+
+def parse_date_string(date_str: str) -> Optional[datetime]:
+    """Parse various date string formats."""
+    formats = [
+        '%m/%d/%y %H:%M',
+        '%m/%d/%Y %H:%M',
+        '%Y-%m-%d %H:%M:%S',
+        '%Y-%m-%d %H:%M',
+        '%m/%d/%y %H:%M:%S'
+    ]
+    
+    for fmt in formats:
+        try:
+            return datetime.strptime(date_str, fmt)
+        except ValueError:
+            continue
+    
+    return None
+
+def generate_insights(data: pd.DataFrame) -> Dict[str, Any]:
+    """Generate comprehensive insights from trip data."""
+    insights = {}
+    
+    insights['total_trips'] = len(data)
+    insights['total_passengers'] = data['Total Passengers'].sum()
+    insights['avg_group_size'] = data['Total Passengers'].mean()
+    insights['median_group_size'] = data['Total Passengers'].median()
+    
+    if 'hour' in data.columns:
+        insights['peak_hour'] = data['hour'].mode().iloc[0] if len(data['hour'].mode()) > 0 else None
+        insights['hour_distribution'] = data['hour'].value_counts().to_dict()
+    
+    if 'pickup_main' in data.columns:
+        insights['top_pickups'] = data['pickup_main'].value_counts().head(10).to_dict()
+        insights['unique_pickup_locations'] = data['pickup_main'].nunique()
+    
+    if 'dropoff_main' in data.columns:
+        insights['top_dropoffs'] = data['dropoff_main'].value_counts().head(10).to_dict()
+        insights['unique_dropoff_locations'] = data['dropoff_main'].nunique()
+    
+    insights['group_size_distribution'] = data['Total Passengers'].value_counts().to_dict()
+    insights['large_groups'] = len(data[data['Total Passengers'] >= config.ANALYSIS_THRESHOLDS['large_group_threshold']])
+    insights['large_groups_percentage'] = (insights['large_groups'] / insights['total_trips']) * 100
+    
+    if 'date' in data.columns:
+        insights['date_range'] = {
+            'start': data['date'].min(),
+            'end': data['date'].max(),
+            'days_covered': (data['date'].max() - data['date'].min()).days + 1
+        }
+        insights['daily_average'] = insights['total_trips'] / insights['date_range']['days_covered']
+    
+    return insights
+
+def format_number(number: float, decimals: int = 1) -> str:
+    """Format numbers for display."""
+    if number >= 1000000:
+        return f"{number/1000000:.{decimals}f}M"
+    elif number >= 1000:
+        return f"{number/1000:.{decimals}f}K"
+    else:
+        return f"{number:.{decimals}f}" if decimals > 0 else str(int(number))
+
+def create_summary_stats(data: pd.DataFrame) -> Dict[str, str]:
+    """Create formatted summary statistics for display."""
+    insights = generate_insights(data)
+    
+    return {
+        'Total Trips': format_number(insights['total_trips'], 0),
+        'Total Passengers': format_number(insights['total_passengers'], 0),
+        'Average Group Size': f"{insights['avg_group_size']:.1f}",
+        'Peak Hour': format_time(insights.get('peak_hour', 22)),
+        'Large Groups': f"{insights['large_groups_percentage']:.1f}%",
+        'Unique Pickup Locations': format_number(insights.get('unique_pickup_locations', 0), 0),
+        'Unique Destinations': format_number(insights.get('unique_dropoff_locations', 0), 0),
+        'Daily Average': f"{insights.get('daily_average', 0):.1f} trips/day"
+    }
+
+def validate_data(data: pd.DataFrame) -> Tuple[bool, List[str]]:
+    """Validate data quality and return issues found."""
+    issues = []
+    
+    required_columns = ['Trip ID', 'Total Passengers', 'Trip Date and Time']
+    missing_columns = [col for col in required_columns if col not in data.columns]
+    if missing_columns:
+        issues.append(f"Missing required columns: {', '.join(missing_columns)}")
+    
+    if len(data) == 0:
+        issues.append("Dataset is empty")
+        return False, issues
+    
+    if 'Total Passengers' in data.columns:
+        invalid_passengers = data[
+            (data['Total Passengers'] < 1) | 
+            (data['Total Passengers'] > 20) | 
+            (data['Total Passengers'].isna())
+        ]
+        if len(invalid_passengers) > 0:
+            issues.append(f"Found {len(invalid_passengers)} trips with invalid passenger counts")
+    
+    if 'Trip Date and Time' in data.columns:
+        invalid_dates = 0
+        for date_str in data['Trip Date and Time'].dropna():
+            if parse_date_string(str(date_str)) is None:
+                invalid_dates += 1
+        if invalid_dates > 0:
+            issues.append(f"Found {invalid_dates} trips with invalid date formats")
+    
+    if 'Trip ID' in data.columns:
+        duplicates = data['Trip ID'].duplicated().sum()
+        if duplicates > 0:
+            issues.append(f"Found {duplicates} duplicate trip IDs")
+    
+    return len(issues) == 0, issues
+
+def create_export_data(data: pd.DataFrame, insights: Dict[str, Any], format_type: str = 'csv') -> Any:
+    """Create data for export in specified format."""
+    if format_type == 'csv':
+        return data.to_csv(index=False)
+    
+    elif format_type == 'json':
+        export_data = {
+            'metadata': {
+                'export_date': datetime.now().isoformat(),
+                'total_records': len(data),
+                'insights': insights
+            },
+            'data': data.to_dict('records')
+        }
+        return export_data
+    
+    elif format_type == 'summary':
+        summary = create_summary_stats(data)
+        return summary
+    
+    else:
+        raise ValueError(f"Unsupported export format: {format_type}")
+
+def search_locations(query: str, locations: List[str], max_results: int = 5) -> List[str]:
+    """Search for locations matching a query."""
+    query_lower = query.lower()
+    matches = []
+    
+    for location in locations:
+        if query_lower == location.lower():
+            matches.append(location)
+    
+    for location in locations:
+        if query_lower in location.lower() and location not in matches:
+            matches.append(location)
+    
+    query_words = query_lower.split()
+    for location in locations:
+        location_lower = location.lower()
+        if (any(word in location_lower for word in query_words) and 
+            location not in matches):
+            matches.append(location)
+    
+    return matches[:max_results]
+
+def get_color_palette(num_colors: int) -> List[str]:
+    """Get a color palette for visualizations."""
+    base_colors = [
+        '#667eea', '#764ba2', '#f093fb', '#f5576c',
+        '#4facfe', '#00f2fe', '#43e97b', '#38f9d7',
+        '#ffecd2', '#fcb69f', '#a8edea', '#fed6e3'
+    ]
+    
+    if num_colors <= len(base_colors):
+        return base_colors[:num_colors]
+    
+    import colorsys
+    additional_colors = []
+    for i in range(num_colors - len(base_colors)):
+        hue = (i * 0.618033988749895) % 1
+        rgb = colorsys.hsv_to_rgb(hue, 0.7, 0.9)
+        hex_color = '#%02x%02x%02x' % tuple(int(c * 255) for c in rgb)
+        additional_colors.append(hex_color)
+    
+    return base_colors + additional_colors

visualizations.py

@@ -0,0 +1,588 @@
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import pandas as pd
+from typing import Dict, Any
+from data_processor import DataProcessor
+
+def create_visualizations(data_processor: DataProcessor) -> Dict[str, Any]:
+    """
+    Create all visualizations for the Fetii dashboard.
+    Compatible with both Streamlit and Gradio interfaces.
+    """
+    insights = data_processor.get_quick_insights()
+    df = data_processor.df
+    
+    visualizations = {}
+    
+    # Core visualizations - optimized for Gradio display
+    visualizations['hourly_distribution'] = create_hourly_chart(insights['hourly_distribution'])
+    visualizations['group_size_distribution'] = create_group_size_chart(insights['group_size_distribution'])
+    visualizations['popular_locations'] = create_locations_chart(insights['top_pickups'])
+    
+    # Advanced visualizations
+    visualizations['time_heatmap'] = create_time_heatmap(df)
+    visualizations['daily_volume'] = create_daily_volume_chart(df)
+    visualizations['trip_distance_analysis'] = create_distance_analysis(df)
+    visualizations['location_comparison'] = create_location_comparison(df)
+    visualizations['peak_patterns'] = create_peak_patterns(df)
+    
+    return visualizations
+
+def create_hourly_chart(hourly_data: Dict[int, int]) -> go.Figure:
+    """Create modern hourly distribution chart."""
+    hours = sorted(hourly_data.keys())
+    counts = [hourly_data[hour] for hour in hours]
+    
+    # Create hour labels
+    hour_labels = []
+    for hour in hours:
+        if hour == 0:
+            hour_labels.append("12 AM")
+        elif hour < 12:
+            hour_labels.append(f"{hour} AM")
+        elif hour == 12:
+            hour_labels.append("12 PM")
+        else:
+            hour_labels.append(f"{hour-12} PM")
+    
+    fig = go.Figure()
+    
+    # Create modern gradient colors based on intensity
+    max_count = max(counts)
+    colors = []
+    for count in counts:
+        intensity = count / max_count
+        if intensity > 0.8:
+            colors.append('#667eea')  # Primary gradient start
+        elif intensity > 0.6:
+            colors.append('#764ba2')  # Primary gradient end
+        elif intensity > 0.4:
+            colors.append('#f093fb')  # Secondary gradient start
+        elif intensity > 0.2:
+            colors.append('#4facfe')  # Success gradient
+        else:
+            colors.append('#9ca3af')  # Gray for low activity
+    
+    fig.add_trace(go.Bar(
+        x=hour_labels,
+        y=counts,
+        marker=dict(
+            color=colors,
+            line=dict(color='rgba(255,255,255,0.8)', width=1)
+        ),
+        name='Trips',
+        hovertemplate='<b>%{x}</b><br>Trips: %{y}<extra></extra>',
+        text=counts,
+        textposition='outside',
+        textfont=dict(color='#374151', size=10, family='Inter')
+    ))
+    
+    fig.update_layout(
+        title={
+            'text': 'Trip Distribution by Hour',
+            'x': 0.5,
+            'font': {'size': 16, 'color': '#1f2937', 'family': 'Inter'}
+        },
+        xaxis_title='Hour of Day',
+        yaxis_title='Number of Trips',
+        plot_bgcolor='rgba(0,0,0,0)',
+        paper_bgcolor='rgba(0,0,0,0)',
+        font={'color': '#374151', 'family': 'Inter'},
+        height=280,
+        margin=dict(t=50, b=40, l=40, r=40),
+        xaxis=dict(
+            showgrid=True,
+            gridwidth=1,
+            gridcolor='rgba(156, 163, 175, 0.2)',
+            showline=True,
+            linecolor='rgba(156, 163, 175, 0.3)'
+        ),
+        yaxis=dict(
+            showgrid=True,
+            gridwidth=1,
+            gridcolor='rgba(156, 163, 175, 0.2)',
+            showline=True,
+            linecolor='rgba(156, 163, 175, 0.3)'
+        )
+    )
+    
+    return fig
+
+def create_group_size_chart(group_data: Dict[int, int]) -> go.Figure:
+    """Create modern group size distribution chart."""
+    sizes = list(group_data.keys())
+    counts = list(group_data.values())
+    
+    # Enhanced modern color palette with gradients
+    colors = [
+        '#667eea', '#764ba2', '#f093fb', '#f5576c',
+        '#4facfe', '#00f2fe', '#43e97b', '#38f9d7',
+        '#fa709a', '#fee140', '#a8edea', '#fed6e3'
+    ]
+    
+    fig = go.Figure()
+    
+    fig.add_trace(go.Pie(
+        labels=[f"{size} passengers" for size in sizes],
+        values=counts,
+        marker=dict(
+            colors=colors[:len(sizes)],
+            line=dict(color='white', width=2)
+        ),
+        hovertemplate='<b>%{label}</b><br>Trips: %{value}<br>Percentage: %{percent}<extra></extra>',
+        textinfo='label+percent',
+        textposition='auto',
+        textfont=dict(color='white', size=11, family='Inter'),
+        hole=0.4
+    ))
+    
+    fig.update_layout(
+        title={
+            'text': 'Group Size Distribution',
+            'x': 0.5,
+            'font': {'size': 16, 'color': '#1f2937', 'family': 'Inter'}
+        },
+        plot_bgcolor='rgba(0,0,0,0)',
+        paper_bgcolor='rgba(0,0,0,0)',
+        font={'color': '#374151', 'family': 'Inter'},
+        height=280,
+        margin=dict(t=50, b=40, l=40, r=40),
+        showlegend=False
+    )
+    
+    return fig
+
+def create_locations_chart(pickup_data: list) -> go.Figure:
+    """Create modern popular locations chart."""
+    locations = [item[0] for item in pickup_data[:8]]
+    counts = [item[1] for item in pickup_data[:8]]
+    
+    # Truncate long location names
+    truncated_locations = []
+    for loc in locations:
+        if len(loc) > 20:
+            truncated_locations.append(loc[:17] + "...")
+        else:
+            truncated_locations.append(loc)
+    
+    fig = go.Figure()
+    
+    # Enhanced gradient colors with modern palette
+    max_count = max(counts)
+    base_colors = ['#667eea', '#764ba2', '#f093fb', '#f5576c', '#4facfe', '#00f2fe', '#43e97b', '#38f9d7']
+    colors = []
+    for i, count in enumerate(counts):
+        base_color = base_colors[i % len(base_colors)]
+        # Convert hex to rgba with opacity based on intensity
+        hex_color = base_color.lstrip('#')
+        rgb = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+        intensity = count / max_count
+        colors.append(f'rgba({rgb[0]}, {rgb[1]}, {rgb[2]}, {0.6 + intensity * 0.4})')
+    
+    fig.add_trace(go.Bar(
+        x=counts,
+        y=truncated_locations,
+        orientation='h',
+        marker=dict(
+            color=colors,
+            line=dict(color='rgba(255,255,255,0.8)', width=1),
+            cornerradius=4
+        ),
+        hovertemplate='<b>%{customdata}</b><br>Pickups: %{x}<extra></extra>',
+        customdata=locations,
+        text=counts,
+        textposition='outside',
+        textfont=dict(color='#374151', size=10, family='Inter')
+    ))
+    
+    fig.update_layout(
+        title={
+            'text': 'Top Pickup Locations',
+            'x': 0.5,
+            'font': {'size': 16, 'color': '#1f2937', 'family': 'Inter'}
+        },
+        xaxis_title='Number of Pickups',
+        yaxis_title='',
+        plot_bgcolor='rgba(0,0,0,0)',
+        paper_bgcolor='rgba(0,0,0,0)',
+        font={'color': '#374151', 'family': 'Inter'},
+        height=280,
+        margin=dict(t=50, b=40, l=120, r=40),
+        yaxis=dict(
+            autorange="reversed",
+            showline=True,
+            linecolor='rgba(156, 163, 175, 0.3)'
+        ),
+        xaxis=dict(
+            showgrid=True,
+            gridwidth=1,
+            gridcolor='rgba(156, 163, 175, 0.2)',
+            showline=True,
+            linecolor='rgba(156, 163, 175, 0.3)'
+        )
+    )
+    
+    return fig
+
+def create_time_heatmap(df: pd.DataFrame) -> go.Figure:
+    """Create advanced time-based heatmap."""
+    df_copy = df.copy()
+    df_copy['day_num'] = df_copy['datetime'].dt.dayofweek
+    df_copy['day_name'] = df_copy['datetime'].dt.day_name()
+    
+    heatmap_data = df_copy.groupby(['day_num', 'hour']).size().reset_index(name='trips')
+    heatmap_pivot = heatmap_data.pivot(index='day_num', columns='hour', values='trips').fillna(0)
+    
+    day_names = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
+    
+    hour_labels = []
+    for hour in range(24):
+        if hour == 0:
+            hour_labels.append("12 AM")
+        elif hour < 12:
+            hour_labels.append(f"{hour} AM")
+        elif hour == 12:
+            hour_labels.append("12 PM")
+        else:
+            hour_labels.append(f"{hour-12} PM")
+    
+    fig = go.Figure()
+    
+    fig.add_trace(go.Heatmap(
+        z=heatmap_pivot.values,
+        x=hour_labels,
+        y=day_names,
+        colorscale=[
+            [0, '#f8fafc'],
+            [0.2, '#e2e8f0'],
+            [0.4, '#94a3b8'],
+            [0.6, '#3b82f6'],
+            [0.8, '#1d4ed8'],
+            [1, '#1e40af']
+        ],
+        hovertemplate='<b>%{y}</b><br>%{x}<br>Trips: %{z}<extra></extra>',
+        colorbar=dict(
+            title=dict(text="Trips", font=dict(family='Inter', color='#374151')),
+            tickfont=dict(family='Inter', color='#374151')
+        )
+    ))
+    
+    fig.update_layout(
+        title={
+            'text': 'Trip Patterns by Day & Hour',
+            'x': 0.5,
+            'font': {'size': 16, 'color': '#1f2937', 'family': 'Inter', 'weight': 700}
+        },
+        xaxis_title='Hour of Day',
+        yaxis_title='Day of Week',
+        plot_bgcolor='rgba(248, 250, 252, 0.5)',
+        paper_bgcolor='rgba(0,0,0,0)',
+        font={'color': '#374151', 'family': 'Inter'},
+        height=350,
+        margin=dict(t=50, b=40, l=100, r=40),
+        xaxis=dict(
+            showgrid=True,
+            gridwidth=1,
+            gridcolor='rgba(156, 163, 175, 0.3)',
+            tickfont=dict(size=11)
+        ),
+        yaxis=dict(
+            showgrid=True,
+            gridwidth=1,
+            gridcolor='rgba(156, 163, 175, 0.3)',
+            tickfont=dict(size=11)
+        )
+    )
+    
+    return fig
+
+def create_daily_volume_chart(df: pd.DataFrame) -> go.Figure:
+    """Create modern daily trip volume chart."""
+    daily_trips = df.groupby('date').size().reset_index(name='trips')
+    daily_trips['date'] = pd.to_datetime(daily_trips['date'])
+    daily_trips = daily_trips.sort_values('date')
+    
+    fig = go.Figure()
+    
+    # Main line
+    fig.add_trace(go.Scatter(
+        x=daily_trips['date'],
+        y=daily_trips['trips'],
+        mode='lines+markers',
+        line=dict(color='#3b82f6', width=3, shape='spline'),
+        marker=dict(size=6, color='#1d4ed8', line=dict(color='white', width=1)),
+        fill='tonexty',
+        fillcolor='rgba(59, 130, 246, 0.1)',
+        hovertemplate='<b>%{x}</b><br>Trips: %{y}<extra></extra>',
+        name='Daily Trips'
+    ))
+    
+    # Add trend line
+    if len(daily_trips) > 1:
+        z = np.polyfit(range(len(daily_trips)), daily_trips['trips'], 1)
+        p = np.poly1d(z)
+        fig.add_trace(go.Scatter(
+            x=daily_trips['date'],
+            y=p(range(len(daily_trips))),
+            mode='lines',
+            line=dict(color='#ef4444', width=2, dash='dot'),
+            name='Trend',
+            hovertemplate='Trend: %{y:.0f}<extra></extra>'
+        ))
+    
+    fig.update_layout(
+        title={
+            'text': 'Daily Trip Volume',
+            'x': 0.5,
+            'font': {'size': 18, 'color': '#1f2937', 'family': 'Inter'}
+        },
+        xaxis_title='Date',
+        yaxis_title='Number of Trips',
+        plot_bgcolor='rgba(0,0,0,0)',
+        paper_bgcolor='rgba(0,0,0,0)',
+        font={'color': '#374151', 'family': 'Inter'},
+        height=320,
+        margin=dict(t=60, b=50, l=50, r=50),
+        showlegend=True,
+        legend=dict(
+            x=0.02,
+            y=0.98,
+            bgcolor='rgba(255,255,255,0.9)',
+            bordercolor='rgba(156, 163, 175, 0.3)',
+            borderwidth=1
+        ),
+        xaxis=dict(
+            showgrid=True,
+            gridwidth=1,
+            gridcolor='rgba(156, 163, 175, 0.2)'
+        ),
+        yaxis=dict(
+            showgrid=True,
+            gridwidth=1,
+            gridcolor='rgba(156, 163, 175, 0.2)'
+        )
+    )
+    
+    return fig
+
+def create_distance_analysis(df: pd.DataFrame) -> go.Figure:
+    """Create group size vs trip distance analysis."""
+    if not all(col in df.columns for col in ['Pick Up Latitude', 'Pick Up Longitude', 'Drop Off Latitude', 'Drop Off Longitude']):
+        return create_placeholder_chart("Distance Analysis", "Location data not available")
+    
+    df_copy = df.copy()
+    df_copy['distance'] = np.sqrt(
+        (df_copy['Drop Off Latitude'] - df_copy['Pick Up Latitude'])**2 + 
+        (df_copy['Drop Off Longitude'] - df_copy['Pick Up Longitude'])**2
+    ) * 111  # Approximate km conversion
+    
+    distance_by_group = df_copy.groupby('Total Passengers')['distance'].agg(['mean', 'std', 'count']).reset_index()
+    distance_by_group = distance_by_group[distance_by_group['count'] >= 3]  # Filter groups with few trips
+    
+    fig = go.Figure()
+    
+    fig.add_trace(go.Scatter(
+        x=distance_by_group['Total Passengers'],
+        y=distance_by_group['mean'],
+        mode='markers+lines',
+        marker=dict(
+            size=distance_by_group['count']/5,
+            color=distance_by_group['mean'],
+            colorscale='Viridis',
+            showscale=True,
+            colorbar=dict(title="Avg Distance (km)"),
+            line=dict(color='white', width=1)
+        ),
+        line=dict(color='#3b82f6', width=2),
+        error_y=dict(
+            type='data',
+            array=distance_by_group['std'],
+            color='rgba(59, 130, 246, 0.3)'
+        ),
+        hovertemplate='<b>Group Size: %{x}</b><br>Avg Distance: %{y:.2f} km<br>Trips: %{marker.size:.0f}<extra></extra>',
+        name='Average Distance'
+    ))
+    
+    fig.update_layout(
+        title={
+            'text': 'Average Trip Distance by Group Size',
+            'x': 0.5,
+            'font': {'size': 18, 'color': '#1f2937', 'family': 'Inter'}
+        },
+        xaxis_title='Group Size (Passengers)',
+        yaxis_title='Average Distance (km)',
+        plot_bgcolor='rgba(0,0,0,0)',
+        paper_bgcolor='rgba(0,0,0,0)',
+        font={'color': '#374151', 'family': 'Inter'},
+        height=400,
+        margin=dict(t=60, b=50, l=50, r=50)
+    )
+    
+    return fig
+
+def create_location_comparison(df: pd.DataFrame) -> go.Figure:
+    """Create pickup vs dropoff location comparison."""
+    pickup_counts = df['pickup_main'].value_counts().head(10)
+    dropoff_counts = df['dropoff_main'].value_counts().head(10)
+    
+    # Get common locations
+    common_locations = list(set(pickup_counts.index) & set(dropoff_counts.index))
+    if not common_locations:
+        # If no common locations, take top 5 from each
+        all_locations = list(set(list(pickup_counts.index[:5]) + list(dropoff_counts.index[:5])))
+    else:
+        all_locations = common_locations[:8]
+    
+    pickup_values = [pickup_counts.get(loc, 0) for loc in all_locations]
+    dropoff_values = [dropoff_counts.get(loc, 0) for loc in all_locations]
+    
+    # Truncate location names
+    truncated_locations = []
+    for loc in all_locations:
+        if len(loc) > 15:
+            truncated_locations.append(loc[:12] + "...")
+        else:
+            truncated_locations.append(loc)
+    
+    fig = go.Figure()
+    
+    fig.add_trace(go.Bar(
+        name='Pickups',
+        x=truncated_locations,
+        y=pickup_values,
+        marker_color='#3b82f6',
+        hovertemplate='<b>%{x}</b><br>Pickups: %{y}<extra></extra>',
+        customdata=all_locations
+    ))
+    
+    fig.add_trace(go.Bar(
+        name='Drop-offs',
+        x=truncated_locations,
+        y=dropoff_values,
+        marker_color='#10b981',
+        hovertemplate='<b>%{x}</b><br>Drop-offs: %{y}<extra></extra>',
+        customdata=all_locations
+    ))
+    
+    fig.update_layout(
+        title={
+            'text': 'Pickup vs Drop-off Comparison',
+            'x': 0.5,
+            'font': {'size': 18, 'color': '#1f2937', 'family': 'Inter'}
+        },
+        xaxis_title='Locations',
+        yaxis_title='Number of Trips',
+        plot_bgcolor='rgba(0,0,0,0)',
+        paper_bgcolor='rgba(0,0,0,0)',
+        font={'color': '#374151', 'family': 'Inter'},
+        height=400,
+        margin=dict(t=60, b=50, l=50, r=50),
+        barmode='group',
+        legend=dict(
+            x=0.02,
+            y=0.98,
+            bgcolor='rgba(255,255,255,0.9)',
+            bordercolor='rgba(156, 163, 175, 0.3)',
+            borderwidth=1
+        )
+    )
+    
+    return fig
+
+def create_peak_patterns(df: pd.DataFrame) -> go.Figure:
+    """Create peak hours analysis by group size category."""
+    df_copy = df.copy()
+    df_copy['group_category'] = df_copy['Total Passengers'].apply(
+        lambda x: 'Small (1-4)' if x <= 4 else
+                  'Medium (5-8)' if x <= 8 else
+                  'Large (9-12)' if x <= 12 else
+                  'Extra Large (13+)'
+    )
+    
+    hourly_by_group = df_copy.groupby(['group_category', 'hour']).size().reset_index(name='trips')
+    
+    fig = go.Figure()
+    
+    colors = ['#3b82f6', '#10b981', '#f59e0b', '#ef4444']
+    categories = ['Small (1-4)', 'Medium (5-8)', 'Large (9-12)', 'Extra Large (13+)']
+    
+    for i, category in enumerate(categories):
+        data = hourly_by_group[hourly_by_group['group_category'] == category]
+        if not data.empty:
+            fig.add_trace(go.Scatter(
+                x=data['hour'],
+                y=data['trips'],
+                mode='lines+markers',
+                name=category,
+                line=dict(color=colors[i], width=3, shape='spline'),
+                marker=dict(size=6, line=dict(color='white', width=1)),
+                hovertemplate='<b>%{fullData.name}</b><br>Hour: %{x}<br>Trips: %{y}<extra></extra>'
+            ))
+    
+    fig.update_layout(
+        title={
+            'text': 'Peak Hours by Group Size Category',
+            'x': 0.5,
+            'font': {'size': 18, 'color': '#1f2937', 'family': 'Inter'}
+        },
+        xaxis_title='Hour of Day',
+        yaxis_title='Number of Trips',
+        plot_bgcolor='rgba(0,0,0,0)',
+        paper_bgcolor='rgba(0,0,0,0)',
+        font={'color': '#374151', 'family': 'Inter'},
+        height=400,
+        margin=dict(t=60, b=50, l=50, r=50),
+        legend=dict(
+            x=0.02,
+            y=0.98,
+            bgcolor='rgba(255,255,255,0.9)',
+            bordercolor='rgba(156, 163, 175, 0.3)',
+            borderwidth=1
+        ),
+        xaxis=dict(
+            showgrid=True,
+            gridwidth=1,
+            gridcolor='rgba(156, 163, 175, 0.2)',
+            tickvals=list(range(0, 24, 2)),
+            ticktext=[f"{h}:00" for h in range(0, 24, 2)]
+        ),
+        yaxis=dict(
+            showgrid=True,
+            gridwidth=1,
+            gridcolor='rgba(156, 163, 175, 0.2)'
+        )
+    )
+    
+    return fig
+
+def create_placeholder_chart(title: str, message: str) -> go.Figure:
+    """Create a placeholder chart when data is not available."""
+    fig = go.Figure()
+    
+    fig.add_annotation(
+        text=message,
+        x=0.5,
+        y=0.5,
+        xref="paper",
+        yref="paper",
+        showarrow=False,
+        font=dict(size=16, color='#6b7280', family='Inter')
+    )
+    
+    fig.update_layout(
+        title={
+            'text': title,
+            'x': 0.5,
+            'font': {'size': 18, 'color': '#1f2937', 'family': 'Inter'}
+        },
+        plot_bgcolor='rgba(0,0,0,0)',
+        paper_bgcolor='rgba(0,0,0,0)',
+        height=300,
+        margin=dict(t=60, b=50, l=50, r=50),
+        xaxis=dict(showgrid=False, showticklabels=False),
+        yaxis=dict(showgrid=False, showticklabels=False)
+    )
+    
+    return fig