SickGear/lib/subliminal/cache.py

# -*- coding: utf-8 -*-
# Copyright 2012 Nicolas Wack <wackou@gmail.com>
#
# This file is part of subliminal.
#
# subliminal is free software; you can redistribute it and/or modify it under
# the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# subliminal is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with subliminal.  If not, see <http://www.gnu.org/licenses/>.
from collections import defaultdict
from functools import wraps
import logging
import os.path
import threading
try:
    import cPickle as pickle
except ImportError:
    import pickle


__all__ = ['Cache', 'cachedmethod']
logger = logging.getLogger("subliminal")


class Cache(object):
    """A Cache object contains cached values for methods. It can have
    separate internal caches, one for each service

    """
    def __init__(self, cache_dir):
        self.cache_dir = cache_dir
        self.cache = defaultdict(dict)
        self.lock = threading.RLock()

    def __del__(self):
        for service_name in self.cache:
            self.save(service_name)

    def cache_location(self, service_name):
        return os.path.join(self.cache_dir, 'subliminal_%s.cache' % service_name)

    def load(self, service_name):
        with self.lock:
            if service_name in self.cache:
                # already loaded
                return

            self.cache[service_name] = defaultdict(dict)
            filename = self.cache_location(service_name)
            logger.debug(u'Cache: loading cache from %s' % filename)
            try:
                self.cache[service_name] = pickle.load(open(filename, 'rb'))
            except IOError:
                logger.info('Cache: Cache file "%s" doesn\'t exist, creating it' % filename)
            except EOFError:
                logger.error('Cache: cache file "%s" is corrupted... Removing it.' % filename)
                os.remove(filename)

    def save(self, service_name):
        filename = self.cache_location(service_name)
        logger.debug(u'Cache: saving cache to %s' % filename)
        with self.lock:
            pickle.dump(self.cache[service_name], open(filename, 'wb'))

    def clear(self, service_name):
        try:
            os.remove(self.cache_location(service_name))
        except OSError:
            pass
        self.cache[service_name] = defaultdict(dict)

    def cached_func_key(self, func, cls=None):
        try:
            cls = func.im_class
        except:
            pass
        return ('%s.%s' % (cls.__module__, cls.__name__), func.__name__)

    def function_cache(self, service_name, func):
        func_key = self.cached_func_key(func)
        return self.cache[service_name][func_key]

    def cache_for(self, service_name, func, args, result):
        # no need to lock here, dict ops are atomic
        self.function_cache(service_name, func)[args] = result

    def cached_value(self, service_name, func, args):
        """Raises KeyError if not found"""
        # no need to lock here, dict ops are atomic
        return self.function_cache(service_name, func)[args]


def cachedmethod(function):
    """Decorator to make a method use the cache.

    .. note::

        This can NOT be used with static functions, it has to be used on
        methods of some class

    """
    @wraps(function)
    def cached(*args):
        c = args[0].config.cache
        service_name = args[0].__class__.__name__
        func_key = c.cached_func_key(function, cls=args[0].__class__)
        func_cache = c.cache[service_name][func_key]

        # we need to remove the first element of args for the key, as it is the
        # instance pointer and we don't want the cache to know which instance
        # called it, it is shared among all instances of the same class
        key = args[1:]

        if key in func_cache:
            result = func_cache[key]
            logger.debug(u'Using cached value for %s(%s), returns: %s' % (func_key, key, result))
            return result

        result = function(*args)

        # note: another thread could have already cached a value in the
        # meantime, but that's ok as we prefer to keep the latest value in
        # the cache
        func_cache[key] = result
        return result
    return cached