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