本文整理汇总了Python中redis.StrictRedis.flushdb方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.flushdb方法的具体用法?Python StrictRedis.flushdb怎么用?Python StrictRedis.flushdb使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.flushdb方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: test_lshash_redis_extra_val
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
def test_lshash_redis_extra_val():
"""
Test external lshash module
"""
config = {"redis": {"host": 'localhost', "port": 6379, "db": 15}}
sr = StrictRedis(**config['redis'])
sr.flushdb()
lsh = LSHash(6, 8, 1, config)
for i in xrange(num_elements):
lsh.index(list(els[i]), el_names[i])
lsh.index(list(els[i]), el_names[i]) # multiple insertions
hasht = lsh.hash_tables[0]
itms = [hasht.get_list(k) for k in hasht.keys()]
for itm in itms:
assert itms.count(itm) == 1
for el in itm:
assert el[0] in els
assert el[1] in el_names
for el in els:
res = lsh.query(list(el), num_results=1, distance_func='euclidean')[0]
# vector an name are in the first element of the tuple res[0]
el_v, el_name = res[0]
# the distance is in the second element of the tuple
el_dist = res[1]
assert el_v in els
assert el_name in el_names
assert el_dist == 0
del lsh
sr.flushdb()
示例2: RedisDataStore
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [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()
示例3: test
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
def test((t, duration, type_)):
conn = StrictRedis()
conn.flushdb()
ret = []
def run():
iterations = 0
signal.setitimer(signal.ITIMER_REAL, int(sys.argv[1]))
try:
if type_ == 'redis_lock':
while True:
with Lock(conn, "test-lock", expire=5):
iterations += 1
time.sleep(duration)
elif type_ == 'native':
while True:
with conn.lock("test-lock", timeout=5):
iterations += 1
time.sleep(duration)
except:
logging.info("Got %r. Returning ...", sys.exc_value)
ret.append(iterations)
sched = scheduler(time.time, time.sleep)
logging.info("Running in %s seconds ...", t - time.time())
sched.enterabs(t, 0, run, ())
sched.run()
return ret[0]
示例4: drop_database
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
def drop_database(db_name, redis_database=0):
mongo_client = MongoClient()
db = getattr(mongo_client, db_name)
db.client.drop_database(db_name)
redis_client = StrictRedis(db=redis_database)
redis_client.flushdb()
示例5: IndexCache
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
class IndexCache(object):
def __init__(self, host, port):
self.client = StrictRedis(host=host, port=port, db=0)
def build(self, doc_word_scores):
"""Clears the entire store and adds all the doc_word_scores into a
hash table in the store.
:param doc_word_scores: dictionary of dictionaries that looks like:
doc_word_scores[word][doc_id] = score of word in that
document
"""
self.reset()
for word, doc_id_score in doc_word_scores.items():
# Add table name to word
word_key = DOCUMENT_WORD_SCORE_NAME + word
self.client.hmset(word_key, doc_id_score)
self.save_to_disk()
def reset(self):
"""Deletes all keys in this DB.
"""
self.client.flushdb()
def save_to_disk(self):
"""Asyncronous write to disk for persistent storage.
"""
self.client.bgsave()
def to_dict(self):
"""Returns the "doc_word_scores" table in Redis in dictionary form.
"""
doc_word_scores = {}
for word_key in self.doc_word_scores_iter():
# Remove the table name from the key
word = word_key.replace(DOCUMENT_WORD_SCORE_NAME, "")
# Grab the {doc_ids : scores} dictionary for word
doc_word_scores[word] = self.client.hgetall(word_key)
return doc_word_scores
def doc_word_scores_iter(self):
"""Returns an iterator for the keys of all the words stored in Redis
"""
return self.client.scan_iter(match=DOCUMENT_WORD_SCORE_NAME + "*")
def is_empty(self):
return self.client.dbsize() <= 0
def doc_scores(self, word):
"""Returns a hash table of document_ids mapping to scores
"""
word_key = DOCUMENT_WORD_SCORE_NAME + word
return self.client.hgetall(word_key)
示例6: SutroTestCase
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
class SutroTestCase(TestCase):
def setUp(self):
redis_connection_pool = ConnectionPool(**settings.WS4REDIS_CONNECTION)
self.redis = StrictRedis(connection_pool=redis_connection_pool)
self.client = Client()
def tearDown(self):
self.redis.flushdb()
def random_string(self, length=None, str_type=None):
DEFAULT_LENGTH = 10
length = length if length else DEFAULT_LENGTH
if str_type == 'number':
string_type = string.digits
else:
string_type = string.lowercase
return ''.join(random.choice(string_type) for x in range(length))
def create_a_user(self, display_name, user_id=None, icon_url=None, user_url=None, rdio_key=None):
user = User()
user.display_name = display_name
user.id = user_id if user_id else uuid.uuid4().hex
user.icon_url = icon_url if icon_url else 'http://' + self.random_string() + '.jpg'
user.user_url = user_url if user_url else 'http://' + self.random_string() + '.com/' + self.random_string()
user.rdio_key = rdio_key if rdio_key else 's' + self.random_string(length=5, str_type='number')
user.save(self.redis)
return user
def create_a_party(self, party_id, name):
party = Party()
party.id = party_id
party.name = name
party.save(self.redis)
return party
示例7: test_lshash_redis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
def test_lshash_redis():
"""
Test external lshash module
"""
config = {"redis": {"host": 'localhost', "port": 6379, "db": 15}}
sr = StrictRedis(**config['redis'])
sr.flushdb()
lsh = LSHash(6, 8, 1, config)
for i in xrange(num_elements):
lsh.index(list(els[i]))
lsh.index(list(els[i])) # multiple insertions should be prevented by the library
hasht = lsh.hash_tables[0]
itms = [hasht.get_list(k) for k in hasht.keys()]
for itm in itms:
for el in itm:
assert itms.count(itm) == 1 # have multiple insertions been prevented?
assert el in els
for el in els:
res = lsh.query(list(el), num_results=1, distance_func='euclidean')[0]
el_v, el_dist = res
assert el_v in els
assert el_dist == 0
del lsh
sr.flushdb()
示例8: pytest_runtest_teardown
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
def pytest_runtest_teardown(item):
from sentry.app import tsdb
tsdb.flush()
client = StrictRedis(db=9)
client.flushdb()
from celery.task.control import discard_all
discard_all()
示例9: store
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
def store(self):
from simplekv.memory.redisstore import RedisStore
r = StrictRedis()
try:
r.get('anything')
except ConnectionError:
pytest.skip('Could not connect to redis server')
r.flushdb()
yield RedisStore(r)
r.flushdb()
示例10: RedconTestBase
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
class RedconTestBase(unittest.TestCase):
def setUp(self):
if hasattr(testsettings, 'REDIS_DB_UNIX_SOCKET_PATH'):
self.redis = StrictRedis(
db=testsettings.REDIS_DB,
unix_socket_path=testsettings.REDIS_DB_UNIX_SOCKET_PATH,
)
else:
self.redis = StrictRedis(
db=testsettings.REDIS_DB,
host=testsettings.REDIS_DB_HOST,
port=testsettings.REDIS_DB_PORT,
)
self.redis.flushdb()
self.redcon = Redcon(self.redis)
示例11: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
class RedisManager(NoSqlManager):
def __init__(self, namespace, url=None, data_dir=None, lock_dir=None, **params):
self.expiretime = params.pop('expiretime', 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), **params)
def __getitem__(self, key):
return pickle.loads(self.db_conn.hget(self._format_key(key), 'data'))
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]
self.db_conn.hset(key, 'data', pickle.dumps(value))
self.db_conn.hset(key, 'accessed', datetime.now())
self.db_conn.hsetnx(key, 'created', datetime.now())
if expiretime or self.expiretime:
self.db_conn.expire(key, expiretime or self.expiretime)
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.flushdb()
def keys(self):
return self.db_conn.keys('beaker:%s:*' % self.namespace)
示例12: testTaggedCache
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
class testTaggedCache(unittest.TestCase):
def setUp(self):
self.redis = StrictRedis(db=DATABASE)
self.redis.flushdb()
self.cache = TaggedCache(self.redis)
def testEverything(self):
cache = self.cache
# Set
cache.set("User:1", "mitch", tags=["User", "PremiumUser"])
cache.set("User:2", "foo", tags=["User"])
cache.set("Post:1", "Hello World!", tags=["Post"])
cache.set("Post:2", "Hello World, again!", tags=["Post"])
self.assertEquals(cache.get("Post:1"), "Hello World!")
self.assertEquals(cache.get_keys("Post"), set(["Post:1", "Post:2"]))
self.assertEquals(cache.get_keys("User"), set(["User:1", "User:2"]))
self.assertEquals(cache.get_tags("User:1"), set(["User", "PremiumUser"]))
self.assertEquals(cache.get_tags("User:2"), set(["User"]))
# Delete all post cache entries
cache.clear_tag("Post")
self.assertEquals(cache.get("Post:1"), None, "Post:1 still exists")
self.assertEquals(cache.get("Post:2"), None, "Post:2 still exists")
# Delete User 2 from cache
cache.clear("User:2")
self.assertEquals(cache.get_tags("User:2"), set())
# Clear everything else
cache.clear_all()
cache.gc()
self.assertEquals(self.redis.get("CacheKeys"), None)
self.assertEquals(self.redis.get("Tags"), None)
self.assertEquals(len(self.redis.keys("*")), 0, "Some keys were not gc'ed")
def testExpireTtl(self):
self.cache.set("ExpireMe", "foo", ttl=1)
time.sleep(2)
self.assertEquals(self.cache.get("ExpireMe"), None)
示例13: main
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
def main():
json_data = []
with open("artist.json", 'r') as _file:
for line in _file.readlines():
# json stringをdic型に変換
json_data.append(loads(line))
path = "./config.ini"
redis_config = RedisConfig(path)
host, port, db = redis_config.read_config()
r = StrictRedis(host=host, port=port, db=db)
# 接続しているDBを全消し
r.flushdb()
# Redisに登録
for dic in json_data:
if "area" in dic:
r.set(str(dic["id"]) + "_" + dic["name"], dic["area"])
示例14: redis_rules
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
def redis_rules(request):
"""Load up some sample traptor rules into Redis."""
with open('tests/data/track_rules.json') as f:
track_rules = [json.loads(line) for line in f]
with open('tests/data/follow_rules.json') as f:
follow_rules = [json.loads(line) for line in f]
with open('tests/data/locations_rules.json') as f:
locations_rules = [json.loads(line) for line in f]
conn = StrictRedis(host=HOST_FOR_TESTING, port=6379, db=5)
conn.flushdb()
rc = RulesToRedis(conn)
rc.send_rules(traptor_type='track', rules=track_rules)
rc.send_rules(traptor_type='follow', rules=follow_rules)
rc.send_rules(traptor_type='locations', rules=locations_rules)
def cleanup():
conn.flushdb()
request.addfinalizer(cleanup)
return conn
示例15: TestCase
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushdb [as 别名]
class TestCase(AsyncTestCase):
"""
Subclass API: Base for Wall unit tests. Takes care of setting / cleaning up
the test environment and provides utilities for testing.
Attributes:
* `db`: connection to temporary Redis database (`15`)
* `app`: Wall application. `TestPost` is available as registered post type.
* `user`: active user.
"""
def setUp(self):
super(TestCase, self).setUp()
self.db = StrictRedis(db=15)
self.db.flushdb()
self.app = WallApp(config={'db': 15})
self.app.add_post_type(TestPost)
self.user = self.app.login('Ivanova', 'test')
self.app.user = self.user
def get_new_ioloop(self):
return IOLoop.instance()