本文整理汇总了Python中redis.StrictRedis.zremrangebyrank方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.zremrangebyrank方法的具体用法?Python StrictRedis.zremrangebyrank怎么用?Python StrictRedis.zremrangebyrank使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.zremrangebyrank方法的4个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zremrangebyrank [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
示例2: KVDB
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zremrangebyrank [as 别名]
class KVDB(object):
""" A wrapper around the Zato's key-value database.
"""
def __init__(self, conn=None, config=None, decrypt_func=None):
self.conn = conn
self.config = config
self.decrypt_func = decrypt_func
def init(self):
config = {}
if self.config.get('host'):
config['host'] = self.config.host
if self.config.get('port'):
config['port'] = int(self.config.port)
if self.config.get('db'):
config['db'] = int(self.config.db)
if self.config.get('password'):
config['password'] = self.decrypt_func(self.config.password)
if self.config.get('socket_timeout'):
config['socket_timeout'] = float(self.config.socket_timeout)
if self.config.get('connection_pool'):
split = self.config.connection_pool.split('.')
module, class_name = split[:-1], split[-1]
mod = import_module(module)
config['connection_pool'] = getattr(mod, class_name)
if self.config.get('charset'):
config['charset'] = self.config.charset
if self.config.get('errors'):
config['errors'] = self.config.errors
if self.config.get('unix_socket_path'):
config['unix_socket_path'] = self.config.unix_socket_path
self.conn = StrictRedis(**config)
def pubsub(self):
return self.conn.pubsub()
def publish(self, *args, **kwargs):
return self.conn.publish(*args, **kwargs)
def subscribe(self, *args, **kwargs):
return self.conn.subscribe(*args, **kwargs)
def translate(self, system1, key1, value1, system2, key2, default=''):
return self.conn.hget(
_KVDB.SEPARATOR.join(
(_KVDB.TRANSLATION, system1, key1, value1, system2, key2)), 'value2') or default
def copy(self):
""" Returns an KVDB with the configuration copied over from self. Note that
the object returned isn't initialized, in particular, the connection to the
database won't have been initialized.
"""
kvdb = KVDB()
kvdb.config = self.config
kvdb.decrypt_func = self.decrypt_func
return kvdb
def close(self):
self.conn.connection_pool.disconnect()
# ##############################################################################
# OAuth
def add_oauth_nonce(self, username, nonce, max_nonce_log):
""" Adds an OAuth to the set containing last N used ones for a given username.
"""
key = NONCE_STORE.KEY_PATTERN.format('oauth', username)
# This lets us trim the set to top (last) N nonces
score = timegm(gmtime())
self.conn.zadd(key, score, nonce)
self.conn.zremrangebyrank(key, 0, -max_nonce_log)
def has_oauth_nonce(self, username, nonce):
""" Returns a boolean flag indicating if there's an OAuth nonce for a given
username stored in KVDB.
"""
return self.conn.zscore(NONCE_STORE.KEY_PATTERN.format('oauth', username), nonce)
示例3: RedisTopTalkerTracker
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zremrangebyrank [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)
示例4: RedisLRU
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zremrangebyrank [as 别名]
class RedisLRU(object):
def __init__(self, redis=None, **kwargs):
if redis is not None:
self._redis = redis
else:
self._redis = Redis(**kwargs)
self.namespaces = {
"default": 10000
}
def setup_namespace(self, namespace, size):
"""Set the LRU Size for a namespace.
"""
self.namespaces[namespace] = int(size)
def _serialize(self, s):
# return json.dumps(s)
return s
def _unserialize(self, s):
# s = s.decode("utf-8")
# return json.loads(s)
return s
def _size(self, namespace):
return self.namespaces[namespace]
def _hit_store(self, namespace):
if namespace not in self.namespaces:
raise KeyError("invalid namespace")
return "cache_keys_{}".format(namespace)
def _value_store(self, namespace):
if namespace not in self.namespaces:
raise KeyError("invalid namespace")
return "cache_values_{}".format(namespace)
def _expire_old(self, namespace):
hits = self._hit_store(namespace)
size = self._size(namespace)
count = self._redis.zcard(hits)
if count >= size:
values = self._value_store(namespace)
items = self._redis.zrange(hits, 0, count-size)
logger.error(items)
self._redis.zremrangebyrank(hits, 0, count-size)
self._redis.hdel(values, *items)
def clear(self, namespace="default"):
"""Clear the Cache.
"""
hits = self._hit_store(namespace)
values = self._value_store(namespace)
self._redis.delete(hits, values)
def clearAll(self):
"""Clear all known namespaces.
"""
for k in self.namespaces.iterkeys():
self.clear(k)
def store(self, key, value, namespace="default"):
"""Store a key value pair in cache.
This will not update an existing item.
"""
values = self._value_store(namespace)
if not self._redis.hexists(values, key):
hits = self._hit_store(namespace)
self._expire_old(namespace)
self._redis.hset(values, key, self._serialize(value))
self._redis.zadd(hits, time.time(), key)
else:
hits = self._hit_store(namespace)
self._redis.hset(values, key, self._serialize(value))
self._redis.zadd(hits, time.time(), key)
def get(self, key, namespace="default"):
"""Get a value from the cache.
returns none if the key is not found.
"""
values = self._value_store(namespace)
value = self._redis.hget(values, key)
if value:
hits = self._hit_store(namespace)
self._redis.zadd(hits, time.time(), key)
return self._unserialize(value)
return None
def expire(self, key, namespace="default"):
"""Expire (invalidate) a key from the cache.
"""
values = self._value_store(namespace)
if self._redis.hexists(values, key):
hits = self._hit_store(namespace)
self._redis.hdel(values, key)
self._redis.zrem(hits, key)