本文整理汇总了Python中redis.StrictRedis.delete方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.delete方法的具体用法?Python StrictRedis.delete怎么用?Python StrictRedis.delete使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.delete方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import delete [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)
示例2: zset_score_min_max_example
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import delete [as 别名]
def zset_score_min_max_example():
""" Example sorted set with min/max score pagination.
"""
from uuid import uuid4
from redis import StrictRedis
from zato.redis_paginator import ZSetPaginator
conn = StrictRedis()
key = 'paginator:{}'.format(uuid4().hex)
# 97-114 is 'a' to 'r' in ASCII
for x in range(1, 18):
conn.zadd(key, x, chr(96 + x))
p = ZSetPaginator(conn, key, 2, score_min=5, score_max=13)
print(p.count) # 9
print(p.num_pages) # 5
print(p.page_range) # [1, 2, 3, 4, 5]
page = p.page(3)
print(page) # <Page 3 of 5>
print(page.object_list) # ['i', 'j']
conn.delete(key)
示例3: RedisJobStore
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import delete [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__
示例4: CacheHelper
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import delete [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)
示例5: __admin_handler
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import delete [as 别名]
def __admin_handler(self, endpoint: bytes):
"""
Handle Admin Request
:param bytes endpoint: Endpoint (in bytes!)
:return: jsonified answer data
"""
json_data = request.get_json()
if json_data is None:
raise BadRequest()
if 'admin_token' not in json_data:
raise BadRequest()
admin_token = json_data['admin_token']
if not isinstance(admin_token, str):
raise BadRequest()
if not RULE_TOKEN.match(admin_token):
raise BadRequest()
redis = StrictRedis(connection_pool=self.api_pool)
ep_key = 'ADMIN_TOKEN:{:s}'.format(admin_token)
should_endpoint = redis.get(ep_key)
if should_endpoint is None:
raise BadRequest()
redis.delete(ep_key)
if should_endpoint != endpoint:
raise BadRequest()
if 'data' not in json_data:
raise BadRequest()
data = json_data['data']
if not isinstance(data, dict):
raise BadRequest()
return jsonify(self.queue_dispatcher({
'_': 'admin:{:s}'.format(endpoint.decode('utf-8')),
'data': data,
}))
示例6: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import delete [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)
示例7: zset_example
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import delete [as 别名]
def zset_example():
""" Example sorted set pagination.
"""
from uuid import uuid4
from redis import StrictRedis
from zato.redis_paginator import ZSetPaginator
conn = StrictRedis()
key = 'paginator:{}'.format(uuid4().hex)
# 97-114 is 'a' to 'r' in ASCII
for x in range(1, 18):
conn.zadd(key, x, chr(96 + x))
p = ZSetPaginator(conn, key, 6)
print(p.count) # 17
print(p.num_pages) # 3
print(p.page_range) # [1, 2, 3]
page = p.page(3)
print(page) # <Page 3 of 3>
print(page.object_list) # ['m', 'n', 'o', 'p', 'q']
conn.delete(key)
示例8: RedisDataStore
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import delete [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()
示例9: init_redis_for_testing_cruncher
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import delete [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())
示例10: post_updates
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import delete [as 别名]
def post_updates(self, updates, log_index):
'''
Update the cache with CRUD changes
'''
cache = StrictRedis(db=config.tokens_cache_redis_db)
self.log.info('post_updates(): posting updates to local storage')
for update in updates: # TODO: could re-add the Redis "Pipelines" feature to combine Redis requests for better performance when available
(user, token, date, action) = update
if action == 'add':
cache.hset('general', token, user) # future method - user-by-token -- really just existence of a token
cache.hset('users', user, token) # future-method - token-by-user: allow lookup of previous token on token changes
cache.set(token, user) # Current method
self.log.info('post_updates(): added token for user: ' + user)
elif action == 'delete':
cache.hdel('general', token) # future method - disables the ability to authenticate
cache.hdel('users', user) # future method - removes history of token
cache.delete(token)
self.log.info('post_updates(): deleted token for user: ' + user)
elif action == 'update':
prev_token = cache.hget('users', user)
cache.hdel('general', prev_token) # future method - disables the ability to authenticate with previous token
cache.hset('general', token, user) # future method - set the new token for the user
cache.hset('users', user, token) # future method - set the user as possessing the new token
cache.set(token, user)
self.log.info('post_updates(): updated token for user: ' + user)
else:
self.log.critical('post_updates(): unexpected change type: ' + action)
if len(updates) > 0: # don't set if there is nothing to do and also don't set if there are errors
cache.set('log_index', log_index)
示例11: JobStatsTest
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import delete [as 别名]
class JobStatsTest(TestCase):
def setUp(self):
self.redis = StrictRedis(**settings.REDISES['default'])
self.stats = JobStats(self.redis)
def tearDown(self):
self.redis.delete('job_stats.1')
def testIncr(self):
job_id = 1
field = 'success'
count = self.stats.get(job_id, field)
self.assertEqual(0, count)
self.stats.incr(job_id, field, 1)
count = self.stats.get(job_id, field)
self.assertEqual(1, count)
self.stats.incr(job_id, field, 2)
count = self.stats.get(job_id, field)
self.assertEqual(3, count)
self.stats.incr(job_id, 'failed')
self.stats.get(job_id, field)
self.assertEqual(3, count)
def testGet(self):
job_id = 1
self.stats.incr(job_id, 'failed', 1)
self.stats.incr(job_id, 'success', 2)
counts = self.stats.get(job_id)
self.assertEqual(1, counts['failed'])
self.assertEqual(2, counts['success'])
示例12: test_group_chord_group_chain
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import delete [as 别名]
def test_group_chord_group_chain(self, manager):
from celery.five import bytes_if_py2
if not manager.app.conf.result_backend.startswith('redis'):
raise pytest.skip('Requires redis result backend.')
redis_connection = StrictRedis()
redis_connection.delete('redis-echo')
before = group(redis_echo.si('before {}'.format(i)) for i in range(3))
connect = redis_echo.si('connect')
after = group(redis_echo.si('after {}'.format(i)) for i in range(2))
result = (before | connect | after).delay()
result.get(timeout=TIMEOUT)
redis_messages = list(map(
bytes_if_py2,
redis_connection.lrange('redis-echo', 0, -1)
))
before_items = \
set(map(bytes_if_py2, (b'before 0', b'before 1', b'before 2')))
after_items = set(map(bytes_if_py2, (b'after 0', b'after 1')))
assert set(redis_messages[:3]) == before_items
assert redis_messages[3] == b'connect'
assert set(redis_messages[4:]) == after_items
redis_connection.delete('redis-echo')
示例13: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import delete [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)
示例14: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import delete [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)
示例15: do_deletes
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import delete [as 别名]
def do_deletes():
"""DELETE"""
db_pipe = StrictRedis().pipeline()
print 'performing a few deletes...'
del_keys = (260, 271, 285, 300, 310)
for key in del_keys:
db_pipe.delete(key)
print 'db_pipe.command_stack:\n{}'.format(db_pipe.command_stack)
db_pipe.execute()