本文整理汇总了Python中redis.StrictRedis.setex方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.setex方法的具体用法?Python StrictRedis.setex怎么用?Python StrictRedis.setex使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.setex方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: DbRedis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [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)
示例2: fetch_questions_ajax
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
def fetch_questions_ajax(request):
current_user = request.user
'''
query the database and find out whether questionpaper is made
or not for this user, if made then return the questions with
shuffled choices along with the answer of user, if not then
the same thing but answers will be empty or non existent
'''
questions = QuestionPaper.objects.all().filter(user=current_user)
question_list = []
if not questions:
# make new questions here
print "making new questions for the user:", current_user.username
question_list = make_question_paper(current_user)
# add a session variable here that keeps track whether we are making
# the paper for the first time or not, otherwise every page refresh
# will result in making of new question paper for this particular user
# another solution is to check in start whether we have received a POST or GET
# don't do it, read the above string comment
# start the timer!
username = current_user.username
key = settings.NCQS_REDIS_PREFIX+username
seconds = settings.NCQS_TOTAL_TIME
print "now setting the key "+key+", which will expire in "+str(seconds)+" seconds.";
rd = StrictRedis()
rd.setex(key, seconds, "1")
else:
question_list = map(get_dictionary_from_question_paper, list(questions))
data = {"data":question_list}
return JsonResponse(data);
示例3: polite_get
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
def polite_get(url, ttl=TTL, db=0, port=6379):
"""
Don't hammer the remote servers.
1. They don't update that often anyway.
2. We don't want to get throttled or banned.
3. It's polite.
Accepts kwargs for ttl, db, and port; otherwise
uses Redis defaults and a one-hour ttl.
"""
db = StrictRedis(db=db, port=port)
key = "url_cache::{0}".format(url)
result = db.get(key)
if result is None:
page = requests.get(url)
result = page.text
db.setex(key, ttl, result.encode('utf-8'))
else:
result = result.decode('utf-8')
return result
示例4: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [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: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [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)
示例6: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [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: archive_events
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
def archive_events():
print("Starting to archive events.")
redis = StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=0)
s3 = tinys3.Connection(AWS_ACCESS_KEY_ID,
AWS_SECRET_ACCESS_KEY,
default_bucket=S3_BUCKET,
endpoint=S3_ENDPOINT,
tls=True)
now = datetime.utcnow()
nowstring = now.strftime("%Y-%m-%d")
# 1. We collect all events objects from the query time span
# and group them by day.
# keep everything in RAM, keyed by day
events = {}
count = 0
for event in fetch_events():
event_datetime = datetime.fromtimestamp(event["created"])
daystring = event_datetime.strftime("%Y-%m-%d")
if daystring == nowstring:
continue
if daystring not in events:
events[daystring] = []
count += 1
events[daystring].append(event)
print("Fetched %d events." % count)
# 2. We go through day by day and see where new entries have been added
# since the last run. For these we create a backup file.
redis_retention = REDIS_RETENTION_DAYS * 24 * 60 * 60
for daystring in sorted(events.keys()):
print("Processing day %s with %d events" % (daystring, len(events[daystring])))
# possibly skip days already archived
redis_value = redis.get(daystring)
if redis_value is not None:
num_entries_before = int(redis_value)
if len(events[daystring]) <= num_entries_before:
print("Skipping day %s, already archived" % daystring)
continue
try:
target_path = upload_dump(daystring, events[daystring], s3)
print("Uploaded %s" % target_path)
# write number of entries per day to redis
redis.setex(daystring, redis_retention, str(len(events[daystring])))
except Exception as ex:
sys.stderr.write("ERROR: No backup created for %s\n" % daystring)
sys.stderr.write(traceback.format_exc() + "\n")
del redis
del s3
del events
print("Done for today.")
示例8: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [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)
示例9: Redis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
class Redis():
INVITE_EXPIRATION = 300
def __init__(self, host='pulsing.jhk.org', port=6379, password='wsad', db=0, **kwargs):
super().__init__()
self.logger = logging.getLogger(__name__)
self.__client = StrictRedis(host=host, port=port, password=password, db=0, **kwargs)
def storeInvitation(self, to_user_id, from_user_id, invitation_id, invitationType):
expiration = datetime.utcnow() + timedelta(seconds=Redis.INVITE_EXPIRATION)
self.__client.setex(invitation_id, '1', Redis.INVITE_EXPIRATION)
self.__client.sadd('INVITATIONS_'+to_user_id,
json.dumps(getInvitation(from_user_id, invitationType, invitation_id, expiration.timestamp() * 1000.0)))
def removeInvitation(self, user_id, invitation_id):
s_invitations = self.__client.smembers('INVITATIONS_'+user_id)
self.logger.debug('removeInvitation fetched - %s ', s_invitations)
invitations = json.loads(s_invitations)
self.logger.debug('removeInvitation parsed - %s ', invitations)
invitation = [invite for invite in invitations if (invite['invitationId'] == invitation_id)]
self.__client.delete(invitation_id)
return invitation
@property
def client(self):
return self.__client
def __eq__(self, other):
return self.__client == other.__client
def __str__(self):
return self.__client.__str__()
def __hash__(self):
return self.__client.__hash__()
示例10: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
class RedisCache:
#是否压缩文件 compress endcoding 编码方式,key:url value:html redis链接:client 设置缓存过期时间expires=timedelta(days=30)
def __init__(self,client=None,compress=True,endcoding='utf-8',expires=timedelta(days=30)):
self.client = StrictRedis(host='localhost',port=6379,db=0)
self.compress = True
self.endcoding =endcoding
self.expires = expires
#序列化 解压 解码 序列化
def __getitem__(self,url):
value = self.client.get(url)
if value:
if self.compress:
value = zlib.decompress(value)
return json.loads(value.decode(self.endcoding))
else:
raise KeyError(url+'does exit')
#反序列化 解码 解压
def __setitem__(self,url,html):
data = bytes(json.dumps(html),encoding=self.endcoding)
if self.compress:
data = zlib.compress(data)
#设置过期时间 setex
self.client.setex(url,self.expires,data)
示例11: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
class WallMessage:
def __init__(self, prefix='msg', timeout=timedelta(minutes=60)):
self.prefix = prefix
self.timeout = timeout
self.r = StrictRedis(__REDIS_HOST__, port=__REDIS_PORT__)
def post(self, message):
try:
key = '%(prefix)s:%(hash)s' % {'prefix': self.prefix, 'hash': uuid()}
return {'result': True, 'message': self.r.setex(key, self.timeout, bleach.clean(message))}, 200
except ConnectionError, e:
return {'result': False, 'error': 'Could not connect to redis, is the server started and accepting connections on %s:%s?' % (__REDIS_HOST__, __REDIS_PORT__)}, 503
except Exception, e:
return {'result': False, 'error': str(e)}, 500
示例12: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
class RedisManager(NoSqlManager):
def __init__(self, namespace, url=None, data_dir=None, lock_dir=None, **params):
self.db = params.pop('db', 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), db=self.db, **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)
#XXX: beaker.container.Value.set_value calls NamespaceManager.set_value
# however it(until version 1.6.3) never sets expiretime param. Why?
# Fortunately we can access expiretime through value.
# >>> value = list(storedtime, expire_argument, real_value)
if expiretime is None:
expiretime = value[1]
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)
示例13: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
#.........这里部分代码省略.........
config["redis"] = kwargs["redis"]
if "safety_threshold" in kwargs:
if type(kwargs["safety_threshold"]) != int or kwargs["safety_threshold"] < 0:
raise RequestsRespectfulConfigError("'safety_threshold' key must be a positive integer")
config["safety_threshold"] = kwargs["safety_threshold"]
if "requests_module_name" in kwargs:
if type(kwargs["requests_module_name"]) != str:
raise RequestsRespectfulConfigError("'requests_module_name' key must be string")
config["requests_module_name"] = kwargs["requests_module_name"]
return config
@classmethod
def configure_default(cls):
for key in config:
config[key] = default_config[key]
return config
def _perform_request(self, request_func, realms):
self._validate_request_func(request_func)
limited_realms = [realm for realm in realms if not self._can_perform_request(realm)]
if not limited_realms:
request_uuid = str(uuid.uuid4())
for realm in realms:
self.redis.setex(
name="%s:REQUEST:%s:%s" % (self.redis_prefix, realm, request_uuid),
time=self.realm_timespan(realm),
value=request_uuid
)
return request_func()
else:
raise RequestsRespectfulRateLimitedError(
"Currently rate-limited on Realm(s): {}".format(', '.join(limited_realms)))
def _realm_redis_key(self, realm):
return "%s:REALMS:%s" % (self.redis_prefix, realm)
def _fetch_realm_info(self, realm):
redis_key = self._realm_redis_key(realm)
return self.redis.hgetall(redis_key)
def _requests_in_timespan(self, realm):
return len(
self.redis.scan(
cursor=0,
match="%s:REQUEST:%s:*" % (self.redis_prefix, realm),
count=self._redis_keys_in_db() + 100
)[1]
)
def _redis_keys_in_db(self):
return self.redis.info().get("db%d" % config["redis"]["database"]).get("keys")
def _can_perform_request(self, realm):
return self._requests_in_timespan(realm) < (self.realm_max_requests(realm) - config["safety_threshold"])
示例14: increx
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
def increx(key, expire=60, incr=1):
result = redis.incr(key, incr)
redis.expire(key, expire)
return result
def halt(signal=None, frame=None):
print "Caught signal %s" % signal
ps_thread.stop()
if __name__ == "__main__":
print "Obtaining lock..."
db.query(func.pg_advisory_lock(413, 4)).scalar()
print "Lock obtained."
load_lists()
signal.signal(signal.SIGTERM, halt)
signal.signal(signal.SIGINT, halt)
ps = redis.pubsub(ignore_subscribe_messages=True)
ps.psubscribe(**{"spamless:reload": load_lists, "channel:*": on_ps})
ps_thread = ps.run_in_thread(sleep_time=0.01)
while ps_thread.is_alive():
redis.setex("spamless:alive", 10, "alive")
ps_thread.join(3)
示例15: TestCheckTasksRequestedByUser
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import setex [as 别名]
class TestCheckTasksRequestedByUser(object):
def setUp(self):
self.connection = StrictRedis()
self.connection.flushall()
@patch('pybossa.api.task_run.get_user_id_or_ip')
def test_check_task_requested_by_user_authenticated_key_exists(self, user):
"""_check_task_requested_by_user should return True for an authorized
user that requested a task"""
user.return_value = {'user_id': 33, 'user_ip': None}
taskrun = TaskRun(task_id=22)
key = 'pybossa:task_requested:user:33:task:22'
self.connection.setex(key, 10, True)
check = _check_task_requested_by_user(taskrun, self.connection)
assert check is True, check
@patch('pybossa.api.task_run.get_user_id_or_ip')
def test_check_task_requested_by_user_anonymous_key_exists(self, user):
"""_check_task_requested_by_user should return True for an anonymous
user that requested a task"""
user.return_value = {'user_id': None, 'user_ip': '127.0.0.1'}
taskrun = TaskRun(task_id=22)
key = 'pybossa:task_requested:user:127.0.0.1:task:22'
self.connection.setex(key, 10, True)
check = _check_task_requested_by_user(taskrun, self.connection)
assert check is True, check
@patch('pybossa.api.task_run.get_user_id_or_ip')
def test_check_task_requested_by_user_wrong_key(self, user):
"""_check_task_requested_by_user should return False for a user that did
not request a task"""
user.return_value = {'user_id': 33, 'user_ip': None}
taskrun = TaskRun(task_id=22)
key = 'pybossa:task_requested:user:88:task:44'
self.connection.setex(key, 10, True)
check = _check_task_requested_by_user(taskrun, self.connection)
assert check is False, check
@patch('pybossa.api.task_run.get_user_id_or_ip')
def test_check_task_requested_by_user_authenticated_deletes_key(self, user):
"""_check_task_requested_by_user deletes the key after checking that
an authenticated user requested the task"""
user.return_value = {'user_id': 33, 'user_ip': None}
taskrun = TaskRun(task_id=22)
key = 'pybossa:task_requested:user:33:task:22'
self.connection.setex(key, 10, True)
_check_task_requested_by_user(taskrun, self.connection)
key_deleted = self.connection.get(key) is None
assert key_deleted is True, key_deleted
@patch('pybossa.api.task_run.get_user_id_or_ip')
def test_check_task_requested_by_user_anonymous_preserves_key(self, user):
"""_check_task_requested_by_user does not delete the key after checking
that an anonymous user requested the task (in case many simultaneous
anonymous users are sharing the same IP"""
user.return_value = {'user_id': None, 'user_ip': '127.0.0.1'}
taskrun = TaskRun(task_id=22)
key = 'pybossa:task_requested:user:127.0.0.1:task:22'
self.connection.setex(key, 10, True)
_check_task_requested_by_user(taskrun, self.connection)
key_deleted = self.connection.get(key) is None
assert key_deleted is False, key_deleted