本文整理汇总了Python中redis.StrictRedis.scan方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.scan方法的具体用法?Python StrictRedis.scan怎么用?Python StrictRedis.scan使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.scan方法的4个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: main
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import scan [as 别名]
def main():
print "Redis status as of:", datetime.datetime.now()
ap = ArgumentParser(description="List a summary of Redis data structures")
ap.add_argument('-H', '--host', default='localhost')
ap.add_argument('-p', '--port', default=6379)
args = ap.parse_args()
r = StrictRedis(host=args.host, port=args.port)
for k in sorted(r.scan()[1]):
for kind, count in ('list', r.llen), ('sset', r.zcard), ('set', r.scard), ('hash', r.hlen):
try:
cnt = count(k)
print "[%-4s] %-25s %s" % (kind, k, cnt)
except:
pass
示例2: int
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import scan [as 别名]
user_id=dead_chat_user.user_id,
type="timeout",
name=dead_chat_user.name,
text="%s's connection timed out." % dead_chat_user.name,
),
)
print "Sent timeout message."
db.commit()
# Generate connected/searching counters every 10 seconds.
if int(current_time) % 10 == 0:
print "Generating user counters."
connected_users = set()
next_index = 0
while True:
next_index, keys = redis.scan(next_index, "chat:*:online")
for key in keys:
for user_id in redis.hvals(key):
connected_users.add(user_id)
if int(next_index) == 0:
break
redis.set("connected_users", len(connected_users))
searching_users = set()
for searcher_id in redis.smembers("searchers"):
session_id = redis.get("searcher:%s:session_id" % searcher_id)
user_id = redis.get("session:%s" % session_id)
if user_id is not None:
searching_users.add(user_id)
redis.set("searching_users", len(searching_users))
rouletting_users = set()
for searcher_id in redis.smembers("roulette_searchers"):
示例3: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import scan [as 别名]
#.........这里部分代码省略.........
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"])
# Requests proxy
def _requests_proxy(self, method, *args, **kwargs):
realms = kwargs.pop("realms", None)
wait = kwargs.pop("wait", False)
if realms is None:
raise RequestsRespectfulError("'realms' is a required kwarg")
return self.request(lambda: getattr(requests, method)(*args, **kwargs), realms, wait=wait)
def _requests_proxy_delete(self, *args, **kwargs):
return self._requests_proxy("delete", *args, **kwargs)
def _requests_proxy_get(self, *args, **kwargs):
return self._requests_proxy("get", *args, **kwargs)
def _requests_proxy_head(self, *args, **kwargs):
return self._requests_proxy("head", *args, **kwargs)
def _requests_proxy_options(self, *args, **kwargs):
return self._requests_proxy("options", *args, **kwargs)
def _requests_proxy_patch(self, *args, **kwargs):
return self._requests_proxy("patch", *args, **kwargs)
def _requests_proxy_post(self, *args, **kwargs):
return self._requests_proxy("post", *args, **kwargs)
def _requests_proxy_put(self, *args, **kwargs):
return self._requests_proxy("put", *args, **kwargs)
@staticmethod
def _validate_request_func(request_func):
request_func_string = inspect.getsource(request_func)
post_lambda_string = request_func_string.split(":")[1].strip()
if not post_lambda_string.startswith(config["requests_module_name"]) and not post_lambda_string.startswith("getattr(requests"):
raise RequestsRespectfulError("The request lambda can only contain a requests function call")
@staticmethod
def _config():
return config
示例4: RedisTokenStore
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import scan [as 别名]
class RedisTokenStore(TokenStoreBase):
def __init__(self, configstring):
if configstring == "":
self.redis = StrictRedis()
else:
host, port, db = configstring.split(":")
self.redis = StrictRedis(host=host, port=port, db=int(db))
self.token_prefix = "bayes_token_"
self.total_key = "bayes_total"
self.seen_prefix = "bayes_seen_"
self.expiration = 7 * 24 * 3600 # one week
self.recalc_totals_interval = 24 * 3600 # once per day
self.labels = ["spam", "ham"]
def recalc_totals(self):
"""from time to time we need to reduce the totals from expired messages"""
for label in self.labels:
kset = set()
pattern = self.seen_prefix + label + "*"
start, values = self.redis.scan(0, match=pattern)
while True:
start, values = self.redis.scan(start, match=pattern)
for v in values:
kset.add(v)
if start == "0":
break
oldval = self.redis.hget(self.total_key, label)
newval = len(kset)
self.redis.hset(self.total_key, label, newval)
# print "%s changed from %s to %s"%(label,oldval,newval)
def background_recalc(self):
# maybe another host/thread already did the recalc, sleep a while before we do it ourselves
now = int(time.time() + random.randint(1, 20))
self.redis.hset(self.total_key, "last_recalc", now)
time.sleep(1)
if self.redis.hget(self.total_key, "last_recalc") == now:
self.recalc_totals()
def get_(self, token, what):
assert what in self.labels
keyname = self.token_prefix + token
count = self.redis.hget(keyname, what)
try:
return int(self.redis.hget(keyname, what))
except:
return 0
def get_ham_count(self, token):
return self.get_(token, "ham")
def get_spam_count(self, token):
return self.get_(token, "spam")
def get_total_ham_count(self):
"""get the number of known ham messages"""
try:
return int(self.redis.hget(self.total_key, "ham"))
except:
return 0
def get_total_spam_count(self):
"""get the number of known spam messages"""
try:
return int(self.redis.hget(self.total_key, "spam"))
except:
return 0
def learn_(self, tokens, aswhat):
assert aswhat in self.labels
digest = sha1()
pipeline = self.redis.pipeline()
for t in set(tokens):
keyname = self.token_prefix + t
curcount = pipeline.hincrby(keyname, aswhat, 1)
if curcount == 1: # only expire on first insert to make sure
pipeline.expire(keyname, self.expiration)
digest.update(t.encode("utf-8", "ignore"))
pipeline.hincrby(self.total_key, aswhat, 1)
pipeline.set(self.seen_prefix + aswhat + "_" + digest.hexdigest(), 1)
pipeline.execute()
if self.recalc_necessary():
thread.start_new_thread(self.background_recalc, ())
def recalc_necessary(self):
last_recalc = self.redis.hget(self.total_key, "last_recalc")
if last_recalc == None:
last_recalc = 0
last_recalc = int(last_recalc)
return time.time() - last_recalc > self.recalc_totals_interval
def learn_ham(self, tokens):
self.learn_(tokens, "ham")
def learn_spam(self, tokens):
self.learn_(tokens, "spam")