The FromCache mapper option below represent

    the "public" method of configuring this state upon the CachingQuery.

    """

    def __init__(self, manager, *args, **kw):

        self.cache_manager = manager

        Query.__init__(self, *args, **kw)

    def __iter__(self):

        """override __iter__ to pull results from Beaker

           if particular attributes have been configured.

           Note that this approach does *not* detach the loaded objects from

           the current session. If the cache backend is an in-process cache

           (like "memory") and lives beyond the scope of the current session's

           transaction, those objects may be expired. The method here can be

           modified to first expunge() each loaded item from the current

           session before returning the list of items, so that the items

           in the cache are not the same ones in the current Session.

        """

        if hasattr(self, '_cache_parameters'):

            return self.get_value(createfunc=lambda:

                                  list(Query.__iter__(self)))

        else:

            return Query.__iter__(self)

    def invalidate(self):

        """Invalidate the value represented by this Query."""

        cache, cache_key = _get_cache_parameters(self)

        cache.remove(cache_key)

    def get_value(self, merge=True, createfunc=None):

        """Return the value from the cache for this query.

        Raise KeyError if no value present and no

        createfunc specified.

        """

        cache, cache_key = _get_cache_parameters(self)

        ret = cache.get_value(cache_key, createfunc=createfunc)

        if merge:

            ret = self.merge_result(ret, load=False)

        return ret

def query_callable(manager, query_cls=CachingQuery):

    def query(*arg, **kw):

        return query_cls(manager, *arg, **kw)

    return query

def get_cache_region(name, region):

    if region not in beaker.cache.cache_regions:

        raise BeakerException('Cache region `%s` not configured '

            'Check if proper cache settings are in the .ini files' % region)

    kw = beaker.cache.cache_regions[region]

    return beaker.cache.Cache._get_cache(name, kw)

def _get_cache_parameters(query):

    """For a query with cache_region and cache_namespace configured,

    return the corresponding Cache instance and cache key, based

    on this query's current criterion and parameter values.

    """

    if not hasattr(query, '_cache_parameters'):

        raise ValueError("This Query does not have caching "

                         "parameters configured.")

    region, namespace, cache_key = query._cache_parameters

    namespace = _namespace_from_query(namespace, query)

    if cache_key is None:

        # cache key - the value arguments from this query's parameters.

        args = _params_from_query(query)

        args.append(query._limit)

        args.append(query._offset)

        cache_key = " ".join(str(x) for x in args)

    if cache_key is None:

        raise Exception('Cache key cannot be None')

    # get cache

    #cache = query.cache_manager.get_cache_region(namespace, region)

    cache = get_cache_region(namespace, region)

    # optional - hash the cache_key too for consistent length

    # import uuid

    # cache_key= str(uuid.uuid5(uuid.NAMESPACE_DNS, cache_key))

    return cache, cache_key