Python StrictRedis.lpop方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpop [as 别名]
def get_mail_from_redis(num=10):
    r = StrictRedis('127.0.0.1', 6379)
    key = "QQMAIL"
    mail_list = r.lrange(key, 0, num)
    for i in range(num):
        r.lpop(key)
    return set(mail_list)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpop [as 别名]
    def test_Redis(self):
        host = "localhost"
        r = StrictRedis(host, socket_timeout=60)
        msg = "Hello world"

        r.delete("channel")
        r.rpush("channel", msg)
        m = r.lpop("channel")
        print m
        assert(m == msg)

        r.rpush("channel", [1, 2, 3])
        m = ast.literal_eval(r.lpop("channel"))
        print m, type(m)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpop [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 lpop [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 lpop [as 别名]
 def test_empty_list_contents_internal(self) -> None:
     """
     Test if there comes nothing back when the list is empty (does the preparation work as expected?)
     """
     rqa = RedisQueueAccess(self.__config)
     redis = StrictRedis(connection_pool=rqa.create_redis_connection_pool())
     data = redis.lpop(rqa.queue)
     self.assertIsNone(data)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpop [as 别名]
 def test_empty_list_contents_external(self) -> None:
     """
     Test if there comes nothing back when the list is empty (does the preparation work as expected?)
     """
     RedisQueueAccess(self.__config)
     redis = StrictRedis(connection_pool=self.__pool)
     data = redis.lpop(self.__config['queue'])
     self.assertIsNone(data)

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpop [as 别名]
class RedisQueue():
    def __init__(self):
        """
        初始化Redis
        """
        self.db = StrictRedis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD)

    def add(self, request):
        """
        向队列添加序列化后的Request
        :param request: 请求对象
        :return: 添加结果
        """
        if isinstance(request, WeixinRequset):
            return self.db.rpush(REDIS_KEY, dumps(request))
        return False

    def pop(self):
        """
        取出下一个Request并反序列化
        :return: Request or None
        """
        if self.db.llen(REDIS_KEY):
            return loads(self.db.lpop(REDIS_KEY))
        else:
            return False

    def clear(self):
        self.db.delete(REDIS_KEY)

    def empty(self):
        """
        检查是否为空
        :return:
        """
        return self.db.llen(REDIS_KEY) == 0

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpop [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 lpop [as 别名]
class RedisHelper:
    prefix = "bc:chart:cache"

    def __init__(self, host=None, port=None, prefix=None):
        # 这里读取redis配置信息，用到了conf.py里面的函数
        self._host = host
        self._port = int(port)
        self._redis = StrictRedis(host=self._host, port=self._port)

    def gen_key(self, chart_id):
        return "%s:%s" % (self.prefix, chart_id)

    def put(self, chart_id, data, expire=2000):
        key = self.gen_key(chart_id)
        self._redis.set(key, dumps(data))
        self._redis.expire(key, expire)
        return True

    def delete(self, chart_id):
        key = self.gen_key(chart_id)
        self._redis.delete(key)

    def deleteN(self, chart_id):
        key = self.gen_key(chart_id)
        keys = self._redis.keys("%s*" % key)
        for k in keys:
            self._redis.delete(k)

    def get(self, chart_id):
        key = self.gen_key(chart_id)
        data = self._redis.get(key)
        return {} if not data else loads(data)

    def hset(self, key, field, value):
        self._redis.hset(key, field, value)

    def hmget(self, key, fields):
        return self._redis.hmget(key, fields)

    def flush(self):
        keys = self._redis.keys("%s*" % self.prefix)
        pipe = self._redis.pipeline()
        for key in keys:
            pipe.delete(key)
        pipe.execute()

    # the type of value is list
    def list_push(self, key, data):
        return self._redis.rpush(key, dumps(data))
    # pop the head element of the list

    def list_pop(self, key):
        return self._redis.lpop(key)

    # pop all elements of the list
    def list_all_pop(self, key):
        while True:
            if self.list_size(key) == 0:
                self._redis.delete(key)
                break
            res = self._redis.lpop(key)
            if res:
                yield loads(res)

    # the length of list
    def list_size(self, key):
        return self._redis.llen(key)

    @property
    def redis(self):
        return self._redis

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import lpop [as 别名]
class JSONRedisBackend(BaseBackend):
    def initialize(self):
        conf = env.get_uri("LINEUP_REDIS_URI")

        self.redis = StrictRedis(
            db=conf.username or 0,
            host=conf.host,
            port=conf.port,
            # using `path` as password to support the URI like:
            # redis://[email protected]:port/veryverylongpasswordhash
            password=conf.path,
        )

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

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

    # read operations
    @io_operation
    def get(self, key):
        value = self.redis.get(key)
        result = self.deserialize(value)
        return result

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

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

    @io_operation
    def lrange(self, key, start, stop):
        return map(self.deserialize, self.redis.lrange(key, start, stop))

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

    # Write operations
    @io_operation
    def set(self, key, value):
        product = self.serialize(value)
        return self.redis.set(key, product)

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

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

    # Pipeline operations
    @io_operation
    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 lpop [as 别名]
class TaskTestCase(DjangoAtomicCeleryTestCaseMixin, TestCase):
    """Test case for tasks.
    """

    def setUp(self):
        super(TaskTestCase, self).setUp()

        # Set up Redis and clear the Celery key.
        self.redis = StrictRedis(settings.REDIS_HOST,
                                 settings.REDIS_PORT,
                                 settings.REDIS_DATABASE)
        self.redis.delete('celery')

    def assertNoScheduled(self):
        """Assert that no tasks are scheduled.
        """

        actual_task_count = self.redis.llen('celery')
        self.assertEqual(actual_task_count, 0)

    def assertScheduled(self, tasks):
        """Assert a specific number of tasks are scheduled.

        :param tasks:
            iterable of :class:`tuple` instances of
            ``(<task name>, <args>, <kwargs>)``.
        """

        actual_task_count = self.redis.llen('celery')
        self.assertEqual(actual_task_count, len(tasks))

        for t in tasks:
            raw_message = self.redis.lpop('celery')
            message = json.loads(raw_message)
            raw_body = base64.b64decode(message[u'body'])
            body = pickle.loads(raw_body)

            expected_name, expected_args, expected_kwargs = t
            self.assertEqual(body['task'], expected_name)
            if expected_args is not None:
                self.assertEqual(tuple(body['args']), tuple(expected_args))
            else:
                # args was not provided, compare with expected default
                self.assertEqual(tuple(body['args']), ())
            if expected_kwargs is not None:
                self.assertEqual(body['kwargs'], expected_kwargs)
            else:
                # kwargs was not provided, compare with expected default
                self.assertEqual(body['kwargs'], {})

    def _test_behavior(self, call, args=None, kwargs=None):
        # Task delayed outside transaction block is scheduled immediately.
        self.assertNoScheduled()
        if kwargs is None and args is None:
            call()
        elif kwargs is not None and args is None:
            call(kwargs=kwargs)
        elif kwargs is None and args is not None:
            call(args=args)
        else:
            call(args=args, kwargs=kwargs)
        self.assertScheduled([('tests.tasks.task', args, kwargs)])

        # Task delayed inside successful atomic transaction block is scheduled
        # after outermost transaction block is left.
        self.assertNoScheduled()
        with transaction.atomic():
            call(args, kwargs)
            self.assertNoScheduled()
        self.assertScheduled([('tests.tasks.task', args, kwargs)])

        self.assertNoScheduled()
        with transaction.atomic():
            call(args, kwargs)
            self.assertNoScheduled()
            with transaction.atomic():
                call(args, kwargs)
                self.assertNoScheduled()
            self.assertNoScheduled()
        self.assertScheduled([('tests.tasks.task', args, kwargs),
                              ('tests.tasks.task', args, kwargs)])

        # Task delayed inside failed atomic transaction block is not scheduled.
        self.assertNoScheduled()
        with self.assertRaises(ValueError):
            with transaction.atomic():
                call(args, kwargs)
                raise ValueError('Testing')
        self.assertNoScheduled()

        self.assertNoScheduled()
        with transaction.atomic():
            call(args, kwargs)
            with self.assertRaises(ValueError):
                with transaction.atomic():
                    call(args, kwargs)
                    raise ValueError('Testing')
            self.assertNoScheduled()
        self.assertScheduled([('tests.tasks.task', args, kwargs)])

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