本文整理汇总了Python中redis.StrictRedis.hgetall方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.hgetall方法的具体用法?Python StrictRedis.hgetall怎么用?Python StrictRedis.hgetall使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.hgetall方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: IndexCache
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hgetall [as 别名]
class IndexCache(object):
def __init__(self, host, port):
self.client = StrictRedis(host=host, port=port, db=0)
def build(self, doc_word_scores):
"""Clears the entire store and adds all the doc_word_scores into a
hash table in the store.
:param doc_word_scores: dictionary of dictionaries that looks like:
doc_word_scores[word][doc_id] = score of word in that
document
"""
self.reset()
for word, doc_id_score in doc_word_scores.items():
# Add table name to word
word_key = DOCUMENT_WORD_SCORE_NAME + word
self.client.hmset(word_key, doc_id_score)
self.save_to_disk()
def reset(self):
"""Deletes all keys in this DB.
"""
self.client.flushdb()
def save_to_disk(self):
"""Asyncronous write to disk for persistent storage.
"""
self.client.bgsave()
def to_dict(self):
"""Returns the "doc_word_scores" table in Redis in dictionary form.
"""
doc_word_scores = {}
for word_key in self.doc_word_scores_iter():
# Remove the table name from the key
word = word_key.replace(DOCUMENT_WORD_SCORE_NAME, "")
# Grab the {doc_ids : scores} dictionary for word
doc_word_scores[word] = self.client.hgetall(word_key)
return doc_word_scores
def doc_word_scores_iter(self):
"""Returns an iterator for the keys of all the words stored in Redis
"""
return self.client.scan_iter(match=DOCUMENT_WORD_SCORE_NAME + "*")
def is_empty(self):
return self.client.dbsize() <= 0
def doc_scores(self, word):
"""Returns a hash table of document_ids mapping to scores
"""
word_key = DOCUMENT_WORD_SCORE_NAME + word
return self.client.hgetall(word_key)
示例2: load
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hgetall [as 别名]
def load(obj, namespace=None, silent=True, key=None):
"""
Reads and loads in to "settings" a single key or all keys from redis
:param obj: the settings instance
:param namespace: settings namespace default='DYNACONF'
:param silent: if errors should raise
:param key: if defined load a single key, else load all in namespace
:return: None
"""
redis = StrictRedis(**obj.REDIS_FOR_DYNACONF)
namespace = namespace or obj.DYNACONF_NAMESPACE
holder = "DYNACONF_%s" % namespace
try:
if key:
value = parse_conf_data(redis.hget(holder.upper(), key))
if value:
obj.set(key, value)
else:
data = {
key: parse_conf_data(value)
for key, value in redis.hgetall(holder.upper()).items()
}
if data:
obj.update(data, loader_identifier=IDENTIFIER)
except Exception as e:
e.message = 'Unable to load config from redis (%s)' % e.message
if silent:
obj.logger.error(e.message)
return False
raise
示例3: new_group
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hgetall [as 别名]
def new_group(request):
groupname = request.POST.get("groupname")
totwords = request.POST.get("totwords")
totmembers = request.POST.get('totmembers')
pref = settings.MY_PREFIX
prefg = pref+":"+groupname
user = str(request.user)
rd = StrictRedis()
# the above statements are self explanatory
exists = rd.exists(pref+":"+groupname)
if exists:
# return error, can't create the group with that name
# don't do that, just add this user to the already existing group
# if group size < totmembers
d = rd.hgetall(prefg+":hash")
response = {'facility':""}
if int(d['totmembers'])>int(d['curmembers']):
rd.hincrby(prefg+":hash", 'curmembers')
#d = rd.hgetall(prefg+":hash")
response['facility'] = groupname
response['new_group_created'] = False
rd.sadd(prefg, user)
#now notify the others that this user joined the group!
redis_publisher = RedisPublisher(facility = pref, broadcast = True)
mydict = {"type":"new_join", 'who':user, 'name':groupname}
msgstring = json.dumps(mydict)
print "broadcast message:"+msgstring
message = RedisMessage(msgstring)
redis_publisher.publish_message(message)
# now check if the competition is ready to start
if int(d['totmembers'])-1 == int(d['curmembers']):
start_competition(request,groupname)
return JsonResponse(response)
# so the group doesn't exist
rd.sadd(prefg, user)
# add this user to the set of all the users that are part of this group
hashdict = {'totwords':totwords, 'totmembers':totmembers, "owner":user, "name":groupname, 'curmembers':1}
# adding group name is redundant but it simplifies things a lot
rd.hmset(prefg+":hash", hashdict)
# using hash greatly simplifies the things(dict interconversion hgetall()), though i feel that the
# naming convention used is horrible
redis_publisher = RedisPublisher(facility = pref, broadcast = True)
mydict = {"type":"new_group"}
mydict.update(hashdict)
msgstring = json.dumps(mydict)
print msgstring
message = RedisMessage(msgstring)
redis_publisher.publish_message(message)
# notify the others about this new group that was created
rd.sadd(pref+":groups", groupname)
return JsonResponse({'facility':groupname, 'new_group_created':True})
示例4: test_flush_cache_overflow
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hgetall [as 别名]
def test_flush_cache_overflow(self):
pool = get_pool()
subject = RedisState(pool, 1)
r1 = Request("4", int(time()) - 10, 'https://www.knuthellan.com/', domain='knuthellan.com')
r1.meta[b'state'] = b'd'
r2 = Request("5", int(time()) - 10, 'https://www.khellan.com/', domain='khellan.com')
r2.meta[b'state'] = b'e'
r3 = Request("6", int(time()) - 10, 'https://www.hellan.me/', domain='hellan.me')
r3.meta[b'state'] = b'f'
batch = [r1, r2, r3]
subject.update_cache(batch)
subject.flush(False)
self.assertEqual(0, len(subject._cache))
connection = StrictRedis(connection_pool=pool)
self.assertEqual({FIELD_STATE: b'd'}, connection.hgetall("4"))
self.assertEqual({FIELD_STATE: b'e'}, connection.hgetall("5"))
self.assertEqual({FIELD_STATE: b'f'}, connection.hgetall("6"))
示例5: do_updates
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hgetall [as 别名]
def do_updates():
"""UPDATE"""
db = StrictRedis()
db_pipe = db.pipeline()
update_keys = (260, 271, 285, 300, 310)
print 'before...'
for key in update_keys:
print db.hgetall(key)
db_pipe.hset(key, 'city', 'NYC')
db_pipe.execute()
print '\nafter...'
for key in update_keys:
print db.hgetall(key)
示例6: test_flush_no_force
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hgetall [as 别名]
def test_flush_no_force(self):
pool = get_pool()
subject = RedisState(pool, 10)
r1 = Request("1", int(time()) - 10, 'https://www.knuthellan.com/', domain='knuthellan.com')
r1.meta[b'state'] = b'a'
r2 = Request("2", int(time()) - 10, 'https://www.khellan.com/', domain='khellan.com')
r2.meta[b'state'] = b'b'
r3 = Request("3", int(time()) - 10, 'https://www.hellan.me/', domain='hellan.me')
r3.meta[b'state'] = b'c'
batch = [r1, r2, r3]
subject.update_cache(batch)
subject.flush(False)
self.assertEqual(3, len(subject._cache))
connection = StrictRedis(connection_pool=pool)
self.assertEqual({FIELD_STATE: b'a'}, connection.hgetall("1"))
self.assertEqual({FIELD_STATE: b'b'}, connection.hgetall("2"))
self.assertEqual({FIELD_STATE: b'c'}, connection.hgetall("3"))
示例7: do_reads
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hgetall [as 别名]
def do_reads():
"""READ"""
db = StrictRedis()
read_keys = (128, 157, 216, 236, 248)
for key in read_keys:
rec = db.hgetall(key)
print rec
示例8: PECorrelator
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hgetall [as 别名]
class PECorrelator(object):
def __init__(self):
self.r = StrictRedis(unix_socket_path=redis_socket, decode_responses=True)
def get_all_samples(self):
return self.r.smembers("hashes_sha256")
def get_all_hashes(self, sha256):
return [sha256] + list(self.r.hmget(sha256, ["sha1", "md5"]))
def get_sample_info(self, sha256):
return self.r.hgetall(sha256)
def get_timestamps_iso(self, num=-1):
return [
(datetime.datetime.fromtimestamp(ts).isoformat(), val)
for ts, val in self.r.zrevrange("timestamps", 0, num, withscores=True)
]
def get_timestamps(self, num=-1):
return self.r.zrevrange("timestamps", 0, num, withscores=True)
def get_samples_timestamp(self, timestamp):
return self.r.smembers("timestamp:{}".format(timestamp))
def get_imphashs(self, num=-1):
return self.r.zrevrange("imphashs", 0, num, withscores=True)
def get_samples_imphash(self, imphash):
return self.r.smembers("imphash:{}".format(imphash))
def get_entrypoints(self, num=-1):
return self.r.zrevrange("entrypoints", 0, num, withscores=True)
def get_samples_entrypoint(self, entrypoint):
return self.r.smembers("entrypoint:{}".format(entrypoint))
def get_secnumbers(self, num=-1):
return self.r.zrevrange("secnumbers", 0, num, withscores=True)
def get_samples_secnumber(self, secnumber):
return self.r.smembers("secnumber:{}".format(secnumber))
def get_originalfilenames(self, num=-1):
return self.r.zrevrange("originalfilenames", 0, num, withscores=True)
def get_samples_originalfilename(self, originalfilename):
return self.r.smembers("originalfilename:{}".format(originalfilename))
def get_sample_secnames(self, sha256):
return self.r.smembers("{}:secnames".format(sha256))
示例9: CachedIDTClient
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hgetall [as 别名]
class CachedIDTClient(IDTClient):
def __init__(self, REDIS_HOST='localhost', REDIS_PORT=6379, REDIS_DB=0):
super(CachedIDTClient, self).__init__()
self.r = StrictRedis(REDIS_HOST, REDIS_PORT, REDIS_DB)
def get_info(self, sequence, oligo=2, na=40, mg=2, dntp=0.2):
if not self.r.exists(sequence):
tm = super(CachedIDTClient, self).get_melting_temp(sequence, oligo, na, mg, dntp)
dimer = super(CachedIDTClient, self).self_dimer_check(sequence)
info = {'tm': tm.tm, 'dimer': dimer.self_dimer, 'compPercent': dimer.compPercent}
self.r.hmset(sequence, info)
else:
info = self.r.hgetall(sequence)
return info
示例10: SnapshotWriterTest
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hgetall [as 别名]
class SnapshotWriterTest(TestCase):
def setUp(self):
self.snapshot_queue = Queue()
self.db = StrictRedis(host=REDIS['host'], port=REDIS['port'], db=SNAPSHOTS_DB)
self.writer = SnapshotWriter(self.snapshot_queue)
def test_should_read_snapshots_from_queue_periodically_and_write_them_to_redis_db(self):
self.writer.start()
snapshot_one = {'id': 1, 'other_details': 'Vehicle data', 'time': 1.0}
snapshot_two = {'id': 2, 'other_details': 'Vehicle data', 'time': 1.0}
[self.snapshot_queue.put(item) for item in [snapshot_one, snapshot_two]]
sleep(0.3)
self.writer.shutdown()
snapshots_in_db = [self.db.hgetall(key) for key in ['vehicle:1:1.000000', 'vehicle:2:1.000000']]
expected_snapshots = [self.redisify_snapshot(snapshot) for snapshot in [snapshot_one, snapshot_two]]
self.assertListEqual(snapshots_in_db, expected_snapshots)
def test_should_write_snapshot_with_key_a_concatenation_of_vehicle_id_and_time_stamp_to_six_decimal_places(self):
self.writer.start()
snapshot = {'id': 1, 'other_details': 'Vehicle data', 'time': 1.123459881213}
self.snapshot_queue.put(snapshot)
sleep(0.1)
self.writer.shutdown()
self.assertTrue('vehicle:1:1.123460' in self.db.keys("*"))
def test_should_stop_reading_snapshots_if_shutdown_is_requested(self):
writer = SnapshotWriter(self.snapshot_queue)
writer.start()
writer.shutdown()
self.assertTrue(True) # Tests that we get here
def redisify_snapshot(self, snapshot):
snapshot.update({'id': str(snapshot['id']), 'time': "%.1f" % snapshot['time']})
return snapshot
def tearDown(self):
for key in self.db.keys("*"):
self.db.delete(key)
示例11: RedisBackend
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hgetall [as 别名]
class RedisBackend(BaseBackend):
def __init__(self):
from redis import StrictRedis
host = conf.METADATA.get('host', 'localhost')
port = conf.METADATA.get('port', 6379)
password = conf.METADATA.get('password', None)
db = conf.METADATA.get('db', 0)
prefix = conf.METADATA.get('PREFIX', 'djthumbs')
self.prefix = prefix + ":"
self.redis = StrictRedis(host=host, port=port, password=password, db=db)
def get_source_key(self, name):
return "%ssources:%s" % (self.prefix, name)
def get_thumbnail_key(self, name):
return "%sthumbnails:%s" % (self.prefix, name)
def add_source(self, name):
self.redis.hset(self.get_source_key(name), name, name)
return name
def get_source(self, name):
return compat.as_text(self.redis.hget(self.get_source_key(name), name))
def delete_source(self, name):
return self.redis.hdel(self.get_source_key(name), name)
def get_thumbnails(self, name):
metas = self.redis.hgetall(self.get_thumbnail_key(name))
return [ImageMeta(name, thumbnail_name, size) for size, thumbnail_name in metas.items()]
def get_thumbnail(self, source_name, size):
name = compat.as_text(self.redis.hget(self.get_thumbnail_key(source_name), size))
if name:
return ImageMeta(source_name, name, size)
return None
def add_thumbnail(self, source_name, size, name):
self.redis.hset(self.get_thumbnail_key(source_name), size, name)
return ImageMeta(source_name, name, size)
def delete_thumbnail(self, source_name, size):
self.redis.hdel(self.get_thumbnail_key(source_name), size)
示例12: ginfo
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hgetall [as 别名]
def ginfo(request):
print(str(request.user)+' requested groupinfo')
rd = StrictRedis()
pref = settings.MY_PREFIX
groupinfo = []
response = {}
if rd.exists(pref+":groups"):
# there is atleast 1 group already created
groupnames = rd.smembers(pref+":groups")
# groupnames is a set
for groupname in groupnames:
groupdict = rd.hgetall(pref+":"+groupname+":hash")
groupinfo.append(groupdict)
#print groupdict
# time to serialize!
response['group_list'] = groupinfo
response.update( {"success":True, "group_count":len(groupinfo)})
#print response
return JsonResponse(response)
示例13: gdelete
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hgetall [as 别名]
def gdelete(request):
groupname = request.POST.get('name', 0);
rd = StrictRedis()
pref = settings.MY_PREFIX
prefg = pref+":"+groupname
user = str(request.user)
print "received request for deleting",groupname,"from",user
ismember = rd.sismember(pref+":groups",groupname)
if not ismember:
return JsonResponse({'done':False,'reason':'No such group name'});
# now check whether the requesting user is the one who created the group
d = rd.hgetall(prefg+":hash")
if d['owner'] != user:
return JsonResponse({'done':False, 'reason':'Only group owner can delete the group'})
rd.srem(pref+":groups", groupname)
rd.delete(prefg+":hash", pref+":"+groupname)
rd.delete(pref+":"+groupname)
redis_publisher = RedisPublisher(facility = pref, broadcast = True)
redis_publisher.publish_message(RedisMessage(json.dumps({"type":"group_delete", "name":groupname})))
return JsonResponse({'done':True})
示例14: Redis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hgetall [as 别名]
class Redis(Backend):
"""Default backend for MimicDB. Initiated with identical parameters
as ``redis.StrictRedis``.
:param args \*args, \**kwargs: StrictRedis.__init__() parameters
.. code-block:: python
from mimicdb.backends.default import Redis
redis = Redis(host='localhost', port=6379, db=0)
"""
def __init__(self, *args, **kwargs):
self._redis = StrictRedis(*args, **kwargs)
def keys(self, pattern='*'):
return self._redis.keys(pattern)
def delete(self, *names):
return self._redis.delete(*names)
def sadd(self, name, *values):
return self._redis.sadd(name, *values)
def srem(self, name, *values):
return self._redis.srem(name, *values)
def sismember(self, name, value):
return self._redis.sismember(name, value)
def smembers(self, name):
return self._redis.smembers(name)
def hmset(self, name, mapping):
return self._redis.hmset(name, mapping)
def hgetall(self, name):
return self._redis.hgetall(name)
示例15: JobsDB
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hgetall [as 别名]
class JobsDB(object):
prefix = { 'job' : 'multivac_job',
'log' : 'multivac_log',
'group' : 'multivac_group',
'action' : 'multivac_action',
'worker' : 'multivac_worker' }
def __init__(self, redis_host, redis_port):
self.redis = StrictRedis(
host=redis_host,
port=redis_port,
decode_responses=True)
self.subs = {}
# TODO: add connection test with r.config_get('port')
#######
# Job Methods
#######
def create_job(self, action_name, args=None, initiator=None):
"""
Create a new job with unique ID and subscribe to log channel
params:
- action_name(str): Name of the action this job uses
- args(str): Optional space-delimited series of arguments to be
appended to the job command
- initiator(str): Optional name of the user who initiated this job
"""
job = self.get_action(action_name)
if not job:
return (False, 'No such action')
#check that user has privilege for this command
if not self.check_user(initiator, job['allow_groups'].split(',')):
log.debug('action denied: %s for user %s' % \
(action_name, initiator))
return (False, 'Invalid user command')
job['id'] = str(uuid4().hex)
job['args'] = args
job['created'] = unix_time(datetime.utcnow())
if job['confirm_required'] == "True":
job['status'] = 'pending'
else:
job['status'] = 'ready'
self._subscribe_to_log(job['id'])
if initiator:
self.append_job_log(job['id'], 'Job initiated by %s' % initiator)
self.redis.hmset(self._key('job', job['id']), job)
return (True, job['id'])
def cancel_job(self, job_id):
""" Cancel and cleanup a pending job by ID """
job = self.get_job(job_id)
if job['status'] != 'pending':
return (False, 'Cannot cancel job in %s state' % job['status'])
self.cleanup_job(job_id, canceled=True)
return (True, '')
def update_job(self, job_id, field, value):
""" Update an arbitrary field for a job """
self.redis.hset(self._key('job', job_id), field, value)
return (True,)
def cleanup_job(self, job_id, canceled=False):
"""
Cleanup log subscriptions for a given job id and mark completed
params:
- canceled(bool): If True, mark job as canceled instead of completed
"""
logkey = self._key('log', job_id)
# send EOF signal to streaming clients
self.redis.publish(logkey, 'EOF')
if job_id in self.subs:
self.subs[job_id].unsubscribe()
del self.subs[job_id]
log.debug('Unsubscribed from log channel: %s' % logkey)
if canceled:
self.update_job(job_id, 'status', 'canceled')
else:
self.update_job(job_id, 'status', 'completed')
def get_job(self, job_id):
"""
Return single job dict given a job id
"""
return self.redis.hgetall(self._key('job', job_id))
#.........这里部分代码省略.........