本文整理汇总了Python中redis.StrictRedis.hexists方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.hexists方法的具体用法?Python StrictRedis.hexists怎么用?Python StrictRedis.hexists使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.hexists方法的7个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: sync_get
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hexists [as 别名]
def sync_get(self, hash_id, identity, *args, **kwargs):
"""
For getting data from cache
:param hash_id: Unique Hash key for the data
:param identity: Unique Integer for the data
:param args: Args for the sync function. (Default: None)
"""
redis = StrictRedis(connection_pool=self.redis_pool)
hash_key = key_generator(self.hash_key, hash_id)
key = key_generator(self.key, identity)
try:
if redis.hexists(hash_key, key):
data = self.get_func(redis.hget(hash_key, key))
else:
data = self.sync_func(identity, *args, **kwargs)
redis.hset(hash_key, key, self.set_func(data))
if data is not None or data != "":
return data
return None
except RedisError as re:
self.log.error("[REDIS] %s", str(re))
data = self.sync_func(identity, args)
return data
finally:
del redis
示例2: RedisJobStore
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hexists [as 别名]
class RedisJobStore(BaseJobStore):
"""
Stores jobs in a Redis database. Any leftover keyword arguments are directly passed to redis's StrictRedis.
Plugin alias: ``redis``
:param int db: the database number to store jobs in
:param str jobs_key: key to store jobs in
:param str run_times_key: key to store the jobs' run times in
:param int pickle_protocol: pickle protocol level to use (for serialization), defaults to the highest available
"""
def __init__(self, db=0, jobs_key='apscheduler.jobs', run_times_key='apscheduler.run_times',
pickle_protocol=pickle.HIGHEST_PROTOCOL, **connect_args):
super(RedisJobStore, self).__init__()
if db is None:
raise ValueError('The "db" parameter must not be empty')
if not jobs_key:
raise ValueError('The "jobs_key" parameter must not be empty')
if not run_times_key:
raise ValueError('The "run_times_key" parameter must not be empty')
self.pickle_protocol = pickle_protocol
self.jobs_key = jobs_key
self.run_times_key = run_times_key
self.redis = StrictRedis(db=int(db), **connect_args)
def lookup_job(self, job_id):
job_state = self.redis.hget(self.jobs_key, job_id)
return self._reconstitute_job(job_state) if job_state else None
def get_due_jobs(self, now):
timestamp = datetime_to_utc_timestamp(now)
job_ids = self.redis.zrangebyscore(self.run_times_key, 0, timestamp)
if job_ids:
job_states = self.redis.hmget(self.jobs_key, *job_ids)
return self._reconstitute_jobs(six.moves.zip(job_ids, job_states))
return []
def get_next_run_time(self):
next_run_time = self.redis.zrange(self.run_times_key, 0, 0, withscores=True)
if next_run_time:
return utc_timestamp_to_datetime(next_run_time[0][1])
def get_all_jobs(self):
job_states = self.redis.hgetall(self.jobs_key)
jobs = self._reconstitute_jobs(six.iteritems(job_states))
paused_sort_key = datetime(9999, 12, 31, tzinfo=utc)
return sorted(jobs, key=lambda job: job.next_run_time or paused_sort_key)
def add_job(self, job):
if self.redis.hexists(self.jobs_key, job.id):
raise ConflictingIdError(job.id)
with self.redis.pipeline() as pipe:
pipe.multi()
pipe.hset(self.jobs_key, job.id, pickle.dumps(job.__getstate__(), self.pickle_protocol))
if job.next_run_time:
pipe.zadd(self.run_times_key, datetime_to_utc_timestamp(job.next_run_time), job.id)
pipe.execute()
def update_job(self, job):
if not self.redis.hexists(self.jobs_key, job.id):
raise JobLookupError(job.id)
with self.redis.pipeline() as pipe:
pipe.hset(self.jobs_key, job.id, pickle.dumps(job.__getstate__(), self.pickle_protocol))
if job.next_run_time:
pipe.zadd(self.run_times_key, datetime_to_utc_timestamp(job.next_run_time), job.id)
else:
pipe.zrem(self.run_times_key, job.id)
pipe.execute()
def remove_job(self, job_id):
if not self.redis.hexists(self.jobs_key, job_id):
raise JobLookupError(job_id)
with self.redis.pipeline() as pipe:
pipe.hdel(self.jobs_key, job_id)
pipe.zrem(self.run_times_key, job_id)
pipe.execute()
def remove_all_jobs(self):
with self.redis.pipeline() as pipe:
pipe.delete(self.jobs_key)
pipe.delete(self.run_times_key)
pipe.execute()
def shutdown(self):
self.redis.connection_pool.disconnect()
def _reconstitute_job(self, job_state):
job_state = pickle.loads(job_state)
job = Job.__new__(Job)
job.__setstate__(job_state)
job._scheduler = self._scheduler
job._jobstore_alias = self._alias
return job
#.........这里部分代码省略.........
示例3: RedisBackendTest
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hexists [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")
示例4: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hexists [as 别名]
class RespectfulRequester:
def __init__(self):
self.redis = StrictRedis(
host=config["redis"]["host"],
port=config["redis"]["port"],
password=config["redis"]["password"],
db=config["redis"]["database"])
try:
self.redis.echo("Testing Connection")
except ConnectionError:
raise RequestsRespectfulRedisError("Could not establish a connection to the provided Redis server")
def __getattr__(self, attr):
if attr in ["delete", "get", "head", "options", "patch", "post", "put"]:
return getattr(self, "_requests_proxy_%s" % attr)
else:
raise AttributeError()
@property
def redis_prefix(self):
return "RespectfulRequester"
def request(self, request_func, realms, wait=False):
if not isinstance(realms, Sequence) or isinstance(realms, basestring):
realms = [realms]
for realm in realms:
if realm not in self.fetch_registered_realms():
raise RequestsRespectfulError("Realm '%s' hasn't been registered" % realm)
if wait:
while True:
try:
return self._perform_request(request_func, realms)
except RequestsRespectfulRateLimitedError:
pass
time.sleep(1)
else:
return self._perform_request(request_func, realms)
def fetch_registered_realms(self):
return list(map(lambda k: k.decode("utf-8"), self.redis.smembers("%s:REALMS" % self.redis_prefix)))
def register_realm(self, realm, max_requests, timespan):
redis_key = self._realm_redis_key(realm)
if not self.redis.hexists(redis_key, "max_requests"):
self.redis.hmset(redis_key, {"max_requests": max_requests, "timespan": timespan})
self.redis.sadd("%s:REALMS" % self.redis_prefix, realm)
return True
def update_realm(self, realm, **kwargs):
redis_key = self._realm_redis_key(realm)
updatable_keys = ["max_requests", "timespan"]
for updatable_key in updatable_keys:
if updatable_key in kwargs and type(kwargs[updatable_key]) == int:
self.redis.hset(redis_key, updatable_key, kwargs[updatable_key])
return True
def unregister_realm(self, realm):
self.redis.delete(self._realm_redis_key(realm))
self.redis.srem("%s:REALMS" % self.redis_prefix, realm)
request_keys = self.redis.keys("%s:REQUEST:%s:*" % (self.redis_prefix, realm))
[self.redis.delete(k) for k in request_keys]
return True
def realm_max_requests(self, realm):
realm_info = self._fetch_realm_info(realm)
return int(realm_info["max_requests".encode("utf-8")].decode("utf-8"))
def realm_timespan(self, realm):
realm_info = self._fetch_realm_info(realm)
return int(realm_info["timespan".encode("utf-8")].decode("utf-8"))
@classmethod
def configure(cls, **kwargs):
if "redis" in kwargs:
if type(kwargs["redis"]) != dict:
raise RequestsRespectfulConfigError("'redis' key must be a dict")
expected_redis_keys = ["host", "port", "password", "database"]
missing_redis_keys = list()
for expected_redis_key in expected_redis_keys:
if expected_redis_key not in kwargs["redis"]:
missing_redis_keys.append(expected_redis_key)
if len(missing_redis_keys):
raise RequestsRespectfulConfigError("'%s' %s missing from the 'redis' configuration key" % (
", ".join(missing_redis_keys),
"is" if len(missing_redis_keys) == 1 else "are"
))
#.........这里部分代码省略.........
示例5: Moose
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hexists [as 别名]
#.........这里部分代码省略.........
params = []
if len(args) < arg_num:
self.help(arg)
return
elif arg_num == 0:
params = []
elif arg_num == -1:
params = [args]
else:
params = args[:arg_num]
if self.commands[arg].get("username", False):
self.commands[arg]["method"](username, *params)
else:
self.commands[arg]["method"](*params)
elif arg in self.commands.keys():
self.help(arg)
def purge(self, username):
if username == "zachzor":
self.redis_server.delete("challs")
self.send_message("All challenges removed")
def get(self, challenge_name):
if challenge_name[0] == '#':
try:
challenge_number = int(challenge_name[1:])
except ValueError:
self.send_message("%s is not a valid challenge id" % challenge_name)
return
if self.redis_server.hlen("challs") <= challenge_number or challenge_number < 0:
self.send_message("%s is not a valid challenge id" % challenge_name)
return
else:
name = [(i, s) for i, s in enumerate(self.redis_server.hkeys("challs"))][challenge_number][1]
try:
gist = self.create_gist(name, pickle.loads(self.redis_server.hget("challs", name)))
self.send_message("%s" % gist)
except GistException:
self.send_message("Unable to create gist")
else:
if not self.redis_server.hexists("challs", challenge_name):
self.send_message("%s is not a valid challenge name" % challenge_name)
return
else:
try:
gist = self.create_gist(challenge_name, pickle.loads(self.redis_server.hget("challs", challenge_name)))
self.send_message("%s" % gist)
except GistException:
self.send_message("Unable to create gist")
def farts(self):
self.send_message(" ".join(list(["pfffttt"] * randint(1, 7))))
def add(self, username, args):
if len(args) < 2:
self.help("add")
return
challenge_name, description = args[0], args[1:]
new_info = InfoMessage(username, datetime.now().strftime("%m-%d-%Y %H:%M:%S"), " ".join(description))
if self.redis_server.hget("challs", challenge_name) == None:
self.redis_server.hset("challs", challenge_name, pickle.dumps([new_info]))
else:
old = pickle.loads(self.redis_server.hget("challs", challenge_name))
old.append(new_info)
self.redis_server.hset("challs", challenge_name, pickle.dumps(old))
self.send_message("Added!")
def idhash(self, hash):
hash_type = HashChecker(hash)
hashzor = hash_type.check_hash()
if hashzor == None:
self.send_message("Hmm... I'm not sure about that one")
else:
self.send_message("That's probably a %s hash" % hashzor)
def challs(self):
if self.redis_server.hlen("challs") == 0:
self.send_message("No challenges")
else:
self.send_message("Challenges: %s" % ", ".join(["[%d] %s" % (i, s) for i, s in enumerate(self.redis_server.hkeys("challs"))]))
def calendar(self):
self.send_message("http://d.pr/Baur")
def help(self, method_name):
print method_name
if method_name not in self.commands.keys():
self.send_message(", ".join(self.commands.keys()))
else:
self.send_message(self.commands[method_name]["text"])
def serve_and_possibly_protect(self):
while 1:
data = self.irc.recv(4096)
username, command, args = self.parsemsg(data)
if command == "PING":
self.irc.send("PONG " + data[1] + '\r\n')
elif command == "PRIVMSG":
if len(args[1]) > 0 and args[1][0][0] == "!":
self.handle_message(username, args[0], [x.lower() for x in args[1]])
示例6: len
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hexists [as 别名]
potential_label_keys = ['classification', 'reproducible', 'status']
for key in potential_label_keys:
if key in entry and len(entry[key]) > 0:
if "duplicate of" in entry[key] or "dup of" in entry[key] or "dupe of" in entry[key]:
label_value = "duplicate"
else:
label_value = entry[key]
label = u"{}:{}".format(key, label_value.lower())
if should_add_given_labels(label, all_labels):
labels.add(label)
all_labels.add(label)
data['labels'] = list(labels)
if r.hexists(RADARS_KEY, radar_id):
# Update the Radar
issue_id = r.hget(RADARS_KEY, radar_id)
if 'resolved' in entry and len(entry['resolved']) > 0:
data['state'] = 'closed'
comment_body = "Resolved: {resolved}\nModified: {modified}".format(**entry)
else:
comment_body = "Modified: {modified}".format(**entry)
issue_url = issues_url + "/" + issue_id
comment_url = issues_url + "/" + issue_id + "/comments"
requests.patch(issue_url, data=json.dumps(data), headers=HEADERS)
comment_data = {
'body': comment_body
示例7: RedisLRU
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import hexists [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)