app.py

from flask import Flask, render_template, jsonify, request
from flask_cors import CORS
import csv
import json
from lru_cache import LRUCache
from lfu_cache import LFUCache

app = Flask(__name__)
CORS(app)

# Configuration
DEFAULT_CACHE_SIZE_MB = 2

def load_access_log(filepath):
    """Load access log from CSV file"""
    with open(filepath, 'r') as f:
        reader = csv.DictReader(f)
        return [row for row in reader]

def simulate_cache_step_by_step(algorithm_class, access_log, cache_size_kb):
    """Simulate cache with step-by-step results"""
    cache = algorithm_class(cache_size_kb)
    results = []
    total_requests = len(access_log)
    total_hits = 0
    total_bandwidth_saved = 0
    total_load_time = 0
    
    for i, entry in enumerate(access_log):
        page = entry['Page']
        size = int(entry['Size'])
        load_time = int(entry['LoadTime'])
        
        # Get cache state before request
        cache_state_before = {
            'pages': list(cache.cache.keys()) if hasattr(cache, 'cache') else list(cache.cache.keys()),
            'sizes': [cache.cache[p] for p in cache.cache] if hasattr(cache, 'cache') else [cache.cache[p] for p in cache.cache],
            'frequencies': [cache.freq[p] for p in cache.cache] if hasattr(cache, 'freq') else [0] * len(cache.cache)
        }
        
        # Make request
        hit = cache.request_page(page, size)
        
        # Update statistics
        if hit:
            total_hits += 1
            total_bandwidth_saved += size
            total_load_time += load_time * 0.2  # cached load time (20% of original)
        else:
            total_load_time += load_time  # full load
        
        # Get cache state after request
        cache_state_after = {
            'pages': list(cache.cache.keys()) if hasattr(cache, 'cache') else list(cache.cache.keys()),
            'sizes': [cache.cache[p] for p in cache.cache] if hasattr(cache, 'cache') else [cache.cache[p] for p in cache.cache],
            'frequencies': [cache.freq[p] for p in cache.cache] if hasattr(cache, 'freq') else [0] * len(cache.cache)
        }
        
        # Calculate current statistics
        current_hit_ratio = (total_hits / (i + 1)) * 100
        current_avg_load_time = total_load_time / (i + 1)
        
        results.append({
            'step': i + 1,
            'page_requested': page,
            'page_size': size,
            'load_time': load_time,
            'hit': hit,
            'cache_state_before': cache_state_before,
            'cache_state_after': cache_state_after,
            'current_hit_ratio': current_hit_ratio,
            'current_bandwidth_saved': total_bandwidth_saved,
            'current_avg_load_time': current_avg_load_time,
            'total_requests': total_requests,
            'total_hits': total_hits
        })
    
    final_hit_ratio = (total_hits / total_requests) * 100
    final_avg_load_time = total_load_time / total_requests
    
    return {
        'steps': results,
        'final_hit_ratio': final_hit_ratio,
        'final_bandwidth_saved': total_bandwidth_saved,
        'final_avg_load_time': final_avg_load_time,
        'total_requests': total_requests,
        'total_hits': total_hits
    }

@app.route('/')
def index():
    """Serve the main HTML page"""
    return render_template('index.html')

@app.route('/api/simulate', methods=['POST'])
def simulate():
    """API endpoint for cache simulation"""
    data = request.json
    algorithm = data.get('algorithm', 'LRU')
    cache_size_mb = data.get('cacheSize', DEFAULT_CACHE_SIZE_MB)
    
    access_log = load_access_log("data/sample_access_log.csv")
    cache_size_kb = cache_size_mb * 1024
    
    if algorithm == 'LRU':
        results = simulate_cache_step_by_step(LRUCache, access_log, cache_size_kb)
    elif algorithm == 'LFU':
        results = simulate_cache_step_by_step(LFUCache, access_log, cache_size_kb)
    else:
        return jsonify({'error': 'Invalid algorithm'}), 400
    
    return jsonify(results)

@app.route('/api/compare', methods=['POST'])
def compare_algorithms():
    """API endpoint for comparing LRU and LFU algorithms"""
    data = request.json
    cache_size_mb = data.get('cacheSize', DEFAULT_CACHE_SIZE_MB)
    
    access_log = load_access_log("data/sample_access_log.csv")
    cache_size_kb = cache_size_mb * 1024
    
    lru_results = simulate_cache_step_by_step(LRUCache, access_log, cache_size_kb)
    lfu_results = simulate_cache_step_by_step(LFUCache, access_log, cache_size_kb)
    
    comparison = {
        'lru': {
            'final_hit_ratio': lru_results['final_hit_ratio'],
            'final_bandwidth_saved': lru_results['final_bandwidth_saved'],
            'final_avg_load_time': lru_results['final_avg_load_time']
        },
        'lfu': {
            'final_hit_ratio': lfu_results['final_hit_ratio'],
            'final_bandwidth_saved': lfu_results['final_bandwidth_saved'],
            'final_avg_load_time': lfu_results['final_avg_load_time']
        }
    }
    
    return jsonify(comparison)

@app.route('/api/access-log')
def get_access_log():
    """API endpoint to get access log data"""
    access_log = load_access_log("data/sample_access_log.csv")
    return jsonify(access_log)

if __name__ == '__main__':
    app.run(debug=True)