本文整理汇总了Python中redis.StrictRedis.keys方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.keys方法的具体用法?Python StrictRedis.keys怎么用?Python StrictRedis.keys使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.keys方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: CacheHelper
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import keys [as 别名]
class CacheHelper(object):
"""A thin wrapper on top of Redis."""
def __init__(self, host="localhost", port=6379, db=0):
self.host = host
self.port = port
self.db = db
def __enter__(self):
self.r = StrictRedis(host=self.host, port=self.port, db=self.db)
return self
def __exit__(self, exc_type, exc_value, traceback):
try:
if any((exc_type, exc_value, traceback,)):
raise
finally:
pass
def get(self, key):
return self.r.get(key) if key in self.r.keys() else None
def set(self, key, json):
self.r.set(key, json)
def keys(self):
return self.r.keys()
def reset(self):
for key in self.keys():
self.r.delete(key)
示例2: delete_all_keys
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import keys [as 别名]
def delete_all_keys(request):
rd = StrictRedis()
print "now deleting keys"
pref = settings.MY_PREFIX
mydict = rd.keys(pref+"*")
mydict = mydict + rd.keys('ws:broadcast*')
for k in mydict:
resp = rd.delete(k)
print "deleted:",k
return HttpResponse("check terminal to see what keys were deleted<br><a href = '"+reverse('group')+"'>go back</a>")
示例3: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import keys [as 别名]
class RedisManager(NoSqlManager):
def __init__(self,
namespace,
url=None,
data_dir=None,
lock_dir=None,
**params):
self.db = params.pop('db', None)
self.dbpass = params.pop('password', None)
self.connection_pool = params.get('redis_connection_pool', None)
self.expires = params.get('expires', params.get('expiretime', None))
NoSqlManager.__init__(self,
namespace,
url=url,
data_dir=data_dir,
lock_dir=lock_dir,
**params)
def open_connection(self, host, port, **params):
if not self.connection_pool:
self.connection_pool = ConnectionPool(host=host, port=port, db=self.db,
password=self.dbpass)
self.db_conn = StrictRedis(connection_pool=self.connection_pool, **params)
def __contains__(self, key):
return self.db_conn.exists(self._format_key(key))
def set_value(self, key, value, expiretime=None):
key = self._format_key(key)
# beaker.container.Value.set_value calls NamespaceManager.set_value
# however it (until version 1.6.4) never sets expiretime param.
#
# Checking "type(value) is tuple" is a compromise
# because Manager class can be instantiated outside container.py (See: session.py)
if (expiretime is None) and (type(value) is tuple):
expiretime = value[1]
# If the machinery above fails, then pickup the expires time from the
# init params.
if not expiretime and self.expires is not None:
expiretime = self.expires
# Set or setex, according to whether we got an expires time or not.
if expiretime:
self.db_conn.setex(key, expiretime, pickle.dumps(value, 2))
else:
self.db_conn.set(key, pickle.dumps(value, 2))
def __delitem__(self, key):
self.db_conn.delete(self._format_key(key))
def _format_key(self, key):
return 'beaker:%s:%s' % (self.namespace, key.replace(' ', '\302\267'))
def _format_pool_key(self, host, port, db):
return '{0}:{1}:{2}'.format(host, port, self.db)
def do_remove(self):
self.db_conn.flush()
def keys(self):
return self.db_conn.keys('beaker:%s:*' % self.namespace)
示例4: RedisJobStore
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import keys [as 别名]
class RedisJobStore(JobStore):
def __init__(self, db=0, key_prefix="jobs.", pickle_protocol=pickle.HIGHEST_PROTOCOL, **connect_args):
self.jobs = []
self.pickle_protocol = pickle_protocol
self.key_prefix = key_prefix
if db is None:
raise ValueError('The "db" parameter must not be empty')
if not key_prefix:
raise ValueError('The "key_prefix" parameter must not be empty')
self.redis = StrictRedis(db=db, **connect_args)
def add_job(self, job):
job.id = str(uuid4())
job_state = job.__getstate__()
job_dict = {
"job_state": pickle.dumps(job_state, self.pickle_protocol),
"runs": "0",
"next_run_time": job_state.pop("next_run_time").isoformat(),
}
self.redis.hmset(self.key_prefix + job.id, job_dict)
self.jobs.append(job)
def remove_job(self, job):
self.redis.delete(self.key_prefix + job.id)
self.jobs.remove(job)
def load_jobs(self):
jobs = []
keys = self.redis.keys(self.key_prefix + "*")
pipeline = self.redis.pipeline()
for key in keys:
pipeline.hgetall(key)
results = pipeline.execute()
for job_dict in results:
job_state = {}
try:
job = Job.__new__(Job)
job_state = pickle.loads(job_dict["job_state".encode()])
job_state["runs"] = long(job_dict["runs".encode()])
dateval = job_dict["next_run_time".encode()].decode()
job_state["next_run_time"] = datetime.strptime(dateval, "%Y-%m-%dT%H:%M:%S")
job.__setstate__(job_state)
jobs.append(job)
except Exception:
job_name = job_state.get("name", "(unknown)")
logger.exception('Unable to restore job "%s"', job_name)
self.jobs = jobs
def update_job(self, job):
attrs = {"next_run_time": job.next_run_time.isoformat(), "runs": job.runs}
self.redis.hmset(self.key_prefix + job.id, attrs)
def close(self):
self.redis.connection_pool.disconnect()
def __repr__(self):
return "<%s>" % self.__class__.__name__
示例5: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import keys [as 别名]
class RedisManager(NoSqlManager):
def __init__(self,
namespace,
url=None,
data_dir=None,
lock_dir=None,
**params):
self.db = params.pop('db', None)
self.connection_pools = {}
NoSqlManager.__init__(self,
namespace,
url=url,
data_dir=data_dir,
lock_dir=lock_dir,
**params)
def open_connection(self, host, port, **params):
pool_key = self._format_pool_key(host, port, self.db)
if pool_key not in self.connection_pools:
self.connection_pools[pool_key] = ConnectionPool(host=host,
port=port,
db=self.db)
self.db_conn = StrictRedis(connection_pool=self.connection_pools[pool_key],
**params)
def __contains__(self, key):
return self.db_conn.exists(self._format_key(key))
def set_value(self, key, value, expiretime=None):
key = self._format_key(key)
#
# beaker.container.Value.set_value calls NamespaceManager.set_value
# however it (until version 1.6.4) never sets expiretime param.
#
# Checking "type(value) is tuple" is a compromise
# because Manager class can be instantiated outside container.py (See: session.py)
#
if (expiretime is None) and (type(value) is tuple):
expiretime = value[1]
if expiretime:
self.db_conn.setex(key, expiretime, pickle.dumps(value, 2))
else:
self.db_conn.set(key, pickle.dumps(value, 2))
def __delitem__(self, key):
self.db_conn.delete(self._format_key(key))
def _format_key(self, key):
return 'beaker:%s:%s' % (self.namespace, key.replace(' ', '\302\267'))
def _format_pool_key(self, host, port, db):
return '{0}:{1}:{2}'.format(host, port, self.db)
def do_remove(self):
self.db_conn.flush()
def keys(self):
return self.db_conn.keys('beaker:%s:*' % self.namespace)
示例6: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import keys [as 别名]
class Redis:
"""
To store and query local/remote Redis server.
"""
def __init__(self, host='localhost',
port=6379,
db=0,
password=None):
self.r = StrictRedis(host, port, db, password)
def __del__(self):
del(self.r)
def update(self, track):
self.r.set(track.key, track.stats())
def lookup(self, keyword):
# TODO: add option for caseless search
return self.r.keys('*' + keyword + '*')
def retrieve(self, key):
if isinstance(key, list):
return self.get_all(key)
return Track.from_redis(key, self.r.get(key))
def get_all(self, keys):
tracks = []
for key in keys:
tracks.append(Track.from_redis(key, self.r.get(key)))
return tracks
示例7: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import keys [as 别名]
class RedisManager(NoSqlManager):
def __init__(self, namespace, url=None, data_dir=None, lock_dir=None, **params):
self.connection_pool = params.pop('connection_pool', None)
NoSqlManager.__init__(self, namespace, url=url, data_dir=data_dir, lock_dir=lock_dir, **params)
def open_connection(self, host, port, **params):
self.db_conn = StrictRedis(host=host, port=int(port), connection_pool=self.connection_pool, **params)
def __contains__(self, key):
log.debug('%s contained in redis cache (as %s) : %s'%(key, self._format_key(key), self.db_conn.exists(self._format_key(key))))
return self.db_conn.exists(self._format_key(key))
def set_value(self, key, value, expiretime=None):
key = self._format_key(key)
#XXX: beaker.container.Value.set_value calls NamespaceManager.set_value
# however it(until version 1.6.3) never sets expiretime param. Why?
if expiretime:
self.db_conn.setex(key, expiretime, pickle.dumps(value))
else:
self.db_conn.set(key, pickle.dumps(value))
def __delitem__(self, key):
self.db_conn.delete(self._format_key(key))
def _format_key(self, key):
return 'beaker:%s:%s' % (self.namespace, key.replace(' ', '\302\267'))
def do_remove(self):
self.db_conn.flush()
def keys(self):
return self.db_conn.keys('beaker:%s:*' % self.namespace)
示例8: get_recent
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import keys [as 别名]
def get_recent(**redis_kwargs):
""" Retrieve recent messages from Redis, in reverse chronological order.
Two lists are returned: one a single most-recent status message from
each process, the other a list of numerous messages from each process.
Each message is a tuple with floating point seconds elapsed, integer
process ID that created it, and an associated text message such as
"Got cache lock in 0.001 seconds" or "Started /osm/12/656/1582.png".
Keyword args are passed directly to redis.StrictRedis().
"""
pid = getpid()
red = StrictRedis(**redis_kwargs)
processes = []
messages = []
for key in red.keys('pid-*-statuses'):
try:
now = time()
pid = int(key.split('-')[1])
msgs = [msg.split(' ', 1) for msg in red.lrange(key, 0, _keep)]
msgs = [(now - float(t), pid, msg) for (t, msg) in msgs]
except:
continue
else:
messages += msgs
processes += msgs[:1]
messages.sort() # youngest-first
processes.sort() # youngest-first
return processes, messages
示例9: RedisDataStore
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import keys [as 别名]
class RedisDataStore(DataStore):
"""Redis-backed datastore object."""
def __init__(self, number=0):
redis_host = os.environ.get('REDIS_PORT_6379_TCP_ADDR')
redis_port = os.environ.get('REDIS_PORT_6379_TCP_PORT')
self.redis_conn = StrictRedis(host=redis_host, port=redis_port,
db=number)
def __setitem__(self, k, v):
self.redis_conn.set(k, v)
def __getitem__(self, k):
return self.redis_conn.get(k)
def __delitem__(self, k):
self.redis_conn.delete(k)
def get(self, k):
return self.redis_conn.get(k)
def __contains__(self, k):
return self.redis_conn.exists(k)
def todict(self):
#TODO(tvoran): use paginate
#TODO(tvoran): do something besides multiple gets
data = {}
for key in self.redis_conn.keys():
data[key] = self.get(key)
return data
def clear_all(self):
self.redis_conn.flushdb()
示例10: test_MQClean
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import keys [as 别名]
def test_MQClean():
host = "localhost"
mq = MQStar(host)
redis = StrictRedis(host, socket_timeout=60)
clients = ["c1", "c2", "c3"]
mq.add_clients(clients)
mq.send_client("c1", "whatever")
rkeys = redis.keys("MQ_*")
assert rkeys
mq.clean()
rkeys = redis.keys("MQ_*")
assert not rkeys
示例11: SnapshotWriterTest
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import keys [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)
示例12: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import keys [as 别名]
class RedisManager(NoSqlManager):
connection_pools = {}
def __init__(self, namespace, url=None, data_dir=None, lock_dir=None, **params):
self.db = params.pop("db", None)
self.dbpass = params.pop("password", None)
NoSqlManager.__init__(self, namespace, url=url, data_dir=data_dir, lock_dir=lock_dir, **params)
def open_connection(self, host, port, **params):
pool_key = self._format_pool_key(host, port, self.db)
if pool_key not in self.connection_pools:
self.connection_pools[pool_key] = ConnectionPool(host=host, port=port, db=self.db, password=self.dbpass)
self.db_conn = StrictRedis(connection_pool=self.connection_pools[pool_key], **params)
def __contains__(self, key):
return self.db_conn.exists(self._format_key(key))
def set_value(self, key, value, expiretime=None):
key = self._format_key(key)
#
# beaker.container.Value.set_value calls NamespaceManager.set_value
# however it (until version 1.6.4) never sets expiretime param.
#
# Checking "type(value) is tuple" is a compromise
# because Manager class can be instantiated outside container.py (See: session.py)
#
if (expiretime is None) and (type(value) is tuple):
expiretime = value[1]
if self.serializer == "json":
serialized_value = json.dumps(value, ensure_ascii=True)
else:
serialized_value = pickle.dumps(value, 2)
if expiretime:
self.db_conn.setex(key, expiretime, serialized_value)
else:
self.db_conn.set(key, serialized_value)
def __delitem__(self, key):
self.db_conn.delete(self._format_key(key))
def _format_key(self, key):
return "beaker:%s:%s" % (self.namespace, key.replace(" ", "\302\267"))
def _format_pool_key(self, host, port, db):
return "{0}:{1}:{2}".format(host, port, self.db)
def do_remove(self):
for key in self.keys():
self.db_conn.delete(key)
def keys(self):
return self.db_conn.keys("beaker:%s:*" % self.namespace)
示例13: fin
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import keys [as 别名]
def fin():
rdb = StrictRedis(host=rdconf['host'], port=rdconf['port'],
db=rdconf['db'])
keys = rdb.keys()
aclog.warning('[RBACKEND FINISH] %s - %s', keys, len(keys))
aclog.warning('[RBACKEND FINISH] module %s, function: %s',
request.module, request.function)
if keys:
rv = rdb.delete(*keys)
aclog.warning('[RBACKEND CLEAN UP] deleted %s items.', rv)
示例14: TestTasksMarkedForContribution
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import keys [as 别名]
class TestTasksMarkedForContribution(object):
def setUp(self):
self.connection = StrictRedis()
self.connection.flushall()
@patch('pybossa.api.get_user_id_or_ip')
def test_mark_task_as_requested_by_user_creates_key_for_auth(self, user):
"""When an authenticated user requests a task, a key is stored in Redis
with his id and task id"""
user.return_value = {'user_id': 33, 'user_ip': None}
task = Task(id=22)
key = 'pybossa:task_requested:user:33:task:22'
mark_task_as_requested_by_user(task, self.connection)
assert key in self.connection.keys(), self.connection.keys()
@patch('pybossa.api.get_user_id_or_ip')
def test_mark_task_as_requested_by_user_creates_key_for_anon(self, user):
"""When an anonymous user requests a task, a key is stored in Redis
with his IP and task id"""
user.return_value = {'user_id': None, 'user_ip': '127.0.0.1'}
task = Task(id=22)
key = 'pybossa:task_requested:user:127.0.0.1:task:22'
mark_task_as_requested_by_user(task, self.connection)
assert key in self.connection.keys(), self.connection.keys()
@patch('pybossa.api.get_user_id_or_ip')
def test_mark_task_as_requested_by_user_sets_expiration_for_key(self, user):
"""When a user requests a task, a key is stored with TTL of 1 hour"""
user.return_value = {'user_id': 33, 'user_ip': None}
task = Task(id=22)
key = 'pybossa:task_requested:user:33:task:22'
mark_task_as_requested_by_user(task, self.connection)
assert self.connection.ttl(key) == 60 * 60, self.connection.ttl(key)
示例15: find_empty_redis_database
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import keys [as 别名]
def find_empty_redis_database():
"""Tries to connect to a random Redis database (starting from 4), and
will use/connect it when no keys are in there.
"""
for dbnum in range(4, 17):
testconn = StrictRedis(db=dbnum)
empty = len(testconn.keys('*')) == 0
if empty:
return testconn
assert False, 'No empty Redis database found to run tests in.'