本文整理汇总了Python中redis.StrictRedis.set方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.set方法的具体用法?Python StrictRedis.set怎么用?Python StrictRedis.set使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.set方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
class Redis:
"""
To store and query local/remote Redis server.
"""
def __init__(self, host='localhost',
port=6379,
db=0,
password=None):
self.r = StrictRedis(host, port, db, password)
def __del__(self):
del(self.r)
def update(self, track):
self.r.set(track.key, track.stats())
def lookup(self, keyword):
# TODO: add option for caseless search
return self.r.keys('*' + keyword + '*')
def retrieve(self, key):
if isinstance(key, list):
return self.get_all(key)
return Track.from_redis(key, self.r.get(key))
def get_all(self, keys):
tracks = []
for key in keys:
tracks.append(Track.from_redis(key, self.r.get(key)))
return tracks
示例2: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [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)
示例3: feed_db
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
def feed_db(container_id, stats):
""" Store data to Redis.
args:
- constainer_id : (str) container's hash 12 first characters
- stats : a dictionary of stats
"""
if DEBUG:
print('feed db with container {} stats'.format(container_id))
# convert the time provided by stats to UTC format, parse it with strptime,
# and transform it again to the desired REDIS_KEY_TIMESTAMP format
instant_str = stats['read'][:-9]+stats['read'][-6:].replace(':', '')
instant = datetime.strptime(instant_str, '%Y-%m-%dT%H:%M:%S.%f%z')
timestamp = instant.strftime(REDIS_KEY_TIMESTAMP)
r = StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB)
for resource, value in stats.items():
if resource != 'read':
key = REDIS_KEY.format(timestamp=timestamp,
container_id=container_id,
resource=resource)
r.set(key, dumps(value))
r.expire(key, REDIS_EXPIRE_TIME)
if DEBUG:
print("Stored {} => {}".format(key, value))
示例4: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [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 set [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: CacheHelper
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
class CacheHelper(object):
"""A thin wrapper on top of Redis."""
def __init__(self, host="localhost", port=6379, db=0):
self.host = host
self.port = port
self.db = db
def __enter__(self):
self.r = StrictRedis(host=self.host, port=self.port, db=self.db)
return self
def __exit__(self, exc_type, exc_value, traceback):
try:
if any((exc_type, exc_value, traceback,)):
raise
finally:
pass
def get(self, key):
return self.r.get(key) if key in self.r.keys() else None
def set(self, key, json):
self.r.set(key, json)
def keys(self):
return self.r.keys()
def reset(self):
for key in self.keys():
self.r.delete(key)
示例7: test_get_text
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
def test_get_text(self):
r = StrictRedis()
r.set('test_get_2', "Open Mining")
DW = DataWarehouse()
self.assertEquals(
DW.get("test_get_2", content_type='application/text'),
"Open Mining")
示例8: sync_get
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [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
示例9: post
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
def post(self, request):
course_code = request.POST.get('course_code')
duration = int(request.POST.get('duration'))
r = StrictRedis(host='localhost', port=6379, db=0)
r.set('{}{}'.format(self.redis_key, course_code), course_code)
r.expire('{}{}'.format(self.redis_key, course_code), duration*3600)
return Response({'success': 'active_class stored'})
#def get_client_ip(request):
# x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
# if x_forwarded_for:
# ip = x_forwarded_for.split(',')[-1].strip()
# else:
# ip = request.META.get('REMOTE_ADDR')
# return ip
#or django-ipaware
示例10: test_list_preparation_with_invalid_type
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
def test_list_preparation_with_invalid_type(self) -> None:
"""
When a list key is already there with a wrong type
"""
redis = StrictRedis(connection_pool=self.__pool)
redis.set(self.__config['queue'], 'test')
self.assertRaises(ValueError, RedisQueueAccess, self.__config)
示例11: RedisManager
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [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)
示例12: search
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
def search():
query = request.args["q"]
ands = request.args["and"] if "and" in request.args else ""
ors = request.args["or"] if "or" in request.args else ""
nots = request.args["not"] if "not" in request.args else ""
try:
page = int(request.args["page"])
except:
page = 1
# cache server
redis = StrictRedis(host="localhost")
# start measuring elapsed time
start = time.time()
# try to load result from cache
key = json.dumps({
"q": query,
"a": ands,
"o": ors,
"n": nots
})
cache_result = redis.get(key)
items = cPickle.loads(cache_result) if cache_result else None
if not items:
items = SearchEngine(get_db(), query, ands, nots, ors) \
.search()
# store results in cache
redis.set(key, cPickle.dumps(items))
elapsed_time = (time.time() - start) * 1000
items_count = len(items)
pages_count = items_count // 10
if pages_count < items_count / 10.0:
pages_count += 1
if page > pages_count:
page = pages_count
# convert to index based
page -= 1
# calculate last item within this page
last_item_index = (page * 10) + 10
json_data = json.dumps({
"items": items[page * 10: last_item_index if last_item_index < items_count else items_count],
"total_count": items_count,
"elapsed_time": int(elapsed_time)
}, cls=SuperListJsonEncoder)
return Response(response=json_data,
status=200,
mimetype="application/json")
示例13: RedisRequestLogger
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
class RedisRequestLogger(RequestLoggerBase):
"""A faster alternative to the default logger, but requiring more configuration"""
def __init__(self):
from redis import StrictRedis
super(RedisRequestLogger, self).__init__()
self.db = StrictRedis(
host = getattr(settings, 'API_REDIS_HOST', 'localhost'),
port = getattr(settings, 'API_REDIS_PORT', 6379),
db = getattr(settings, 'API_REDIS_DB', 0),
password = getattr(settings, 'API_REDIS_PASSWORD', '')
)
def get_key(self, app):
return 'bambu-api-requests-%s' % app.key
def log_request(self, app):
"""Saves the number of requests within the given timeframe to the Redis database"""
timestamp = self.get_timestamp()
key = self.get_key(app)
values = self.db.get(key)
if values:
try:
values = pickle.loads(values)
except:
values = {}
else:
values = {}
if values.has_key(timestamp):
values = {
timestamp: values[timestamp] + 1
}
else:
values = {
timestamp: 1
}
self.db.set(key, pickle.dumps(values))
def get_request_count(self, app, timestamp):
"""Returns the number of requests by the specified app, within the specified timeframe"""
values = self.db.get(
self.get_key(app)
)
if values:
try:
values = pickle.loads(values)
except:
values = {}
else:
values = {}
return values.get(timestamp) or 0
示例14: control_me
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
def control_me():
r = StrictRedis()
print("Human controller started. Press 'q' to exit ... ")
while True:
c = getch()
if c == 'q':
return
r.set("action", c)
示例15: post
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import set [as 别名]
def post(self, request):
course_code = request.POST.get('course_code')
duration = int(request.POST.get('duration'))
r = StrictRedis(host='localhost', port=6379, db=0)
r.set('{}{}'.format(self.redis_key, course_code), course_code)
r.expire('{}{}'.format(self.redis_key, course_code), duration*3600)
return Response({'success': 'active_class stored'})