Python StrictRedis.zrevrank方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zrevrank [as 别名]
class GistStorage(object):
    SUPER_KEY = 'live'

    def __init__(self, host, port, password):
        self.client = StrictRedis(host=host, port=port, password=password)

    def upvote(self, gist_id):
        return self.client.zincrby(self.SUPER_KEY, gist_id, 1)

    def get_rank(self, gist_id):
        return self.client.zrevrank(self.SUPER_KEY, gist_id)

    def get_points(self, gist_id):
        return self.client.zscore(self.SUPER_KEY, gist_id)

    def get_rank_list(self, offset=0, num=-1):
        return self.client.zrevrange(self.SUPER_KEY, offset, num, withscores=True, score_cast_func=float)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zrevrank [as 别名]

#.........这里部分代码省略.........

    def set_metric(self, user, value, ts=None):
        """
        Set a new peak value for this user, e.g. high score
        """
        if self.timed_ties:
            value = self._encode_value_with_time(value, ts)

        for r in self.ranges:
            key = self._board_key(r)
            self.r.zadd(key, value, user)
            if r != self.RANGE_ALLTIME:
                self.r.expire(key, r.expiration)

    def inc_metric(self, user, value, ts=None):
        """
        Increment the current value for this user, e.g. total earned
        """
        if ts:
            log.warn('inc_metric: timestamps not supported yet')

        for r in self.ranges:
            key = self._board_key(r)
            self.r.zincrby(key, user, value)
            if r != self.RANGE_ALLTIME:
                self.r.expire(key, r.expiration)

    def leaders(self, range, limit=-1, offset=0, id=None, slots_ago=0):
        """
        Retrieve a list of global leaders.

        :param range: The TimeRange to query
        :param limit: Maximum number of entries to return
        :param offset: Rank to start at, ignored if id is provided
        :param id: Member to center the range of entries around, i.e. "leaders near me"
        :param slots_ago: number of time slots prior, e.g. 1 for yesterday, last week, etc.
        """
        key = self._board_key(range, slots_ago)

        if id:
            if self.reverse:
                rank = self.r.zrevrank(key, id)
            else:
                rank = self.r.zrank(key, id)
            log.debug('uid: %r, rank: %r', id, rank)
            if rank is None:
                log.warn('specified id %r not found in board %r', id, key)
                rank = 0
            offset = max(0, rank - int(round(limit / 2.0)) + 1)
            end = rank + limit / 2 if limit > 0 else -1
        else:
            end = offset + limit - 1 if limit > 0 else -1

        total, with_ranks = self._leaders_with_ranks(key, offset, end)
        start, end = range.date_range(slots_ago)
        return Leaders(total, start, end, with_ranks)

    def leaders_friends_list(self, friends, range, limit=-1, offset=0, slots_ago=0):
        """
        retrieve a list of leaders from the given friends list
        """
        # create a temp zset of friends to intersect w/global list
        # todo: allow for caching the friend list via config
        tmpid = self._hashlist(friends)
        friends_key = 'friends_' + tmpid
        pipe = self.r.pipeline()
        for f in friends:
            pipe.zadd(friends_key, 0, f)
        pipe.execute()

        l = self.leaders_friends_key(friends_key, range, limit, offset, slots_ago)
        self.r.delete(friends_key)
        return l

    def leaders_friends_key(self, friends_key, range, limit=-1, offset=0, slots_ago=0):
        """
        Retrieve a list of leaders from the given friends list
        """
        key = self._board_key(range, slots_ago)
        inter_key = 'inter_' + friends_key + "_" + key

        self.r.zinterstore(inter_key, [key, friends_key])
        end = offset + limit if limit > 0 else -1

        total, with_ranks = self._leaders_with_ranks(inter_key, offset, end)

        self.r.delete(inter_key)
        start, end = range.date_range(slots_ago)
        return Leaders(total, start, end, with_ranks)

    def clear(self, range, slots_ago=0):
        """
        """
        key = self._board_key(range, slots_ago)
        self.r.delete(key)

    def clear_all(self):
        # TODO: track and clear all prior slots
        for range in self.ranges:
            self.clear(range)