本文整理汇总了Python中redis.StrictRedis.hdel方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.hdel方法的具体用法?Python StrictRedis.hdel怎么用?Python StrictRedis.hdel使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.hdel方法的11个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hdel [as 别名]
class WordList:
def __init__(self):
self.conn = Redis()
self.CACHE_SIZE = 50
self.CACHE_KEYS = "words-keys"
self.CACHE_STORE = "words-store"
self.WORD_FILE = os.path.join(os.path.expanduser("~"), '.words.txt')
def _reorganize(self):
pop_n = self.conn.zcard(self.CACHE_KEYS) - self.CACHE_SIZE
if pop_n >= 0:
to_pop = self.conn.zrange(self.CACHE_KEYS, 0, pop_n)
#print pop_n, to_pop
self.conn.zremrangebyrank(self.CACHE_KEYS, 0, pop_n)
for k in to_pop:
self.conn.hdel(self.CACHE_STORE, k)
def _add_word(self, key, value):
result = self.conn.hget(self.CACHE_STORE, key)
if result:
self.conn.zincrby(self.CACHE_KEYS, key, 1.0)
else:
self._reorganize()
self.conn.hset(self.CACHE_STORE, key, value)
self.conn.zadd(self.CACHE_KEYS, 1, key)
def _get_words(self):
try:
words = self.conn.zrevrange(self.CACHE_KEYS, 0, -1, True)
#hashs = self.conn.hgetall(self.CACHE_STORE)
#print words
#print hashs
return words
except redis.exceptions.ConnectionError:
return None
def dump_console(self):
if os.path.isfile(self.WORD_FILE):
with open(self.WORD_FILE, 'r') as f:
print f.read()
def write_file(self):
words = self._get_words()
if words is None:
return
content = '\n'.join(["%d. %s\t %d"%(i, x[0], int(x[1])) for i, x in enumerate(words)])
with open(self.WORD_FILE, 'w+') as f:
f.write(content)
f.write('\n')
def add_word(self, key):
try:
self._add_word(key,key)
self.write_file()
except redis.exceptions.ConnectionError:
return
示例2: delete
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hdel [as 别名]
def delete(obj, key=None):
"""
Delete a single key if specified, or all namespace if key is none
:param obj: settings object
:param key: key to delete from store location
:return: None
"""
client = StrictRedis(**obj.REDIS_FOR_DYNACONF)
holder = "DYNACONF_%s" % obj.DYNACONF_NAMESPACE
if key:
client.hdel(holder.upper(), key.upper())
obj.unset(key)
else:
keys = client.hkeys(holder.upper())
client.delete(holder.upper())
obj.unset_all(keys)
示例3: RedisBackend
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hdel [as 别名]
class RedisBackend(BaseBackend):
def __init__(self):
from redis import StrictRedis
host = conf.METADATA.get('host', 'localhost')
port = conf.METADATA.get('port', 6379)
password = conf.METADATA.get('password', None)
db = conf.METADATA.get('db', 0)
prefix = conf.METADATA.get('PREFIX', 'djthumbs')
self.prefix = prefix + ":"
self.redis = StrictRedis(host=host, port=port, password=password, db=db)
def get_source_key(self, name):
return "%ssources:%s" % (self.prefix, name)
def get_thumbnail_key(self, name):
return "%sthumbnails:%s" % (self.prefix, name)
def add_source(self, name):
self.redis.hset(self.get_source_key(name), name, name)
return name
def get_source(self, name):
return compat.as_text(self.redis.hget(self.get_source_key(name), name))
def delete_source(self, name):
return self.redis.hdel(self.get_source_key(name), name)
def get_thumbnails(self, name):
metas = self.redis.hgetall(self.get_thumbnail_key(name))
return [ImageMeta(name, thumbnail_name, size) for size, thumbnail_name in metas.items()]
def get_thumbnail(self, source_name, size):
name = compat.as_text(self.redis.hget(self.get_thumbnail_key(source_name), size))
if name:
return ImageMeta(source_name, name, size)
return None
def add_thumbnail(self, source_name, size, name):
self.redis.hset(self.get_thumbnail_key(source_name), size, name)
return ImageMeta(source_name, name, size)
def delete_thumbnail(self, source_name, size):
self.redis.hdel(self.get_thumbnail_key(source_name), size)
示例4: RedisStorage
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hdel [as 别名]
class RedisStorage(BaseSharedStorage):
def __init__(self, db_num):
self._redis = StrictRedis(db=db_num)
def save(self, filename, key, data):
self._purge_duplicates(filename)
self._redis.hset(filename, key, data)
def load(self, filename):
redis_keys = self._redis.hkeys(filename)
key = redis_keys[0] # Should never be more than one key
data = self._redis.hget(filename, key)
return key, data
def _purge_duplicates(self, dict_key):
"""Remove identical files from server to be replaced by new files."""
keys = self._redis.hkeys(dict_key)
for key in keys:
self._redis.hdel(dict_key, key)
示例5: post_updates
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hdel [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)
示例6: RedisDict
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hdel [as 别名]
class RedisDict(MutableMapping):
""" RedisDict - a dictionary-like interface for ``redis`` key-stores
"""
def __init__(self, namespace, collection_name='redis_dict_data',
connection=None):
"""
The actual key name on the redis server will be
``namespace``:``collection_name``
In order to deal with how redis stores data/keys,
everything, i.e. keys and data, must be pickled.
:param namespace: namespace to use
:param collection_name: name of the hash map stored in redis
(default: redis_dict_data)
:param connection: ``redis.StrictRedis`` instance.
If it's ``None`` (default), a new connection with
default options will be created
"""
if connection is not None:
self.connection = connection
else:
self.connection = Redis()
self._self_key = ':'.join([namespace, collection_name])
def __getitem__(self, key):
result = self.connection.hget(self._self_key, pickle.dumps(key))
if result is None:
raise KeyError
return pickle.loads(bytes(result))
def __setitem__(self, key, item):
self.connection.hset(self._self_key, pickle.dumps(key),
pickle.dumps(item))
def __delitem__(self, key):
if not self.connection.hdel(self._self_key, pickle.dumps(key)):
raise KeyError
def __len__(self):
return self.connection.hlen(self._self_key)
def __iter__(self):
for v in self.connection.hkeys(self._self_key):
yield pickle.loads(bytes(v))
def clear(self):
self.connection.delete(self._self_key)
def __str__(self):
return str(dict(self.items()))
示例7: delete
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hdel [as 别名]
def delete(self, hash_id, identity):
"""
For Deleting a key inside the hash
:param hash_id:
:param identity:
:return:
"""
redis = StrictRedis(connection_pool=self.redis_pool)
hash_key = key_generator(self.hash_key, hash_id)
key = key_generator(self.key, identity)
try:
i = redis.hdel(hash_key, key)
return i
except RedisError as re:
self.log.error("[REDIS] %s", str(re))
return 0
finally:
del redis
示例8: RedisBackendTest
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hdel [as 别名]
class RedisBackendTest(TestCase):
def setUp(self):
self.backend = RedisBackend()
self.redis = StrictRedis()
def test_get_source_key(self):
self.assertEqual(self.backend.get_source_key("a.jpg"), "djthumbs-test:sources:a.jpg")
def test_get_thumbnail_key(self):
self.assertEqual(self.backend.get_thumbnail_key("a.jpg"), "djthumbs-test:thumbnails:a.jpg")
def test_add_delete_source(self):
source_name = "test-thumbnail.jpg"
source_key = self.backend.get_source_key(source_name)
self.backend.add_source(source_name)
self.assertTrue(self.redis.hexists(source_key, source_name))
self.backend.delete_source(source_name)
self.assertFalse(self.redis.hexists(source_key, source_name))
def test_get_source(self):
source_name = "test-thumbnail.jpg"
source_key = self.backend.get_source_key(source_name)
self.redis.hset(source_key, source_name, source_name)
self.assertEqual(self.backend.get_source(source_name), source_name)
# Delete Source
self.redis.hdel(source_key, source_name)
def test_add_delete_thumbnail(self):
source_name = "test-thumbnail.jpg"
size = "small"
thumbnail_key = self.backend.get_thumbnail_key(source_name)
self.backend.add_source(source_name)
self.backend.add_thumbnail(source_name, size, "test-thumbnail_small.jpg")
self.assertTrue(self.redis.hexists(thumbnail_key, size))
self.backend.delete_thumbnail(source_name, size)
self.assertFalse(self.redis.hexists(thumbnail_key, size))
# Delete Source
self.redis.hdel(self.backend.get_source_key(source_name), source_name)
def test_get_thumbnail(self):
source_name = "test-thumbnail.jpg"
self.backend.add_source(source_name)
self.backend.add_thumbnail(source_name, "small", "test-thumbnail_small.jpg")
self.assertEqual(
self.backend.get_thumbnail(source_name, "small"),
ImageMeta(source_name, "test-thumbnail_small.jpg", "small"),
)
self.backend.add_thumbnail(source_name, "large", "test-thumbnail_large.jpg")
expected = ["test-thumbnail_large.jpg", "test-thumbnail_small.jpg"]
result = [image_meta.name for image_meta in self.backend.get_thumbnails(source_name)]
self.assertEqual(result.sort(), expected.sort())
# Delete Source & Thumbnails
thumbnail_key = self.backend.get_thumbnail_key(source_name)
self.redis.hdel(self.backend.get_source_key(source_name), source_name)
self.redis.hdel(thumbnail_key, "small")
self.redis.hdel(thumbnail_key, "large")
示例9: StrictRedis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hdel [as 别名]
# need: a list of changesets with their owners and extents that gets built up in redis
# redis wants: a geofenced channel with a list of changeset ids in it, potentially of limited length.
# changesets will build slowly over time, not using the API's bbox support because it's too blunt.
# redis structure for a changeset - ?
# ways: ask the API for their extent? keep them around with a timeout?
redis = StrictRedis()
for changeset_id in sorted(changesets):
#
# Delete saved changeset bounding boxes, because they've probably changed.
#
changeset_key = 'changeset-' + changeset_id
redis.hdel(changeset_key, 'min_lat')
redis.hdel(changeset_key, 'min_lon')
redis.hdel(changeset_key, 'max_lat')
redis.hdel(changeset_key, 'max_lon')
for node in nodes:
#
# Save nodes to redis hashes under "node-id" keys, with keys "lat", "lon".
# Also add node keys to associated changeset redis set.
#
pipe = redis.pipeline(True)
node_key = 'node-%(id)s' % node.attrib
change_items_key = 'changeset-%(changeset)s-items' % node.attrib
osm.remember_node(pipe, node.attrib)
示例10: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hdel [as 别名]
#.........这里部分代码省略.........
info = unpackb(info)
if tagging == '__taggings__':
rv[ts] = list(info.keys())
elif tagging == '__all__':
rv[ts] = info
elif tagging in info:
if ret_whold:
rv.append((info, ts))
else:
rv.append((info[tagging], ts))
return rv
def inc_coll_cache_set(self, coll, field, value):
key = self.inc_coll_cache_fmt.format(name=coll.name)
self.rdb.hset(key, field, packb(value))
def inc_coll_caches_get(self, coll, *fields):
"""
:ret: return [] if no data exists. Normal structure is:
[value1, value2, ..., valueN]
"""
if not fields:
return []
key = self.inc_coll_cache_fmt.format(name=coll.name)
rv = self.rdb.hmget(key, *fields)
# print('inc_coll_caches_get - ', rv)
# print('inc_coll_caches_get After - ', [unpackb(r) for r in rv if r])
return [unpackb(r) for r in rv if r]
def inc_coll_caches_del(self, coll, *fields):
key = self.inc_coll_cache_fmt.format(name=coll.name)
return self.rdb.hdel(key, *fields)
def uniq_count_coll_cache_set(self, coll, ts, tagging, values):
"""
:param values: should be a iterable object contain members
"""
values = {packb(v) for v in values}
key_fmt = self.unique_count_coll_cache_fmt
key = key_fmt.format(name=coll.name, tagging=tagging, ts=ts)
return self.rdb.sadd(key, *values)
def uniq_count_coll_cache_get(self, coll, tagging, timestamps, count_only=False):
key_fmt = self.unique_count_coll_cache_fmt
rv = []
for ts in timestamps:
key = key_fmt.format(name=coll.name, tagging=tagging, ts=ts)
if count_only:
count = self.rdb.scard(key)
rv.append(count)
else:
members = self.rdb.smembers(key)
rv.append({unpackb(m) for m in members})
return rv
def uniq_count_coll_cache_pop(self, coll, tagging, timestamps, number):
"""
:note: Redis `SPOP key [count]` command, The count argument will be
available in a later version and is not available
in 2.6, 2.8, 3.0.
Now use SRANDMEMBER and SREM commands to mimic the effect of
SPOP count.
"""
key_fmt = self.unique_count_coll_cache_fmt
示例11: RedisLRU
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hdel [as 别名]
class RedisLRU(object):
def __init__(self, redis=None, **kwargs):
if redis is not None:
self._redis = redis
else:
self._redis = Redis(**kwargs)
self.namespaces = {
"default": 10000
}
def setup_namespace(self, namespace, size):
"""Set the LRU Size for a namespace.
"""
self.namespaces[namespace] = int(size)
def _serialize(self, s):
# return json.dumps(s)
return s
def _unserialize(self, s):
# s = s.decode("utf-8")
# return json.loads(s)
return s
def _size(self, namespace):
return self.namespaces[namespace]
def _hit_store(self, namespace):
if namespace not in self.namespaces:
raise KeyError("invalid namespace")
return "cache_keys_{}".format(namespace)
def _value_store(self, namespace):
if namespace not in self.namespaces:
raise KeyError("invalid namespace")
return "cache_values_{}".format(namespace)
def _expire_old(self, namespace):
hits = self._hit_store(namespace)
size = self._size(namespace)
count = self._redis.zcard(hits)
if count >= size:
values = self._value_store(namespace)
items = self._redis.zrange(hits, 0, count-size)
logger.error(items)
self._redis.zremrangebyrank(hits, 0, count-size)
self._redis.hdel(values, *items)
def clear(self, namespace="default"):
"""Clear the Cache.
"""
hits = self._hit_store(namespace)
values = self._value_store(namespace)
self._redis.delete(hits, values)
def clearAll(self):
"""Clear all known namespaces.
"""
for k in self.namespaces.iterkeys():
self.clear(k)
def store(self, key, value, namespace="default"):
"""Store a key value pair in cache.
This will not update an existing item.
"""
values = self._value_store(namespace)
if not self._redis.hexists(values, key):
hits = self._hit_store(namespace)
self._expire_old(namespace)
self._redis.hset(values, key, self._serialize(value))
self._redis.zadd(hits, time.time(), key)
else:
hits = self._hit_store(namespace)
self._redis.hset(values, key, self._serialize(value))
self._redis.zadd(hits, time.time(), key)
def get(self, key, namespace="default"):
"""Get a value from the cache.
returns none if the key is not found.
"""
values = self._value_store(namespace)
value = self._redis.hget(values, key)
if value:
hits = self._hit_store(namespace)
self._redis.zadd(hits, time.time(), key)
return self._unserialize(value)
return None
def expire(self, key, namespace="default"):
"""Expire (invalidate) a key from the cache.
"""
values = self._value_store(namespace)
if self._redis.hexists(values, key):
hits = self._hit_store(namespace)
self._redis.hdel(values, key)
self._redis.zrem(hits, key)