Python StrictRedis.hgetall方法代码示例

# 需要导入模块: 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)

# 需要导入模块: 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

# 需要导入模块: 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})

# 需要导入模块: 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"))

# 需要导入模块: 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)

# 需要导入模块: 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"))

# 需要导入模块: 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

# 需要导入模块: 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))

# 需要导入模块: 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

# 需要导入模块: 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)

# 需要导入模块: 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)

# 需要导入模块: 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)

# 需要导入模块: 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})

# 需要导入模块: 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)

# 需要导入模块: 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))

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