本文整理汇总了Python中redis.StrictRedis.hlen方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.hlen方法的具体用法?Python StrictRedis.hlen怎么用?Python StrictRedis.hlen使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.hlen方法的4个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: RedisDict
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hlen [as 别名]
class RedisDict(MutableMapping):
""" RedisDict - a dictionary-like interface for ``redis`` key-stores
"""
def __init__(self, namespace, collection_name='redis_dict_data',
connection=None):
"""
The actual key name on the redis server will be
``namespace``:``collection_name``
In order to deal with how redis stores data/keys,
everything, i.e. keys and data, must be pickled.
:param namespace: namespace to use
:param collection_name: name of the hash map stored in redis
(default: redis_dict_data)
:param connection: ``redis.StrictRedis`` instance.
If it's ``None`` (default), a new connection with
default options will be created
"""
if connection is not None:
self.connection = connection
else:
self.connection = Redis()
self._self_key = ':'.join([namespace, collection_name])
def __getitem__(self, key):
result = self.connection.hget(self._self_key, pickle.dumps(key))
if result is None:
raise KeyError
return pickle.loads(bytes(result))
def __setitem__(self, key, item):
self.connection.hset(self._self_key, pickle.dumps(key),
pickle.dumps(item))
def __delitem__(self, key):
if not self.connection.hdel(self._self_key, pickle.dumps(key)):
raise KeyError
def __len__(self):
return self.connection.hlen(self._self_key)
def __iter__(self):
for v in self.connection.hkeys(self._self_key):
yield pickle.loads(bytes(v))
def clear(self):
self.connection.delete(self._self_key)
def __str__(self):
return str(dict(self.items()))
示例2: StrictRedis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hlen [as 别名]
print "Obtaining lock..."
db.query(func.pg_advisory_lock(413, 1)).scalar()
print "Lock obtained."
redis = StrictRedis(connection_pool=redis_pool)
while True:
current_time = int(time.time())
# Make sure a message is sent every 25 seconds so the long poll requests
# don't time out.
# XXX INCREASE THIS TO SEVERAL MINUTES
for chat_id in redis.zrangebyscore("longpoll_timeout", 0, current_time):
redis.publish("channel:%s" % chat_id, '{"messages":[]}')
if redis.hlen("chat:%s:online" % chat_id) != 0:
redis.zadd("longpoll_timeout", time.time() + 25, chat_id)
else:
redis.zrem("longpoll_timeout", chat_id)
# And do the reaping.
for dead in redis.zrangebyscore("chats_alive", 0, current_time):
print current_time, "Reaping ", dead
chat_id, session_id = dead.split("/")
user_id = redis.hget("chat:%s:online" % chat_id, session_id)
disconnected = disconnect(redis, chat_id, session_id)
# Only send a timeout message if they were already online.
if not disconnected:
print "Not sending timeout message."
continue
try:
示例3: Moose
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hlen [as 别名]
#.........这里部分代码省略.........
if arg == "help" and len(args) == 0:
self.help("")
elif arg in self.commands.keys():
arg_num = self.commands[arg]["number_of_args"]
params = []
if len(args) < arg_num:
self.help(arg)
return
elif arg_num == 0:
params = []
elif arg_num == -1:
params = [args]
else:
params = args[:arg_num]
if self.commands[arg].get("username", False):
self.commands[arg]["method"](username, *params)
else:
self.commands[arg]["method"](*params)
elif arg in self.commands.keys():
self.help(arg)
def purge(self, username):
if username == "zachzor":
self.redis_server.delete("challs")
self.send_message("All challenges removed")
def get(self, challenge_name):
if challenge_name[0] == '#':
try:
challenge_number = int(challenge_name[1:])
except ValueError:
self.send_message("%s is not a valid challenge id" % challenge_name)
return
if self.redis_server.hlen("challs") <= challenge_number or challenge_number < 0:
self.send_message("%s is not a valid challenge id" % challenge_name)
return
else:
name = [(i, s) for i, s in enumerate(self.redis_server.hkeys("challs"))][challenge_number][1]
try:
gist = self.create_gist(name, pickle.loads(self.redis_server.hget("challs", name)))
self.send_message("%s" % gist)
except GistException:
self.send_message("Unable to create gist")
else:
if not self.redis_server.hexists("challs", challenge_name):
self.send_message("%s is not a valid challenge name" % challenge_name)
return
else:
try:
gist = self.create_gist(challenge_name, pickle.loads(self.redis_server.hget("challs", challenge_name)))
self.send_message("%s" % gist)
except GistException:
self.send_message("Unable to create gist")
def farts(self):
self.send_message(" ".join(list(["pfffttt"] * randint(1, 7))))
def add(self, username, args):
if len(args) < 2:
self.help("add")
return
challenge_name, description = args[0], args[1:]
new_info = InfoMessage(username, datetime.now().strftime("%m-%d-%Y %H:%M:%S"), " ".join(description))
if self.redis_server.hget("challs", challenge_name) == None:
self.redis_server.hset("challs", challenge_name, pickle.dumps([new_info]))
else:
示例4: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hlen [as 别名]
class RedisBackend:
colls_index_fmt = 'plumbca:' + dfconf['mark_version'] + ':collections:index'
metadata_fmt = 'plumbca:' + dfconf['mark_version'] + ':metadata:timeline:{name}'
inc_coll_cache_fmt = 'plumbca:' + dfconf['mark_version'] + ':cache:{name}'
sorted_count_coll_cache_fmt = 'plumbca:' + dfconf['mark_version'] + \
':sorted:count:cache:{name}:{tagging}:{ts}'
unique_count_coll_cache_fmt = 'plumbca:' + dfconf['mark_version'] + \
':unique:count:cache:{name}:{tagging}:{ts}'
def __init__(self):
self.rdb = StrictRedis(host=rdconf['host'], port=rdconf['port'],
db=rdconf['db'])
self.version = dfconf['mark_version']
def set_collection_index(self, name, instance):
""" Set the collection info of instance to the backend.
"""
key = self.colls_index_fmt
v = instance.__class__.__name__
self.rdb.hset(key, name, packb(v))
def get_collection_index(self, name):
""" Get the collection info from backend by name.
"""
key = self.colls_index_fmt
rv = self.rdb.hget(key, name)
return [name, unpackb(rv)] if rv else None
def get_collection_indexes(self):
""" Get all of the collections info from backend.
"""
key = self.colls_index_fmt
rv = self.rdb.hgetall(key)
if rv:
return {name.decode("utf-8"): unpackb(info)
for name, info in rv.items()}
def delete_collection_keys(self, coll, klass=''):
""" Danger! This method will erasing all values store in the key that
should be only use it when you really known what are you doing.
It is good for the testing to clean up the environment.
"""
md_key = self.metadata_fmt.format(name=coll.name)
self.rdb.delete(md_key)
if klass == 'IncreaseCollection':
cache_key = self.inc_coll_cache_fmt.format(name=coll.name)
self.rdb.delete(cache_key)
def get_collection_length(self, coll, klass=''):
if not klass:
klass = coll.__class__.__name__
rv = []
md_key = self.metadata_fmt.format(name=coll.name)
md_len = self.rdb.zcard(md_key)
rv.append(md_len)
# print('** TL -', self.rdb.zrange(md_key, 0, -1, withscores=True))
if klass == 'IncreaseCollection':
cache_key = self.inc_coll_cache_fmt.format(name=coll.name)
cache_len = self.rdb.hlen(cache_key)
# notice that the cache_len is the length of all the items in cache_key
rv.append(cache_len)
return rv
def set_collection_metadata(self, coll, tagging, expts, ts, *args):
""" Insert data to the metadata structure if timestamp data do not
exists. Note that the metadata structure include two types, timeline
and expire.
:param coll: collection class
:param tagging: specific tagging string
:param ts: the timestamp of the data
:param expts: the expired timestamp of the data
"""
md_key = self.metadata_fmt.format(name=coll.name)
# Ensure the item of the specific `ts` whether it's exists or not,
element = self.rdb.zrangebyscore(md_key, ts, ts)
if element:
info = unpackb(element[0])
if tagging in info:
# the tagging info already exists then do nothings
return
info[tagging] = [expts] + list(args)
# remove the md_key and update new value atomically
p = self.rdb.pipeline()
p.zremrangebyscore(md_key, ts, ts)
p.zadd(md_key, ts, packb(info))
p.execute()
else:
info = {tagging: [expts] + list(args)}
self.rdb.zadd(md_key, ts, packb(info))
# print('-'*10)
# print(tagging)
#.........这里部分代码省略.........