Free At UCD ? Free Food for Students with Real-Time Availability

# AWS Configuration for Free at UCD
import boto3
import psycopg2
from sqlalchemy import create_engine
import streamlit as st

class AWSInfrastructure:
    def __init__(self):
        # EC2 instance configuration
        self.ec2_client = boto3.client('ec2', region_name='eu-west-1')  # Ireland region for UCD
        self.rds_endpoint = os.getenv('RDS_ENDPOINT')
        self.db_engine = create_engine(
            f"postgresql://{os.getenv('DB_USER')}:{os.getenv('DB_PASSWORD')}@{self.rds_endpoint}/freeatucd"
        )
    
    def setup_auto_scaling(self):
        """Configure auto-scaling for traffic spikes during lunch hours"""
        return {
            'min_instances': 1,
            'max_instances': 3,
            'scale_up_threshold': 70,  # CPU percentage
            'scale_down_threshold': 30,
            'target_group_arn': os.getenv('ALB_TARGET_GROUP_ARN')
        }

import cv2
import numpy as np
import pytesseract
from instagram_private_api import Client
import re
from datetime import datetime

class InstagramFoodScraper:
    def __init__(self):
        self.instagram_client = Client(username, password)
        self.food_keywords = [
            'free food', 'pizza', 'sandwiches', 'coffee', 'snacks',
            'giveaway', 'complimentary', 'refreshments', 'lunch'
        ]
        self.location_keywords = [
            'student centre', 'library', 'quad', 'belfield', 
            'newman building', 'science centre', 'lecture theatre'
        ]
    
    def scrape_ucd_societies(self):
        """Scrape Instagram posts from UCD societies for food events"""
        ucd_societies = [
            'ucdsu', 'ucd_dramsoc', 'ucd_lawsoc', 'ucd_comsoc',
            'ucd_engsoc', 'ucd_bizzsoc', 'ucd_medsoc'
        ]
        
        food_events = []
        
        for society in ucd_societies:
            recent_posts = self.get_recent_posts(society, limit=10)
            
            for post in recent_posts:
                # Download image
                image_url = post['image_versions2']['candidates'][0]['url']
                image = self.download_image(image_url)
                
                # Extract text using OCR
                extracted_text = self.extract_text_from_image(image)
                
                # Check for food-related content
                if self.contains_food_keywords(extracted_text):
                    event_details = self.parse_event_details(
                        extracted_text, post['caption']['text']
                    )
                    
                    if event_details:
                        food_events.append(event_details)
        
        return food_events
    
    def extract_text_from_image(self, image):
        """Use OpenCV + Tesseract to extract text from Instagram posts"""
        # Convert to grayscale
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        
        # Apply image preprocessing for better OCR
        # 1. Noise reduction
        denoised = cv2.medianBlur(gray, 5)
        
        # 2. Contrast enhancement
        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
        enhanced = clahe.apply(denoised)
        
        # 3. Threshold for better text recognition
        _, thresh = cv2.threshold(enhanced, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
        
        # Extract text using Tesseract
        custom_config = r'--oem 3 --psm 6'
        extracted_text = pytesseract.image_to_string(thresh, config=custom_config)
        
        return extracted_text.lower()
    
    def parse_event_details(self, ocr_text, caption_text):
        """Parse event details from extracted text"""
        combined_text = f"{ocr_text} {caption_text}".lower()
        
        # Extract time using regex
        time_pattern = r'(\d{1,2}:\d{2}|\d{1,2}pm|\d{1,2}am)'
        time_matches = re.findall(time_pattern, combined_text)
        
        # Extract location
        location = None
        for keyword in self.location_keywords:
            if keyword in combined_text:
                location = keyword
                break
        
        # Extract food type
        food_type = None
        for keyword in self.food_keywords:
            if keyword in combined_text:
                food_type = keyword
                break
        
        if time_matches and location and food_type:
            return {
                'food_type': food_type,
                'location': location,
                'time': time_matches[0],
                'source': 'instagram_scraper',
                'confidence': self.calculate_confidence(combined_text)
            }
        
        return None

# Usage in main application
class FreeAtUCDApp:
    def __init__(self):
        self.scraper = InstagramFoodScraper()
        self.db_connection = self.setup_database()
    
    def run_automated_scraping(self):
        """Run every 30 minutes to find new food events"""
        while True:
            try:
                new_events = self.scraper.scrape_ucd_societies()
                
                for event in new_events:
                    # Verify event doesn't already exist
                    if not self.event_exists(event):
                        self.add_event_to_database(event)
                        self.notify_subscribers(event)
                
                time.sleep(1800)  # Wait 30 minutes
                
            except Exception as e:
                logging.error(f"Scraping error: {e}")
                time.sleep(300)  # Wait 5 minutes on error

PERFORMANCE_METRICS = {
    "daily_sessions": "400-500",
    "peak_concurrent_users": 150,
    "average_session_duration": "3.2 minutes",
    "database_queries_per_day": 25000,
    "instagram_posts_processed": "50-80 per day",
    "automated_events_detected": "5-10 per day",
    "user_retention_rate": "68%",
    "mobile_users_percentage": "85%"
}