cache.py

import logging
from functools import wraps
from hashlib import md5

from memcache import Client

def memoized(side_effect=None):
    side_effect = side_effect or (lambda s, a, k: None)
    
    def _memoized(func):
        @wraps(func)
        def wrapper(self, *args, **kwargs):
            key = repr((args, kwargs))
            val = cache_get(key)
        
            if not val:
                val = func(self, *args, **kwargs)
                cache_set(key, val)
                
            side_effect(self, args, kwargs)
            
            return val
        return wrapper

    return _memoized


def cache_get(key):
    cache = Client(get_data_memcache_servers())
    key_hash = md5(key).hexdigest()
    try:
        value = cache.get(key_hash)
    finally:
        cache.disconnect_all()
    
    if value is None:
        logging.debug('%s: miss' % key_hash, type='cache', key=key, key_hash=key_hash)
    else:
        logging.debug('%s: hit' % key_hash, type='cache', key=key, key_hash=key_hash)
    
    return value

def cache_set(key, value, expiry=0):
    cache = Client(get_data_memcache_servers())

    try:
        cache.set(md5(key).hexdigest(), value, expiry)
    finally:
        cache.disconnect_all()

ui.py

from tornado.web import UIModule
from so1.utils.cache import memoized

class StudentSchedule(BaseUIModule):
    def dependencies(self):
        return [
            HomeworkAssignment,
            ParAwarenessWidget,
            ParticipationWidget
        ]
    
    def css_files(self):
        return [
            'css/jquery.rating-3.13.css',
            'css/student_schedule.css'
        ]
            
    def javascript_files(self):
        return [
            'javascript/jquery.rating-3.13.patched.js'
        ]
    
    @memoized_with_dependencies()
    def render(self, student, schedule_date, user_type):
        from so1.models.skill import Skill
        
        slots = []
        todays_exposures = 0
        for section_slot in student.full_schedule(schedule_date):
            if section_slot.is_so1:
                todays_exposures += 1
            slots.append(section_slot)

        skill_progress = SkillProgress.on_date(student, schedule_date, todays_exposures)
        
        homeroom = student.homeroom()
        
        return self.render_string('tables/student_schedule_table.html', 
                                  slots=slots,
                                  schedule_date=schedule_date,
                                  user_type=user_type,
                                  student=student,
                                  skill_progress=skill_progress,
                                  homeroom=homeroom)


def memoized_with_dependencies():
    return memoized(lambda self, a, kw: self.activate_modules())

class BaseUIModule(UIModule):
    def dependencies(self):
        return []
    
    def activate_modules(self):
        for module_class in self.dependencies():
            name = module_class.__name__
            module = module_class(self.handler)
            self.handler._active_modules[name] = module
            module.activate_modules()