Python StrictRedis.lpush方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpush [as 别名]
def init_redis_for_testing_cruncher(game_file):
    buffer = Buffer(**REDIS_PARAM)
    buffer.delete(TO_CRUNCHER)
    buffer.delete(TO_USERCRUNCHER)
    with open(game_file, "r") as f:
        for game_id in f.readlines():
            buffer.lpush(TO_CRUNCHER, game_id.strip())

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpush [as 别名]
class DbRedis(Db):
    def __init__(self):
        super().__init__()
        self.redis = StrictRedis(**dbSettings)

    def generateKey(self):
        return self.redis.incr("id")

    def store(self, key, objSerial):
        self.redis.setex(key, TTL, objSerial)

    def retrieve(self, key):
        return self.redis.get(key)

    def lenList(self, name):
        return self.redis.llen(name)

    def listAppend(self, name, val):
        self.redis.lpush(name, val)

    def listPopLeft(self, name):
        return self.redis.lpop(name)

    def retrieveList(self, name):
        return self.redis.lrange(name, 0, -1)

    def removeFromList(self, name, item):
        self.redis.lrem(name, item, 0)

    def keyExists(self, key):
        return self.redis.exists(key)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpush [as 别名]
 def test_list_preparation_with_exisiting_list(self) -> None:
     """
     Test preparation with an already existing list
     """
     redis = StrictRedis(connection_pool=self.__pool)
     redis.lpush(self.__config['queue'], 'test')
     rqa = RedisQueueAccess(self.__config)
     type_queue = redis.type(rqa.queue)
     self.assertEqual(type_queue, b'list')

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpush [as 别名]
def init():
    r = StrictRedis('127.0.0.1', 6379)
    key = 'QQMAIL'
    mail_list = []
    with open('qqmail.txt', 'r') as f:
        for line in f:
            mail_list.append(line.strip())

    random.shuffle(mail_list)

    for i in mail_list:
        r.lpush(key, i)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpush [as 别名]
def update_status(msg, **redis_kwargs):
    """ Updated Redis with a message, prefix it with the current timestamp.
    
        Keyword args are passed directly to redis.StrictRedis().
    """
    pid = getpid()
    red = StrictRedis(**redis_kwargs)
    key = 'pid-%d-statuses' % pid
    msg = '%.6f %s' % (time(), msg)
    
    red.lpush(key, msg)
    red.expire(key, 60 * 60)
    red.ltrim(key, 0, _keep)

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

    def __init__(self, host, port):
        self.r = StrictRedis(host=host, port=port)

# store dictionary
#    redis.hmset(hkey, dict_to_store)
# retrieve dictionary
#    redis.hmget(hkey)
# lists
#    redis.lappend(hkey, string)
#    redis.llen

    def get_item(self, key_store, index):
        length = self.r.llen(key_store)
        if length == 0:
            return None
        if index >= length:
            raise Exception('Index out of range.')
        item_json = self.r.lindex(key_store, length - (index + 1))
        item_dict = json.loads(item_json)
        return item_dict

    def append_item(self, key_store, item):
        item_json = json.dumps(item)
        if not self.r.lpush(key_store, item_json):
            raise Exception('Unable to write key_store: [%s]' % item_json)

    def fetch_all(self, key_store):
        q = []
        length = self.r.llen(key_store)
        for i in range(length):
            item_json = self.r.lindex(key_store, length - (i + 1))
            item_dict = json.loads(item_json)
            q.append(item_dict)
        return q

    def set(self, key_store, list):
        self.r.delete(key_store)
        for item_dict in list:
            item_json = json.dumps(item_dict)
            if not self.r.lpush(key_store, item_json):
                raise Exception('Unable to write key_store: [%s]' % item_json)

    def delete(self, key_store):
        self.r.delete(key_store)

    def info(self):
        return self.r.info()

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpush [as 别名]
class JSONRedisBackend(BaseBackend):

    def __init__(self):
        self.redis = StrictRedis()

    def serialize(self, value):
        return json.dumps(value)

    def deserialize(self, value):
        return value and json.loads(value) or None

    def get(self, key):
        value = self.redis.get(key)
        result = self.deserialize(value)
        return result

    def set(self, key, value):
        product = self.serialize(value)
        return self.redis.set(key, product)

    def rpush(self, key, value):
        product = self.serialize(value)
        return self.redis.rpush(key, product)

    def lpush(self, key, value):
        product = self.serialize(value)
        return self.redis.lpush(key, product)

    def lpop(self, key):
        value = self.redis.lpop(key)
        result = self.deserialize(value)
        return result

    def llen(self, key):
        return self.redis.llen(key)

    def rpop(self, key):
        value = self.redis.rpop(key)
        result = self.deserialize(value)
        return result

    def report_steps(self, name, consumers, producers):
        pipeline = self.redis.pipeline()
        producers_key = ':'.join([name, 'producers'])
        consumers_key = ':'.join([name, 'consumers'])

        for consumer in consumers:
            pipeline.sadd(consumers_key, consumer)

        for producer in producers:
            pipeline.sadd(producers_key, producer)

        pipeline.smembers(consumers_key)
        pipeline.smembers(producers_key)

        result = pipeline.execute()
        all_consumers = result[-2]
        all_producers = result[-1]

        return all_consumers, all_producers

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

    def __init__(self):
        self.available_buckets = config["visual_debugger"]["available_buckets"]
        self.bucket_generator = itertools.cycle(self.available_buckets)

        self.redis_client = StrictRedis(**config["redis"])
        self.clear_image_data()

    def store_image_data(self, image_data, image_shape, bucket="debug"):
        self.redis_client.lpush(f"{config['visual_debugger']['redis_key_prefix']}:{bucket}:SHAPE", pickle.dumps(image_shape))
        self.redis_client.lpush(f"{config['visual_debugger']['redis_key_prefix']}:{bucket}", image_data.tobytes())

    def retrieve_image_data(self):
        bucket = next(self.bucket_generator)
        bucket_key = f"{config['visual_debugger']['redis_key_prefix']}:{bucket}"

        response = self.redis_client.rpop(bucket_key)

        if response is not None:
            bucket = bucket_key.split(":")[-1]

            image_shape = self.redis_client.rpop(f"{config['visual_debugger']['redis_key_prefix']}:{bucket}:SHAPE")
            image_shape = pickle.loads(image_shape)

            image_data = np.fromstring(response, dtype="uint8").reshape(image_shape)

            return bucket, image_data

        return None

    def save_image_data(self, bucket, image_data):
        if bucket in self.available_buckets:
            if image_data.dtype == "bool" or (image_data.dtype == "uint8" and 1 in np.unique(image_data)):
                image_data = image_data.astype("uint8") * 255

            skimage.io.imsave(f"{bucket}.png", image_data)

    def clear_image_data(self):
        visual_debugger_keys = self.redis_client.keys(f"{config['visual_debugger']['redis_key_prefix']}*")

        for key in visual_debugger_keys:
            self.redis_client.delete(key.decode("utf-8"))

    def get_bucket_queue_length(self, bucket):
        return self.redis_client.llen(f"{config['visual_debugger']['redis_key_prefix']}:{bucket}")

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpush [as 别名]
 def perform_action(self, request, *args, **kwargs):
     action_item = ActionItem()
     action_item.comment = str(self.request.POST.get('comment'))
     r = StrictRedis(settings.REDIS_HOST,
                     settings.REDIS_PORT,
                     settings.REDIS_DB)
     if self.request.POST.get('update_field'):
         index = self.request.POST.get('update_field')
         original = pickle.loads(
             r.lindex('users:{}:action.items'.format(self.request.user.id),
                      index))
         original.comment = action_item.comment
         r.lset('users:{}:action.items'.format(self.request.user.id),
                index, pickle.dumps(original))
     else:
         action_item.created = timezone.datetime.now()
         r.lpush('users:{}:action.items'.format(self.request.user.id),
                 pickle.dumps(action_item))

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpush [as 别名]
 def test_filled_list_contents(self) -> None:
     """
     Test if there are entries in the list (does the preparation work as expected?)
     """
     fill_items = (
         'item_1',
         'item_2',
         'item_three',
     )
     redis_filler = StrictRedis(connection_pool=self.__pool)
     for item in fill_items:
         redis_filler.lpush(self.__config['queue'], item)
     rqa = RedisQueueAccess(self.__config)
     redis_receiver = StrictRedis(connection_pool=rqa.create_redis_connection_pool())
     for item in fill_items:
         data = redis_receiver.rpop(rqa.queue)
         self.assertEqual(bytes(item, encoding='UTF-8'), data)
     self.assertIsNone(redis_receiver.rpop(rqa.queue))

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

    def __init__(self, project_key=None):
        if project_key is None:
            raise AnalyticsClientError("'project_key' kwarg is expected...")

        self.project_key = project_key
        self.redis_client = StrictRedis(**config["redis"])

    @property
    def redis_key(self):
        return f"SERPENT:{self.project_key}:EVENTS"

    def track(self, event_key=None, data=None):
        event = {
            "project_key": self.project_key,
            "event_key": event_key,
            "data": data,
            "timestamp": datetime.utcnow().isoformat()
        }

        self.redis_client.lpush(self.redis_key, json.dumps(event))

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpush [as 别名]
class JobSyncTest(TestCase):
    def setUp(self):
        self.redis = StrictRedis(**settings.REDISES['default'])
        self.sync = JobSync(self.redis)
        self.key  = 'queue_job_changes'

    def tearDown(self):
        self.redis.delete(self.key)

    def test_notifier(self):
        self.assertFalse(self.sync.has_notifier())
        self.redis.lpush(self.key, '1||add||None')
        self.assertTrue(self.sync.has_notifier())

    def test_push(self):
        self.assertFalse(self.sync.has_notifier())
        self.sync.push(1, 'add')
        self.assertTrue(self.sync.has_notifier())

    def test_pop(self):
        self.assertFalse(self.sync.has_notifier())

        timezone = tz.gettz('Asia/Chongqing')
        now = datetime.now(timezone)
        item = self.sync.pop(now)
        self.assertEqual(0, item[0])

        self.sync.push(1, 'add')
        self.assertTrue(self.sync.has_notifier())
        item = self.sync.pop(now)
        self.assertFalse(self.sync.has_notifier())
        self.assertEqual(1, item[0])
        self.assertEqual('add', item[1])

    def test_handle(self):
        pass

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpush [as 别名]
class QueueClient(object):
    """Interface to a Redis queue/hashmap combo for managing account sync
    allocation.
    """

    # Lua scripts for atomic assignment and conflict-free unassignment.
    ASSIGN = """
    local k = redis.call('RPOP', KEYS[1])
    if k then
        local s = redis.call('HSETNX', KEYS[2], k, ARGV[1])
        if s then
            return k
        end
    end"""

    UNASSIGN = """
    if redis.call('HGET', KEYS[1], KEYS[2]) == ARGV[1] then
        return redis.call('HDEL', KEYS[1], KEYS[2])
    else
        return 0
    end
    """

    def __init__(self, zone):
        self.zone = zone
        redis_host = config["ACCOUNT_QUEUE_REDIS_HOSTNAME"]
        redis_db = config["ACCOUNT_QUEUE_REDIS_DB"]
        self.redis = StrictRedis(
            host=redis_host, db=redis_db, socket_connect_timeout=SOCKET_CONNECT_TIMEOUT, socket_timeout=SOCKET_TIMEOUT
        )

    def all(self):
        """
        Returns all keys being tracked (either pending in the queue, or
        already assigned).
        """
        p = self.redis.pipeline(transaction=True)
        p.hgetall(self._hash)
        p.lrange(self._queue, 0, -1)
        unassigned, assigned = p.execute()
        return {int(k) for k in itertools.chain(unassigned, assigned)}

    def assigned(self):
        """
        Returns a dictionary of all currently assigned key/value pairs (keys
        are coerced to integers).
        """
        return {int(k): v for k, v in self.redis.hgetall(self._hash).items()}

    def enqueue(self, key):
        """
        Adds a new key onto the pending queue.
        """
        self.redis.lpush(self._queue, key)

    def claim_next(self, value):
        """
        Pulls the next key off of the pending queue (if any exists), and sets
        it to `value` in the hash. Returns None if the queue is empty or if the
        key is already present in the hash; otherwise returns the key.
        """
        s = self.redis.register_script(self.ASSIGN)
        return s(keys=[self._queue, self._hash], args=[value])

    def unassign(self, key, value):
        """
        Removes `key` from the hash, if and only if it is present and set to
        `value` (to prevent removing a key actually assigned to someone else).
        """
        s = self.redis.register_script(self.UNASSIGN)
        return s(keys=[self._hash, key], args=[value])

    def qsize(self):
        """
        Returns current length of the queue.
        """
        return self.redis.llen(self._queue)

    @property
    def _queue(self):
        return "unassigned_{}".format(self.zone)

    @property
    def _hash(self):
        return "assigned_{}".format(self.zone)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpush [as 别名]
class KeyValueStore(object):
    def __init__(self):
        self.data = StrictRedis(host = settings.redis.server.host, port = settings.redis.server.port)
        log.debug("Connected to REDIS(%s, %s)" % (settings.redis.server.host, settings.redis.server.port))

    def _get_value(self, key):
        return self.data.get(key)

    def _set_value(self, key, value, seconds=None):
        self.data.set(key, value)
        if seconds is not None:
            self.data.expire(key, seconds)

    def _delete_key(self, key):
        self.data.delete(key)

    def _search_keys(self, pattern):
        return self.data.keys(pattern)

    def _get_model(self, model_pf, model_id):
        value = self._get_value(model_pf+model_id)
        if value is None:
            return None
        return Struct(loads(self._get_value(model_pf+model_id)))

    def _set_model(self, model_pf, model_id, model_value, seconds=None):
        self._set_value(model_pf+model_id, dumps(model_value, default=datetime_serializer), seconds)

    def _list_model(self, model_pf):
        return [Struct(loads(self._get_value(key))) for key in self._search_keys(model_pf+'*')]

    def _get_list_models(self, list_pf, list_id):
        return [Struct(loads(value)) for value in self.data.lrange(list_pf+list_id, 0, -1)]

    def _get_list_scalars(self, list_pf, list_id):
        return [value for value in self.data.lrange(list_pf+list_id, 0, -1)]

    def _pop_list_scalars(self, list_pf, list_id):
        scalars = []
        scalar = True

        while scalar:
            scalar=self.data.lpop(list_pf+list_id)
            if scalar:
                scalars += [scalar]

        return scalars

    def _push_list(self, list_pf, list_id, model_value, trim_count):
        if not isinstance(model_value, unicode):
            model_value = dumps(model_value)

        self.data.lpush(list_pf+list_id, model_value)
        self.data.ltrim(list_pf+list_id, 0, MAX_STAT_ITEMS-1)

    # Devices

    def get_device(self, mac_address):
        return self._get_model(DEVICE_PF, mac_address.replace(":","").upper())

    def set_device(self, mac_address, device):
        self._set_model(DEVICE_PF, mac_address.replace(":","").upper(), device)

    def delete_device(self, mac_address):
        self._delete_key(DEVICE_PF+mac_address.replace(":","").upper())
        self._delete_key(ASSETLIST_PF+mac_address.replace(":","").upper())

    def list_devices(self):
        return self._list_model(DEVICE_PF)

    # Assets

    def get_asset(self, guid):
        return self._get_model(ASSET_PF, guid)

    def set_asset(self, guid, asset):
        self._set_model(ASSET_PF, guid, asset)

    def delete_asset(self, guid):
        self._delete_key(ASSET_PF+guid)

    def list_assets(self):
        return self._list_model(ASSET_PF)

    # Playlists

    def get_playlist(self, name):
        return self._get_model(PLAYLIST_PF, name)

    def set_playlist(self, name, playlist):
        self._set_model(PLAYLIST_PF, name, playlist)

    def delete_playlist(self, name):
        self._delete_key(PLAYLIST_PF+name)

    def list_playlists(self):
        return self._list_model(PLAYLIST_PF)

    # Stats

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

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

#.........这里部分代码省略.........
        sub = self.subs[job_id]

        for msg in sub.listen():
            if str(msg['data']) == 'EOF':
                break
            else:
                yield self._read_jsonlog(msg['data'], append_ts=timestamp)

    def get_stored_log(self, job_id, timestamp=True):
        """
        Return the stored output of a given job id
        params:
         - timestamp(bool): prefix lines with timestamp. default True.
        """
        logs = self.redis.lrange(self._key('log', job_id), 0, -1)
        return [ self._read_jsonlog(l,append_ts=timestamp) for \
                 l in reversed(logs) ]

    def append_job_log(self, job_id, text):
        """
        Append a line of job output to a redis list and
        publish to relevant channel
        """
        key = self._key('log', job_id)

        #split up the line if carriage returns, newlines
        if len(text.splitlines()) > 1:
            for line in text.splitlines():
                self.append_job_log(job_id, line)
        else:
            if not text.isspace(): #don't keep empty lines
                logjson = self._jsonlog(text)
                self.redis.publish(key, logjson)
                self.redis.lpush(key, logjson)

    @staticmethod
    def _read_jsonlog(jsonlog, append_ts=True):
        ts,msg = json.loads(jsonlog)
        if not append_ts:
            return msg
        return '[%s] %s' % (ts, msg)

    @staticmethod
    def _jsonlog(msg):
        ts = datetime.utcnow().strftime('%a %b %d %H:%M:%S %Y')
        return json.dumps((ts, msg))

    def _subscribe_to_log(self, job_id):
        """ Subscribe this db object to a jobs log channel by ID """
        key = self._key('log', job_id)

        sub = self.redis.pubsub(ignore_subscribe_messages=True)
        sub.subscribe(key)
        self.subs[job_id] = sub

        log.debug('Subscribed to log channel: %s' % key)

    #######
    # Action Methods
    #######

    def get_action(self, action_name):
        """
        Return a single action dict, given the action name
        """
        return self.redis.hgetall(self._key('action', action_name))