本文整理汇总了Python中redis.StrictRedis.exists方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.exists方法的具体用法?Python StrictRedis.exists怎么用?Python StrictRedis.exists使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.exists方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: MispRedisConnector
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import exists [as 别名]
class MispRedisConnector(object):
def __init__(self):
self.r = StrictRedis(unix_socket_path=redis_socket)
def search(self, authkey, values=None, hash_values=None, return_eid=False, quiet=False):
if isinstance(values, list):
hash_values = [SHA256.new(v.lower()).hexdigest() for v in values]
elif values:
hash_values = [SHA256.new(values.lower()).hexdigest()]
elif not isinstance(hash_values, list):
hash_values = [hash_values]
if not hash_values:
raise Exception('No value to search.')
org = self.__get_org_by_auth(authkey)
if not org:
raise Exception('Invalid authkey')
if quiet:
return [(self.r.exists(h) or self.r.exists(org + ':' + h)) for h in hash_values]
uuid_by_hashes = [self.r.smembers(h).union(self.r.smembers(org + ':' + h)) for h in hash_values]
if not return_eid:
to_return = uuid_by_hashes
else:
to_return = []
for h in uuid_by_hashes:
to_return.append([self.r.hget('uuid_id', uuid) for uuid in h])
return to_return
def __get_org_by_auth(self, authkey):
return self.r.get(authkey)
示例2: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import exists [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)
示例3: RedisProducer
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import exists [as 别名]
class RedisProducer(object):
def __init__(self, hostname = 'localhost', port = 6379):
log.debug("Initializing RedisProducer with hostname of %s and port %s" % (hostname, port))
self.r = StrictRedis(host = hostname, port = port)
def send(self, message):
tries = 0
next_index_key = get_next_index_for_topic_key(message.topic)
next_index = 1
result = None
log.debug("Sending message on topic %s" % message.topic)
while result is None and tries < TRIES_LIMIT:
if self.r.exists(next_index_key):
next_index = long(self.r.get(next_index_key)) + 1
message_key = get_message_key(message.topic, next_index)
try:
pl = self.r.pipeline()
pl.watch(next_index_key, message_key)
pl.multi()
pl.incr(next_index_key).set(message_key, message.payload)
result = pl.execute()
except WatchError:
# Should probably log something here, but all it means is we're
# retrying
pass
if result is None:
log.error("Could not send message, retry amount exceeded")
raise RuntimeError("Attempted to send message %s times and failed" % TRIES_LIMIT)
示例4: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import exists [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)
示例5: RedisDataStore
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import exists [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()
示例6: sync_get
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import exists [as 别名]
def sync_get(self, identity, *args, **kwargs):
"""
For getting data from cache
:param identity: Unique Integer for the data
:param args: Args for the sync function. (Default: None)
"""
redis = StrictRedis(connection_pool=self.redis_pool)
key = key_generator(self.key, identity)
try:
if redis.exists(key):
data = self.get_func(redis.get(key))
else:
data = self.sync_func(identity, *args, **kwargs)
if self.expire:
self._setex(redis, key, self.set_func(data))
else:
redis.set(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
示例7: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import exists [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)
示例8: DbRedis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import exists [as 别名]
class DbRedis(Db):
def __init__(self):
super().__init__()
self.redis = StrictRedis(**dbSettings)
def generateKey(self):
return self.redis.incr("id")
def store(self, key, objSerial):
self.redis.setex(key, TTL, objSerial)
def retrieve(self, key):
return self.redis.get(key)
def lenList(self, name):
return self.redis.llen(name)
def listAppend(self, name, val):
self.redis.lpush(name, val)
def listPopLeft(self, name):
return self.redis.lpop(name)
def retrieveList(self, name):
return self.redis.lrange(name, 0, -1)
def removeFromList(self, name, item):
self.redis.lrem(name, item, 0)
def keyExists(self, key):
return self.redis.exists(key)
示例9: new_group
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import exists [as 别名]
def new_group(request):
groupname = request.POST.get("groupname")
totwords = request.POST.get("totwords")
totmembers = request.POST.get('totmembers')
pref = settings.MY_PREFIX
prefg = pref+":"+groupname
user = str(request.user)
rd = StrictRedis()
# the above statements are self explanatory
exists = rd.exists(pref+":"+groupname)
if exists:
# return error, can't create the group with that name
# don't do that, just add this user to the already existing group
# if group size < totmembers
d = rd.hgetall(prefg+":hash")
response = {'facility':""}
if int(d['totmembers'])>int(d['curmembers']):
rd.hincrby(prefg+":hash", 'curmembers')
#d = rd.hgetall(prefg+":hash")
response['facility'] = groupname
response['new_group_created'] = False
rd.sadd(prefg, user)
#now notify the others that this user joined the group!
redis_publisher = RedisPublisher(facility = pref, broadcast = True)
mydict = {"type":"new_join", 'who':user, 'name':groupname}
msgstring = json.dumps(mydict)
print "broadcast message:"+msgstring
message = RedisMessage(msgstring)
redis_publisher.publish_message(message)
# now check if the competition is ready to start
if int(d['totmembers'])-1 == int(d['curmembers']):
start_competition(request,groupname)
return JsonResponse(response)
# so the group doesn't exist
rd.sadd(prefg, user)
# add this user to the set of all the users that are part of this group
hashdict = {'totwords':totwords, 'totmembers':totmembers, "owner":user, "name":groupname, 'curmembers':1}
# adding group name is redundant but it simplifies things a lot
rd.hmset(prefg+":hash", hashdict)
# using hash greatly simplifies the things(dict interconversion hgetall()), though i feel that the
# naming convention used is horrible
redis_publisher = RedisPublisher(facility = pref, broadcast = True)
mydict = {"type":"new_group"}
mydict.update(hashdict)
msgstring = json.dumps(mydict)
print msgstring
message = RedisMessage(msgstring)
redis_publisher.publish_message(message)
# notify the others about this new group that was created
rd.sadd(pref+":groups", groupname)
return JsonResponse({'facility':groupname, 'new_group_created':True})
示例10: RedisBackend
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import exists [as 别名]
class RedisBackend(Backend):
def __init__(self, config):
super(RedisBackend, self).__init__(config)
self.redis = StrictRedis(host=config.get("host", "localhost"),
port=config.get("port", 6379),
db=config.get("db", 0))
self.namespace = config.get("namespace", "short:")
def furl(self, name):
return self.namespace + "url:" + name
def fvisits(self, name):
return self.namespace + "visits:" + name
def next_name(self):
name = None
while 1:
name = hashids.encrypt(
self.redis.incr(self.namespace + "meta:num"))
if not self.exists(name):
break
return name
def exists(self, name):
return self.redis.exists(self.furl(name))
def set(self, link):
if self.redis.exists(self.furl(link.name)):
raise NameUnavailableError(link.name)
self.redis.set(self.furl(link.name), link.url)
self.redis.set(self.fvisits(link.name), 0)
def get(self, name):
rawlink = self.redis.get(self.furl(name))
if not rawlink:
raise NotFoundError(name)
link = Link(name=name,
url=rawlink.decode("utf-8"),
visits=int(
self.redis.get(self.fvisits(name)) or 0
))
return link
def visit(self, name):
self.redis.incr(self.fvisits(name))
示例11: RedisConsumer
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import exists [as 别名]
class RedisConsumer(object):
def __init__(self, timeout, group_id, hostname = 'localhost', port = 6379):
self.group_id = group_id
self.timeout = timeout
log.debug("Initializing RedisConsumer with hostname of %s and port %s" % (hostname, port))
self.r = StrictRedis(host = hostname, port = port)
def poll(self, topic):
result = None
current_index_key = get_next_index_for_topic_key(topic)
end_millis = time.time() * 1000 + self.timeout
log.debug("Polling topic %s" % topic)
while time.time() * 1000 < end_millis:
if self.r.exists(current_index_key):
current_index = long(self.r.get(current_index_key))
consumer_index_key = get_next_index_for_group_id_key(topic, self.group_id)
pl = self.r.pipeline()
pl.watch(consumer_index_key)
consumer_index = 0
if self.r.exists(consumer_index_key):
consumer_index = long(self.r.get(consumer_index_key))
if current_index > consumer_index:
try:
pl.multi()
pl.incr(consumer_index_key)
incr_result = pl.execute()
if not incr_result is None and len(incr_result) > 0:
consumer_index = long(incr_result[0])
key = get_message_key(topic, consumer_index)
if self.r.exists(key):
result = self.r.get(key)
break
except WatchError:
log.debug("Redis keys changed for topic %s and group %s, trying again" % (topic, self.group_id))
pass
return result
def unsubscribe_from_topic(self, topic):
self.r.delete(get_next_index_for_group_id_key(topic, self.group_id))
示例12: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import exists [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: RedisDB
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import exists [as 别名]
class RedisDB(object):
def __init__(self):
if not hasattr(RedisDB, 'pool'):
RedisDB.createPool()
self.r = StrictRedis(connection_pool = RedisDB.pool)
@staticmethod
def createPool():
RedisDB.pool = redis.ConnectionPool(
host = '127.0.0.1',
port = 6379,
db = 0
)
def saveToRedis(self, receiver, to_station_ab, to_station_name, from_station_ab, from_station_name, querydate, purpose_code, noticetime, publishtime):
'''将需要抓取的信息存入redis'''
uid = self.r.incr('uid')
tickets_info = {'uid':uid, 'receiver':receiver, 'to_station_ab':to_station_ab, 'to_station_name':to_station_name, 'from_station_ab':from_station_ab,'from_station_name':from_station_name, 'querydate':querydate, 'purpose_code':purpose_code, 'noticetime':noticetime, 'publishtime': publishtime}
self.r.zadd('email_que_set_all', uid, str(tickets_info))
if noticetime == '9am':
self.r.zadd('email_que_set_9am', uid, str(tickets_info))
elif noticetime == '11am':
self.r.zadd('email_que_set_11am', uid, str(tickets_info))
elif noticetime == '3pm':
self.r.zadd('email_que_set_3pm', uid, str(tickets_info))
elif noticetime == '5pm':
self.r.zadd('email_que_set_5pm', uid, str(tickets_info))
self.r.save()
def getStation(self, set, name):
return self.r.hget(set, name)
def zrevrange(self, set, begin, end):
return self.r.zrevrange(set, begin, end)
def zremrangebyscore(self, queue, uid):
return self.r.zremrangebyscore(queue, uid, uid)
def station_validate(self, form, field):
'''
表单tostation和tostation验证函数
'''
if not self.r.getStation(field.data):
raise ValidationError(u'木有这个站')
def saveJSONToSet(self, setName, json):
if not self.r.exists(setName):
for i, name in enumerate(json):
self.r.hset(setName, name, json[name])
print 'insert'+name
self.r.save()
else:
pass
示例14: WatchmanBlacklist
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import exists [as 别名]
class WatchmanBlacklist(object):
def __init__(self, config_xml = None):
if config_xml is None:
config_xml = ET.parse(CONFIG_FILE)
#elif not isinstance(config_xml,ET.Element) and not isinstance(config_xml,ET.ElementTree):
# raise TypeError("config_xml must be either None or an ElementTree element")
try:
password = config_xml.find('/global/password').text
except StandardError as e:
password = ""
try:
redishost = config_xml.find('/global/redis').text
except StandardError as e:
redishost = "localhost"
try:
expire = config_xml.find('/global/expire').text
self.expire = int(expire)
except StandardError as e:
logging.warning("No <expire> setting in the <global> section of config. Defaulting to 360s.")
self.expire = 360
try:
dbnum = config_xml.find('/global/blacklistdb').text
self._dbnum = int(dbnum)
except StandardError as e:
logging.warning("No blacklistdb setting in the <global> section of config. Defaulting to Redis database 2.")
dbnum = 2
self._conn = StrictRedis(host=redishost, password=password, db=dbnum)
def get(self,filepath,update=True,value="(locked)"):
"""
Check if the given path is in the blacklist, and optionally update the lock whether or not it exists
:param filepath: file path to check
:param update: if True, then add the filepath to the blacklist and reset the expiry counter - even if it already exists.
:param value: value to store against the file path (typically the mtime)
:return: value of the key or None
"""
rtn = self._conn.get(filepath)
#if update:
# self._conn.setnx(filepath, value)
# self._conn.expire(filepath, self.expire)
if not self._conn.exists(filepath):
logging.debug("{0} does not exist in the blacklist. Attempting to add it.".format(filepath))
self._conn.setnx(filepath, value)
self._conn.expire(filepath, self.expire)
return rtn
示例15: factory
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import exists [as 别名]
def factory(request):
# note: will raise ConnectionError if connection is not established
redis = getattr(request.registry, '_redis_sessions', None)
if redis is None: # pragma no cover
redis = StrictRedis(host=host, port=port, db=db, password=password,
socket_timeout=socket_timeout,
connection_pool=connection_pool, charset=charset,
errors=errors, unix_socket_path=unix_socket_path)
setattr(request.registry, '_redis_sessions', redis)
def add_cookie(session_id):
if not cookie_on_exception:
exc = getattr(request, 'exception', None)
if exc is None: # don't set cookie during exceptions
return
def set_cookie_callback(request, response):
cookieval = sign_session_id(session_id, secret)
response.set_cookie(
cookie_name,
value = cookieval,
max_age = cookie_max_age,
domain = cookie_domain,
secure = cookie_secure,
httponly = cookie_httponly,
)
request.add_response_callback(set_cookie_callback)
return
def delete_cookie():
def set_cookie_callback(request, response):
response.delete_cookie(cookie_name)
request.add_response_callback(set_cookie_callback)
return
cookieval = request.cookies.get(cookie_name)
session_id = None
if cookieval is not None:
try:
session_id = unsign_session_id(cookieval, secret)
except ValueError:
pass
if session_id and redis.exists(session_id):
session = RedisSession(redis, session_id, timeout, delete_cookie)
else:
new_id = new_session_id(redis, timeout)
add_cookie(new_id)
session = RedisSession(redis, new_id, timeout, delete_cookie)
session._v_new = True
return session