本文整理汇总了Python中redis.StrictRedis.get方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.get方法的具体用法?Python StrictRedis.get怎么用?Python StrictRedis.get使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.get方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: app
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
def app(environ, start_response):
ret = {}
qs = dict(parse_qsl(environ["QUERY_STRING"]))
red = StrictRedis(host="localhost", port=6379, db=0)
root_key = red.get("root")
if root_key is None: #Load trucks into redis if there is no tree already in it
inp_file = "Mobile_Food_Facility_Permit.csv"
load_trucks(inp_file, red)
root_key = red.get("root")
try:
lat = float(qs["latitude"])
lon = float(qs["longitude"])
rad = float(qs["radius"])
except KeyError: #Return error if required fields aren't present
start_response("400 Bad Request", [("Content-type", "text/plain")])
ret["error"] = "latitude, longitude, and radius query parameters are required"
return [dumps(ret)]
ret["latitude"] = lat
ret["longitude"] = lon
ret["radius"] = rad
food = qs.get("food", "").upper()
if food:
ret["food"] = food
ret["trucks"] = [str(t)
for t in get_trucks(lat, lon, rad, red, root_key) if food in t.food]
else:
trucks = []
foods = set()
for t in get_trucks(lat, lon, rad, red, root_key):
trucks.append(str(t))
foods |= set(t.food)
ret["trucks"] = trucks
ret["foods"] = list(foods)
start_response("200 OK", [("Content-type", "text/plain")])
return [dumps(ret)]
示例2: RedisDataStore
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [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()
示例3: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [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
示例4: test_token
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
def test_token(redis_server):
conn = StrictRedis(unix_socket_path=UDS_PATH)
lock = Lock(conn, "foobar-tok")
tok = lock.id
assert conn.get(lock._name) is None
lock.acquire(blocking=False)
assert conn.get(lock._name) == tok
示例5: RedisRequestLogger
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [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
示例6: BearerAuth
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
class BearerAuth(BasicAuth):
""" Overrides Eve's built-in basic authorization scheme and uses Redis to
validate bearer token
"""
def __init__(self):
super(BearerAuth, self).__init__()
self.redis = StrictRedis()
def check_auth(self, token, allowed_roles, resource, method):
""" Check if API request is authorized.
Examines token in header and checks Redis cache to see if token is
valid. If so, request is allowed.
:param token: OAuth 2.0 access token submitted.
:param allowed_roles: Allowed user roles.
:param resource: Resource being requested.
:param method: HTTP method being executed (POST, GET, etc.)
"""
if not token:
return False
user_id = self.redis.get(token)
if not user_id:
return False
# now switching to the user-reserved mongo instance.
mongo_prefix = 'MONGO%s' % user_id
# TODO remove defaulting to localhost so exception is raised
# if db host is not available. Right now, unless redis hodls a
# key for the user, all dbs are hosted on localhost.
host = self.redis.get(user_id) or 'localhost'
if not host:
raise ConfigException('Cannot locate host for user database %s' %
user_id)
uri = 'mongodb://%s/%s' % (host, user_id)
current_app.config['%s_URI' % mongo_prefix] = uri
self.set_mongo_prefix(mongo_prefix)
return True
def authorized(self, allowed_roles, resource, method):
""" Validates the the current request is allowed to pass through.
:param allowed_roles: allowed roles for the current request, can be a
string or a list of roles.
:param resource: resource being requested.
"""
try:
token = request.headers.get('Authorization').split(' ')[1]
except:
token = None
return self.check_auth(token, allowed_roles, resource, method)
示例7: get
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
def get(cls, name):
db = StrictRedis()
value = None
while True:
ver = db.get(name+'::v')
value = cls._get(db, name)
if ver == db.get(name+'::v'):
break
return value
示例8: check_health_status
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
def check_health_status(self):
'''
Verify that all necessary systems are available and running correctly.
'''
status = {'result': 'error', 'message': 'failure'}
self.log.info("check_health_status(): starting health check")
# Check Redis. Fail right-away if Redis is down - verifies infrastructure
try:
cache = StrictRedis(db=config.health_cache_redis_db)
cache.set('test', 'test')
rv = cache.get('test')
if rv <> 'test':
return {'result': 'error', 'message': 'redis is not responding correctly'}
except Exception as ex:
self.log.critical("check_health_status() redis is not responding: " + str(ex))
return {'result': 'error', 'message': 'redis is not responding'}
# Check if down for maintenance
cache = StrictRedis(db=config.health_cache_redis_db)
is_maintenance = cache.get('is_maintenance')
if is_maintenance == 'true':
return {'result': 'error', 'message': 'system is down for maintenance'}
# Do a web request for all buildings - verifies data quality
try:
cache = StrictRedis(db=config.tokens_cache_redis_db)
token = config.test_token
token_hash = auth.calc_hash(token)
cache.set(token_hash, '[email protected]')
r = requests.get('http://localhost:8888/org/v1/buildings', auth=(token, ''))
buildings = r.json()
if len(buildings) < 65 or len(buildings) > 90:
self.log.critical("check_health_status(): building data failure")
return {'result': 'error', 'message': 'building data failure'}
#cache.delete(token_hash)
except Exception as ex:
self.log.critical("check_health_status(): building data failure: " + str(ex))
return {'result': 'error', 'message': 'building data failure: ' + str(ex)}
# Check db -- if down set flag to not expire data. Do not fail if db is down
status = {'result': 'success', 'message': "success"}
return status
示例9: RedisRequestLogger
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
class RedisRequestLogger(RequestLoggerBase):
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):
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):
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
示例10: store
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
def store(self):
from simplekv.memory.redisstore import RedisStore
r = StrictRedis()
try:
r.get('anything')
except ConnectionError:
pytest.skip('Could not connect to redis server')
r.flushdb()
yield RedisStore(r)
r.flushdb()
示例11: TaskCache
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
class TaskCache(ITaskCache):
"""
`self.user_store': {'user_id': <list of task_ids>}
`self.task_store`: {'task_id`: <AsyncResult>}
`self.progress_store`: {`task_id`: `progress_value(int)`}
"""
def __init__(self, user_kwargs, task_kwargs ,progress_kwargs):
self.user_store = StrictRedis(**user_kwargs)
self.task_store = StrictRedis(**task_kwargs)
self.progress_store = LingvodocRedisClient(**progress_kwargs)
def get(self, user, remove_finished=False):
result = dict()
tasks = self.user_store.get(user.id)
if tasks is None:
return {}
tasks = pickle.loads(tasks)
remained_tasks = list()
for t in tasks:
val = self.task_store.get(t)
if val is None:
continue
async_result = pickle.loads(val)
progress = self.progress_store.get(t)
# Redis client returns byte array. We need to decode it
if progress is not None:
progress = int(progress.decode())
result[t] = {'finished': async_result.ready(),
'progress': progress}
if remove_finished:
if async_result.ready():
self.task_store.delete(t)
else:
remained_tasks.append(t)
if remove_finished:
self.user_store.set(user.id, pickle.dumps(remained_tasks))
return result
# TODO: add try/catch handlers.
# we should remove the task from caches (and queue?) if exception is raised
def set(self, user, task_key, async_task):
self.task_store.set(task_key, pickle.dumps(async_task))
cached = self.user_store.get(user.id)
if cached is None:
tmp_tasks = [task_key]
else:
tmp_tasks = pickle.loads(cached)
tmp_tasks.append(task_key)
self.user_store.set(user.id, pickle.dumps(tmp_tasks))
示例12: DbRedis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [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)
示例13: polite_get
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [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
示例14: __admin_handler
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [as 别名]
def __admin_handler(self, endpoint: bytes):
"""
Handle Admin Request
:param bytes endpoint: Endpoint (in bytes!)
:return: jsonified answer data
"""
json_data = request.get_json()
if json_data is None:
raise BadRequest()
if 'admin_token' not in json_data:
raise BadRequest()
admin_token = json_data['admin_token']
if not isinstance(admin_token, str):
raise BadRequest()
if not RULE_TOKEN.match(admin_token):
raise BadRequest()
redis = StrictRedis(connection_pool=self.api_pool)
ep_key = 'ADMIN_TOKEN:{:s}'.format(admin_token)
should_endpoint = redis.get(ep_key)
if should_endpoint is None:
raise BadRequest()
redis.delete(ep_key)
if should_endpoint != endpoint:
raise BadRequest()
if 'data' not in json_data:
raise BadRequest()
data = json_data['data']
if not isinstance(data, dict):
raise BadRequest()
return jsonify(self.queue_dispatcher({
'_': 'admin:{:s}'.format(endpoint.decode('utf-8')),
'data': data,
}))
示例15: CacheHelper
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import get [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)