本文整理汇总了Python中redis.StrictRedis.lpop方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.lpop方法的具体用法?Python StrictRedis.lpop怎么用?Python StrictRedis.lpop使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.lpop方法的11个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: get_mail_from_redis
# 需要导入模块: 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)
示例2: test_Redis
# 需要导入模块: 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)
示例3: JSONRedisBackend
# 需要导入模块: 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
示例4: DbRedis
# 需要导入模块: 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)
示例5: test_empty_list_contents_internal
# 需要导入模块: 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)
示例6: test_empty_list_contents_external
# 需要导入模块: 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)
示例7: RedisQueue
# 需要导入模块: 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
示例8: KeyValueStore
# 需要导入模块: 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
#.........这里部分代码省略.........
示例9: __init__
# 需要导入模块: 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
示例10: JSONRedisBackend
# 需要导入模块: 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
示例11: TaskTestCase
# 需要导入模块: 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)])
#.........这里部分代码省略.........