Python StrictRedis.zadd方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def zset_score_min_max_example():
    """ Example sorted set with min/max score pagination.
    """
    from uuid import uuid4
    from redis import StrictRedis
    from zato.redis_paginator import ZSetPaginator
    
    conn = StrictRedis()
    key = 'paginator:{}'.format(uuid4().hex)
    
    # 97-114 is 'a' to 'r' in ASCII
    for x in range(1, 18):
        conn.zadd(key, x, chr(96 + x))
        
    p = ZSetPaginator(conn, key, 2, score_min=5, score_max=13)
    
    print(p.count)      # 9
    print(p.num_pages)  # 5
    print(p.page_range) # [1, 2, 3, 4, 5]
    
    page = p.page(3)
    print(page)             # <Page 3 of 5>
    print(page.object_list) # ['i', 'j']
        
    conn.delete(key)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def zset_example():
    """ Example sorted set pagination.
    """
    from uuid import uuid4
    from redis import StrictRedis
    from zato.redis_paginator import ZSetPaginator
    
    conn = StrictRedis()
    key = 'paginator:{}'.format(uuid4().hex)
    
    # 97-114 is 'a' to 'r' in ASCII
    for x in range(1, 18):
        conn.zadd(key, x, chr(96 + x))
        
    p = ZSetPaginator(conn, key, 6)
    
    print(p.count)      # 17
    print(p.num_pages)  # 3
    print(p.page_range) # [1, 2, 3]
    
    page = p.page(3)
    print(page)             # <Page 3 of 3>
    print(page.object_list) # ['m', 'n', 'o', 'p', 'q']
        
    conn.delete(key)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def push(payload, ttl, priority, redis_host='localhost', redis_port=6379):
    """
    Push a package to the queue
    """
    connection = StrictRedis(host=redis_host, port=redis_port)
    package = create_package_with_ttl(
        payload=payload, ttl=float(ttl), score=float(priority))
    connection.zadd(DEFAULT_REDIS_KEY, package.score, package.raw_entry)
    connection.publish(DEFAULT_REDIS_KEY, 'new_message')

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
class WordList:
  def __init__(self):
    self.conn = Redis()
    self.CACHE_SIZE = 50
    self.CACHE_KEYS = "words-keys"
    self.CACHE_STORE = "words-store"
    self.WORD_FILE = os.path.join(os.path.expanduser("~"), '.words.txt')

  def _reorganize(self):
    pop_n = self.conn.zcard(self.CACHE_KEYS) - self.CACHE_SIZE
    if pop_n >= 0:
      to_pop = self.conn.zrange(self.CACHE_KEYS, 0, pop_n)
      #print pop_n, to_pop
      self.conn.zremrangebyrank(self.CACHE_KEYS, 0, pop_n)
      for k in to_pop:
        self.conn.hdel(self.CACHE_STORE, k)

  def _add_word(self, key, value):
    result = self.conn.hget(self.CACHE_STORE, key)
    if result:
      self.conn.zincrby(self.CACHE_KEYS, key, 1.0)
    else:
      self._reorganize()
      self.conn.hset(self.CACHE_STORE, key, value)
      self.conn.zadd(self.CACHE_KEYS, 1, key)

  def _get_words(self):
    try:
      words = self.conn.zrevrange(self.CACHE_KEYS, 0, -1, True)
      #hashs = self.conn.hgetall(self.CACHE_STORE)
      #print words
      #print hashs
      return words
    except redis.exceptions.ConnectionError:
      return None

  def dump_console(self):
    if os.path.isfile(self.WORD_FILE):
      with open(self.WORD_FILE, 'r') as f:
        print f.read()

  def write_file(self):
    words = self._get_words()
    if words is None:
      return
    content = '\n'.join(["%d. %s\t %d"%(i, x[0], int(x[1])) for i, x in enumerate(words)])
    with open(self.WORD_FILE, 'w+') as f:
      f.write(content)
      f.write('\n')

  def add_word(self, key):
    try:
      self._add_word(key,key)
      self.write_file()
    except redis.exceptions.ConnectionError:
      return

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
class RedisDB(object):

    def __init__(self):
        if not hasattr(RedisDB, 'pool'):
            RedisDB.createPool()
        self.r = StrictRedis(connection_pool = RedisDB.pool)

    @staticmethod  
    def createPool():  
        RedisDB.pool = redis.ConnectionPool(  
        host = '127.0.0.1',  
        port = 6379,  
        db   = 0
        )

    def saveToRedis(self, receiver, to_station_ab, to_station_name, from_station_ab, from_station_name, querydate, purpose_code, noticetime, publishtime):
        '''将需要抓取的信息存入redis'''
        uid = self.r.incr('uid')    
        tickets_info = {'uid':uid, 'receiver':receiver, 'to_station_ab':to_station_ab, 'to_station_name':to_station_name, 'from_station_ab':from_station_ab,'from_station_name':from_station_name, 'querydate':querydate, 'purpose_code':purpose_code, 'noticetime':noticetime, 'publishtime': publishtime}
        self.r.zadd('email_que_set_all', uid, str(tickets_info))
        if noticetime == '9am':
            self.r.zadd('email_que_set_9am', uid, str(tickets_info))
        elif noticetime == '11am':
            self.r.zadd('email_que_set_11am', uid, str(tickets_info))
        elif noticetime == '3pm':
            self.r.zadd('email_que_set_3pm', uid, str(tickets_info))
        elif noticetime == '5pm':
            self.r.zadd('email_que_set_5pm', uid, str(tickets_info))
        self.r.save()

    def getStation(self, set, name):
        return self.r.hget(set, name)

    def zrevrange(self, set, begin, end):
        return self.r.zrevrange(set, begin, end)
    
    def zremrangebyscore(self, queue, uid):
        return self.r.zremrangebyscore(queue, uid, uid)

    def station_validate(self, form, field):  
        ''' 
        表单tostation和tostation验证函数
        '''
        if not self.r.getStation(field.data):
     
            raise ValidationError(u'木有这个站') 

    def saveJSONToSet(self, setName, json):
        if not self.r.exists(setName):
            for i, name in enumerate(json):
                self.r.hset(setName, name, json[name])
                print 'insert'+name
            self.r.save()
        else:
            pass

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def _fill_fake_task():
    r = StrictRedis(host='127.0.0.1', port=6379, password='[email protected])')
    for url in open('url.list'):
        url = url.strip()
        ret = urlparse(url)
        domain = ret.netloc
        task = {
            'tid': str(uuid.uuid4()).replace('-', ''),
            'method': 'GET',
            'url': url
        }
        r.zadd('CQ:10001:%s' % domain, 1, json.dumps(task))

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def seed(task):
    priority = 5
    if pattern.match(task['url']):
        priority = 15
    if task['url'].startswith('http://www.xiami.com/album/'):
        priority = 16
    if task['url'].startswith('http://www.xiami.com/artist/album/id/'):
        priority = 16
    if task['url'].startswith('http://www.xiami.com/artist/album-id'):
        priority = 15
    logger.info('schedule %s %s %d' % (task['url'], task['attr']['type'], priority))
    r = StrictRedis(host='127.0.0.1', port=6379)
    r.zadd('CQ:10001:%s' % task['attr']['domain'], priority, json.dumps(task))

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def tfidf_reduce(args):
    if args is None:
        return
    key, doc_id, value = args
    import json
    import math
    counts = None
    r = StrictRedis(db=1)
    def freq(word, doc_id):
        return r.zscore(word, doc_id)

    def word_count(doc_id):        
        try:
            with open("counts/" + doc_id, "r+") as f:
                return float(f.read())
        except:
            return 1.0 

    def num_docs_containing(word):
        return r.zcard(word)

    def tf(word, doc_id):
        return (freq(word, doc_id) / float(word_count(doc_id)))

    def idf(word):
        return math.log(doc_count / float(num_docs_containing(word)))

    def tf_idf(word, doc_id):
        return (tf(word, doc_id) * idf(word))    
    if doc_id not in db:
        print("Deleted " + doc_id + " from " + key)
        r.zrem(key, doc_id)
        return
    doc = db[doc_id]
    multiplier = 1
    try:
        if key.lower() in doc['title'].lower():
            multiplier = 4
        elif key.lower() in doc['description'].lower():
            multiplier = 2
    except:
        pass
    rank = tf_idf(key, doc_id) * multiplier
    if rank is None :
        rank = 0
    print("{0}: {1} is {2}".format(doc_id, key, rank))
    r.zadd(key, rank, doc_id)
    return rank

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def copy_values():
	source = StrictRedis()
	dest = StrictRedis(db=1)
	for key in source.keys():
		try:
			for doc_id, value in source.zrevrange(key, 0, -1, "WITHSCORES"):
				print(dest.zadd(key, value, doc_id))
				source.zrem(key, doc_id)
		except redis.exceptions.ResponseError:
			pass
	print key

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
class RedisDupeFilter(BaseDupeFilter):
    
    def __init__(self, path=None):
        self.redis_cli = StrictRedis(host='localhost', port=6379, db=0)
    
    @classmethod
    def from_settings(cls, settings):
        return cls(job_dir(settings))
     
    def request_seen(self, request):
        fp = request_fingerprint(request)
        domain = request.url.split('/')[2]
        suffix = 'category'
        if request.meta.has_key('skip'):
            suffix = 'content'
        key = '%s_%s' % (domain, suffix)
        timestamp = self.redis_cli.zscore(key, fp)
        if timestamp:
            #log.msg('skip %s' % request.url, level=log.INFO)
            return True
        self.redis_cli.zadd(key, time(), fp)
        return False

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def _fill_fake_task():
    r = StrictRedis(host='127.0.0.1', port=6379, password='[email protected])')
    for url in open('url.list.all'):
        url = url.strip()
        ret = urlparse(url)
        r.zadd('CQ:10001:%s' % ret.netloc, 1, url)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
class RedisTopTalkerTracker(object):
    def __init__(self, size=16384, redis_host='localhost', redis_port=6379,
                 redis_table='top_talkers'):
        self.size = size
        self.redis_table = 'top_talkers'
        self.client = StrictRedis(host=redis_host, port=redis_port)

        self.is_saturated = self.decide_is_saturated()

    def decide_is_saturated(self):
        return self.client.zcard(self.redis_table) >= self.size

    def clear(self):
        self.client.zremrangebyrank(self.redis_table, 0, -1)
        self.is_saturated = self.decide_is_saturated()

    def is_full(self):
        if self.is_saturated:
            return True

        self.is_saturated = self.decide_is_saturated()
        return self.is_saturated

    def get(self, key):
        count = self.client.zscore(self.redis_table, key)
        if count is None:
            return count

        return int(count)

    def contains(self, key):
        count = self.client.zscore(self.redis_table, key)
        return count is not None

    def add(self, key):
        # If it's already in there, increment its count and we're done.
        count = self.client.zscore(self.redis_table, key)
        if count is not None:
            self.client.zincrby(self.redis_table, key, 1)
            return

        # Else if the key is new to us but we're full, pop the lowest key/count
        # pair and insert the new key as count + 1.
        if self.is_full():
            keys_counts = self.client.zrange(
                self.redis_table, 0, 0, withscores=True, score_cast_func=int)
            old_count = keys_counts[0][1]
            self.client.zremrangebyrank(self.redis_table, 0, 0)
            new_count = old_count + 1
            self.client.zadd(self.redis_table, new_count, key)
            return

        # Or if the key is new to us and we have space, just insert it.
        self.client.zadd(self.redis_table, 1, key)

    def top_n_keys(self, n):
        return self.client.zrevrange(
            self.redis_table, 0, n - 1, score_cast_func=int)

    def top_n_keys_counts(self, n):
        keys_counts = self.client.zrevrange(
            self.redis_table, 0, n - 1, withscores=True, score_cast_func=int)
        if self.is_full():
            lowest_keys_counts = self.client.zrange(
                self.redis_table, 0, 0, withscores=True, score_cast_func=int)
            the_min = lowest_keys_counts[0][1] - 1
        else:
            the_min = 0
        return map(lambda (key, count): (key, count - the_min), keys_counts)

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

#.........这里部分代码省略.........
            # invert the timestamp for proper ordering
            ts = 3000000000 - ts
        to_dec = 0.0000000001
        return float(value) + (ts * to_dec)

    def _decode_value_with_time(self, combo):
        from_dec = 10000000000
        value = int(combo)
        ts = (combo - value) * from_dec
        if self.reverse == self.tie_oldest_wins:
            ts = datetime.utcfromtimestamp(3000000000 - ts)
        return value, ts

    def _leaders_with_ranks(self, key, offset, end):
        total = self.r.zcard(key)
        l = self._range(key, offset, end)
        if self.timed_ties:
            l = [((m,) + self._decode_value_with_time(s)) for (m, s) in l]
        else:
            l = [(m, s, 0) for (m, s) in l]
        log.info(l)
        with_ranks = self._add_ranks(l, offset)
        return total, with_ranks

    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:

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
BUCKET_NAME = "elfin"
Proxy = {"http": "http://127.0.0.1:48657"}

qiniu = Auth(ACCESS_KEY, SECRET_KEY)

def get_name():
    name = str(time())
    return name.replace(".", "")

def upload_media(media):
    key = get_name()
    data = media
    token = qiniu.upload_token(BUCKET_NAME)
    return put_data(token, key, data)

if __name__ == "__main__":
    while 1:
        media_url = redis.blpop("media_url")
        if media_url:
            media = get(url=media_url[1], proxies=Proxy)
            try:
                ret, info = upload_media(media.content)
            except Exception, e:
                redis.rpush("media_url", media_url)
                logbook.error(e)
            else:
                media_name = ret["key"]
                redis.zadd("image_name", int(media_name), int(media_name))
            finally:
                logbook.info("work on {}".format(media_url))

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


if __name__ == "__main__":
	mapping = load()
	params = {"from": "2013-06-14T15:00:00Z"}
	while params is not None:
		rt = harvest(params, mapping)
		params = None
		if rt is not None and rt != "null":
			params = {RESUMPTION_TOKEN: rt}
	r = StrictRedis(db=1)
	db = couchdb.Database("http://localhost:5984/lr-data")
	for doc in docs.itervalues():
		keys = doc['keywords']
		del doc['keywords']
		try:
			del db[doc['_id']]
			db.save(doc)
			print(keys)
			for k, v in keys.iteritems():
				mult = 1
				if k in doc['title'].lower():
					mult = 10
				elif k in doc['description'].lower():
					mult = 6
				r.zadd(k, v * mult, doc['_id'])
		except:
			pass