def fib_decompose(n, cache=None):
result = set()
if not cache:
cache = FunctionCache(lambda x: fib_decompose(x, cache))
# if it's already in the cache, why bother? Let's give it back!
if n in cache:
return cache.get(n)
if n <= 3:
result.add((n, ))
else:
for fib_nbr in get_fib_seq(n):
remain = n - fib_nbr
# skip solutions that require 1
if remain < 2:
continue
# get decompositions of the cached remain, computing it if it's not already in the cache
decompositions = cache.get(remain)
# add fib_nbr to the decompositions of the remaining, then sort each decompositions (to guarantee unicity),
# and add the decompositions to the final result if it's not already present
for decomp in \
map(
lambda x : tuple(sorted((x[0], *x[1]))),
it.product([fib_nbr], decompositions)
):
result.add(decomp)
return result
def passes(norad_id):
try:
query = PassesQuery().load(request.args)
except ValidationError as err:
abort(jsonify(err.messages))
limit = query.pop('limit')
cache_key = get_cache_key(norad_id, query, prefix="passes")
cache_response = cache.get(cache_key)
# Return results from cache if hit
if cache_response:
passes = json.loads(cache_response)
next_passes = filter_next_passes(passes)
return Response(json.dumps(next_passes[:limit]),
headers={
"x-api-cache": "HIT",
"x-api-cache-ttl": f"{cache.ttl(cache_key)}",
"content-type": "application/json"
})
# Calculate next passes
tracker = SatTracker(query["lat"], query["lon"], norad_id=norad_id)
passes = tracker.next_passes(days=query["days"],
visible_only=query["visible_only"])
# Cache passes for 1 day
content = json.dumps(passes)
cache.set(cache_key, content, ex=timedelta(days=1))
return Response(json.dumps(passes[:limit]),
headers={
"x-api-cache": "MISS",
"content-type": "application/json"
})
def get_auth_token(cls):
token = cache.get(cls.CACHE_KEY)
if not token:
token = cls.generate_auth_token()
cache.set(cls.CACHE_KEY, token, expire=cls.CACHE_EXPIRE)
return token
def get(cls, _id):
"""
:rtype: AbstractStaff | None
"""
key = 'staff:{0}'.format(_id)
return cache.get(key)
def get(cls, char_id, _id):
"""
:rtype: AbstractUnit | None
"""
key = 'unit:{0}:{1}'.format(char_id, _id)
return cache.get(key)
def get_auth_token(cls):
token = cache.get(cls.CACHE_KEY)
if not token:
token = cls.generate_auth_token()
cache.set(cls.CACHE_KEY, token, expire=cls.CACHE_EXPIRE)
return token
def validate_captcha(self, field):
captcha = field.data
email = self.email.data
cache_captcha = cache.get(email).decode()
if not cache_captcha or captcha.lower() != cache_captcha.lower():
raise ValidationError('验证码不正确!')
def check_captcha(cls, captcha):
captcha_lower = captcha.lower()
if cache.get(captcha_lower):
cache.delete(captcha_lower)
return True
else:
return False
def validate_graph_captcha(self, field):
graph_captcha = field.data
#print(graph_captcha)
#print(cache.get(key=graph_captcha.lower()))
# if graph_captcha != '1111':
if not cache.get(key=graph_captcha.lower()):
raise ValidationError(message='图形验证码错误')
def get(cls, _id):
"""
:rtype: AbstractStaff | None
"""
key = 'staff:{0}'.format(_id)
return cache.get(key)
def get(cls, char_id, _id):
"""
:rtype: AbstractUnit | None
"""
key = 'unit:{0}:{1}'.format(char_id, _id)
return cache.get(key)
def validate_sms_captcha(self, field):
sms_captcha = field.data
mobile = self.telephone.data
sms_captcha_mem = cache.get(mobile)
print(sms_captcha_mem)
if not sms_captcha or sms_captcha.lower() != sms_captcha_mem.lower():
raise ValidationError(message="短信验证码不一致")
def wrap(*args, **kwargs):
data = cache.get(redis_key)
if data:
return data
data = func(*args, **kwargs)
cache.set(redis_key, data, expire=ttl)
return data
def _tag_rate(self):
import math
total = int(cache.get(TRAIN_TOTAL))
file_path = os.path.join(DATA_DIR, 'tag_rate_train.dic')
file = open(file_path, 'w')
keys = cache.keys('%s*' %TRAIN_TAG_PREFIX)
for key in keys:
name = key[len(TRAIN_TAG_PREFIX):]
value = float(cache.get(key))
log = math.log10(total/value)
line = '%s\t%.3f\n' %(name.decode('utf-8'), log)
file.write(line.encode('utf-8'))
file.close()
def cache_obj(hid):
h = cache.get('hero:{0}'.format(hid))
if h:
return h
h = Hero(hid)
h.save_cache()
return h
def cache_obj(hid):
h = cache.get('hero:{0}'.format(hid))
if h:
return h
h = Hero(hid)
h.save_cache()
return h
def wrap(*args, **kwargs):
data = cache.get(redis_key)
if data:
return data
data = func(*args, **kwargs)
cache.set(redis_key, data, expire=ttl)
return data
def get(self, book_id=None):
"""Get detail information of book"""
book = cache.get(f"book:{book_id}")
if not book:
book = db.session.query(Book).filter_by(id=book_id).first()
if not book:
return {'message': "Not found"}, 404
cache.set(f"book:{book_id}", book)
return self.book_schema.dump(book)
def validate_sms_captcha(self, field):
sms_captcha = field.data
telephone = self.telephone.data
sms_captcha_mem = cache.get(telephone)
if sms_captcha != '1111':
if not sms_captcha_mem or sms_captcha_mem.lower(
) != sms_captcha.lower():
raise ValidationError(message='短信验证码错误!')
def validate_sms_captcha(self, field):
sms_captcha = field.data
print(sms_captcha)
telephone = self.telephone.data
print(telephone)
sms_captcha_cache = cache.get(telephone)
if not sms_captcha_cache or sms_captcha.lower(
) != sms_captcha_cache.lower():
raise ValidationError(message="短信验证码错误")
def wrap(request, *args, **kwargs):
char_id = getattr(request, char_id_name, None)
if not char_id:
return func(request, *args, **kwargs)
redis_key = 'opt:{0}:{1}'.format(func_name, char_id)
if keep_result:
data = cache.get(redis_key)
if data:
extra = {
'log_type_id':
1,
'error_id':
error_code,
'char_id':
char_id,
'func_name':
func_name,
'error_msg':
'Operate Too Fast, Return from cache',
'occurred_at':
arrow.utcnow().to(TIME_ZONE).format(
'YYYY-MM-DD HH:mm:ss')
}
logger.info(
"Operate Guard. Char {0} operate {1} too fast. Return result from cache."
.format(char_id, func_name),
extra=extra)
return data
data = func(request, *args, **kwargs)
cache.set(redis_key, data, expire=interval)
return data
else:
x = cache.get(redis_key)
if x:
raise SanguoException(
error_code, char_id, "Operate Guard",
"operate {0} too fast".format(func_name))
cache.set(redis_key, 1, expire=interval)
return func(request, *args, **kwargs)
def validate_sms_captcha(self, field):
sms_captcha = field.data
telephone = self.telephone.data
sms_captcha_mem = cache.get(key=telephone)
#print("sms_captcha",sms_captcha)
#print("sms_captcha_mem",sms_captcha_mem)
# if sms_captcha != '1111':
if not sms_captcha_mem or sms_captcha_mem.lower() != sms_captcha.lower(
):
raise ValidationError(message='短信验证码错误')
def validate_code():
email = request.form.get("email")
code = request.form.get("validate_code")
user = CMSUser.query.filter_by(email=email).first()
print(user)
if user and cache.get("validate_code") == code:
# print("ok")
return jsonify({"message": "验证成功"})
else:
return jsonify({"message": "验证码填写错误或者邮箱填写与之前不一致"})
def push_of_login(self, title, content):
key = 'getui:login:{0}'.format(self.account_id)
if cache.get(key):
return None
result = self._push(title, content)
self._set_cache(key)
return result
def push_of_login(self, title, content):
key = 'getui:login:{0}'.format(self.account_id)
if cache.get(key):
return None
result = self._push(title, content)
self._set_cache(key)
return result
def wrap(request, *args, **kwargs):
char_id = getattr(request, char_id_name, None)
if not char_id:
return func(request, *args, **kwargs)
redis_key = 'opt:{0}:{1}'.format(func_name, char_id)
if keep_result:
data = cache.get(redis_key)
if data:
extra = {
'log_type_id': 1,
'error_id': error_code,
'char_id': char_id,
'func_name': func_name,
'error_msg': 'Operate Too Fast, Return from cache',
'occurred_at': arrow.utcnow().to(TIME_ZONE).format('YYYY-MM-DD HH:mm:ss')
}
logger.info("Operate Guard. Char {0} operate {1} too fast. Return result from cache.".format(char_id, func_name),
extra=extra
)
return data
data = func(request, *args, **kwargs)
cache.set(redis_key, data, expire=interval)
return data
else:
x = cache.get(redis_key)
if x:
raise SanguoException(
error_code,
char_id,
"Operate Guard",
"operate {0} too fast".format(func_name)
)
cache.set(redis_key, 1, expire=interval)
return func(request, *args, **kwargs)
def wrap(request, *args, **kwargs):
char_id = getattr(request, char_id_name, None)
if not char_id:
return func(request, *args, **kwargs)
redis_key = 'opt:{0}:{1}'.format(func_name, char_id)
if keep_result:
data = cache.get(redis_key)
if data:
extra = {
'log_type_id': 1,
'error_id': errormsg.OPERATE_TOO_FAST,
'char_id': char_id,
'func_name': func_name,
'error_msg': 'Operate Too Fast, Return from cache',
'occurred_at': localnow().strftime('%Y-%m-%d %H:%M:%S'),
}
logger.info("Operate Guard. Char {0} operate {1} too fast. Return result from cache.".format(char_id, func_name),
extra=extra
)
return data
data = func(request, *args, **kwargs)
cache.set(redis_key, data, expire=interval)
return data
else:
x = cache.get(redis_key)
if x:
raise SanguoException(
errormsg.OPERATE_TOO_FAST,
char_id,
"Operate Guard",
"operate {0} too fast".format(func_name)
)
cache.set(redis_key, 1, expire=interval)
return func(request, *args, **kwargs)
def _tag_relations(self, prefix, func=None):
def default(a):
return a
if not func:
func = default
keys = cache.keys('%s*' %prefix)
file_path = os.path.join(DATA_DIR, '%s_%s.dic'
%(prefix.replace(':', '_').lower(), func.__name__))
file = open(file_path, 'w')
for key in keys:
items = cache.zrevrangebyscore(name=key, min='-inf', max='+inf', withscores=True)
name = key[len(prefix):]
total = 0
for tag, value in items:
score = cache.get(name=cache_key(TRAIN_TAG_PREFIX, tag.decode('utf-8')))
total += value/ float(func(score))
objs = []
for tag, value in items:
score = cache.get(name=cache_key(TRAIN_TAG_PREFIX, tag.decode('utf-8')))
percentage = value/float(func(score))/total
objs.append((tag, percentage))
def cmp(a, b):
return int(a[1]*1000) - int(b[1]*1000)
objs = sorted(objs, cmp=cmp, reverse=True)
values = ','.join(['%s__%.4f'%(obj[0].decode('utf-8'), obj[1]) for obj in objs])
line = '%s\t%s\n' %(name.decode('utf-8'), values)
file.write(line.encode('utf-8'))
file.close()
def wrapper(*args, **kwargs):
token = get_token()
if token is None:
return {"message": "Authentication required"}, 401, \
{"WWW-Authenticate": "Bearer realm='Token required'"}
if cache.get(f"blacklisted_token:{token}"):
return {"message": "Token is already blacklisted"}, 403
try:
decode_auth_token(token)
except jwt.ExpiredSignatureError:
return {"message": "Signature expired. Please log in again"}, 401
except jwt.InvalidTokenError:
return {"message": 'Invalid token. Please log in again.'}, 400
return function(*args, **kwargs)
def wrap(request, *args, **kwargs):
char_id = getattr(request, char_id_name, None)
if not char_id:
return func(request, *args, **kwargs)
redis_key = 'opt:{0}:{1}'.format(func_name, char_id)
if keep_result:
data = cache.get(redis_key)
if data:
extra = {
'log_type_id': 1,
'error_id': errormsg.OPERATE_TOO_FAST,
'char_id': char_id,
'func_name': func_name,
'error_msg': 'Operate Too Fast, Return from cache',
'occurred_at':
localnow().strftime('%Y-%m-%d %H:%M:%S'),
}
logger.info(
"Operate Guard. Char {0} operate {1} too fast. Return result from cache."
.format(char_id, func_name),
extra=extra)
return data
data = func(request, *args, **kwargs)
cache.set(redis_key, data, expire=interval)
return data
else:
x = cache.get(redis_key)
if x:
raise SanguoException(
errormsg.OPERATE_TOO_FAST, char_id, "Operate Guard",
"operate {0} too fast".format(func_name))
cache.set(redis_key, 1, expire=interval)
return func(request, *args, **kwargs)
def post(self):
form = ResetEmailForm(request.form)
if form.validate():
user = g.cms_user
new_eamil = form.newemail.data
email_captcha = form.emailcaptcha.data
if email_captcha == cache.get(new_eamil):
user.email = new_eamil
db.session.commit()
return success()
else:
return params_error(msg="验证码错误")
else:
msg = form.get_error()
return params_error(msg=msg)
def get_tle(norad_id):
"""Get latest TLE from API"""
cache_key = f"tle:{norad_id}"
tle = cache.get(cache_key)
if tle:
logger.info(f"Cache TLE HIT norad={norad_id}")
return json.loads(tle)
url = f"{NASA_TLE_API_URL}/{norad_id}"
assert NASA_TLE_API_KEY is not None, "Missing NASA TLE API Key"
response = session.get(url, params={"api_key": NASA_TLE_API_KEY})
tle = response.json()
logger.info(f"Cache TLE MISS, saving norad={norad_id}")
cache.set(cache_key, json.dumps(tle), CACHE_TIMEOUT)
return tle
def get_tle(norad_id):
"""Get latest TLE from API"""
cache_key = f"tle:{norad_id}"
tle = cache.get(cache_key)
if tle:
logger.info(f"Cache TLE HIT norad={norad_id}")
return tle.split("\n")
response = session.get(CELESTRAK_API_TLE, params={
"CATNR": norad_id,
"FORMAT": "TLE"
})
tle = response.text
if tle == "No GP data found":
raise TLENotFound
logger.info(f"Cache TLE MISS, saving norad={norad_id}")
cache.set(cache_key, tle, CACHE_TIMEOUT)
return tle.split("\n")
def email_captcha():
email = request.args.get('email')
if not email:
return restful.params_error(message='请传递邮箱')
else:
# string.ascii_letters 可以拿到一个a-zA-Z的字符串
# list()可以将字符串中的每一个字符作为列表的一项
source = list(string.ascii_letters)
# map(func= , 可迭代对象)
# map方法可以将可迭代对象中的每一项执行func方法
source.extend(map(lambda x:str(x),range(0,10)))
# random.sample(列表，个数)方法可以在列表中随机拿多少个
# ''.join() 可以将列表中的每一项组成一个字符串
captcha = ''.join(random.sample(source,6))
message = Message('Python论坛邮箱验证码',recipients=[email],body='您的邮箱验证码是：%s'%captcha)
try:
mail.send(message)
except:
return restful.params_error()
cache.set(email,captcha,ex=120)
print(cache.get(email))
return restful.success()
def post(self, token: str):
"""Function to set new password"""
new_password = request.json.get("password")
if not new_password:
return {"message": "Provide a new password"}, 400
try:
payload = decode_auth_token(token)
except jwt.ExpiredSignatureError:
return {"message": "The link is expired"}, 410
except jwt.InvalidTokenError:
return {
"message":
'The link is invalid. Check if the link '
'was copied rightly'
}, 400
uuid = payload["sub"]
if not cache.get(f"reset_password:{uuid}"):
return {"message": "This link was already used"}
user = db.session.query(User).filter_by(uuid=uuid).first()
user.password = new_password
user.save()
cache.delete(f"reset_password:{uuid}")
return {"message": "Password was successfully changed"}
def register(_data):
if not cache.exists(session['username']):
log.info('设置register_data[session[\'username\']]为空')
cache.set(session['username'] + '.count', 0, ex=600)
# expires in 10 minutes
session['action'] = 'register'
if verify(_data):
cache.rpush(session['username'], json.dumps(_data))
cache.incr(session['username'] + '.count')
log.info('获取到了一组合法签名数据')
log.debug(_data)
if int(cache.get(session['username'] + '.count')) >= 3:
log.info('获取到了三组信息，成功注册')
log.debug('所有数据:')
register_data = cache.lrange(session['username'], 0, -1)
register_data = [json.loads(i) for i in register_data]
log.debug(register_data)
cache.delete(session['username'])
cache.delete(session['username'] + '.count')
real = DynamicProcess.prepare_list(register_data)
real_v = DynamicProcess.prepare_value(real)
execute_sql(
"INSERT INTO user (username, password, sign_prepared, sign_val) values (\
%(username)s, %(password)s, %(sign_prepared)s, %(sign_val)s\
)",
username=session['username'],
password=session['password'],
sign_prepared=json.dumps(real),
sign_val=real_v)
session.pop('username')
session.pop('password')
return 'ret'
return 'continue'
def post(self):
"""Function to send link to mail"""
email = request.json.get("email")
username = request.json.get("username")
if not email and not username:
return {"message": "Email or username is required"}, 400
user = db.session.query(User).filter(
or_(User.username == username, User.email == email)).first()
if not user:
return {"message": "This user doesn't exist"}, 404
if cache.get(f"reset_password:{user.uuid}"):
print(f"reset_password:{user.uuid}")
return {"message": "Link was already sent"}, 409
token = encode_auth_token(user.uuid, LINK_EXPIRATION, user.is_admin)
cache.add(f"reset_password:{user.uuid}",
token,
timeout=int(timedelta(**LINK_EXPIRATION).total_seconds()))
# TODO: don't hardcode
send_email.apply_async(args=[
"Reset password", [user.email], f"Send POST-request by the link "
f"http://localhost:5000/auth/set-password/{token} "
f"to change your password"
])
return {"message": "Link to change password was sent to your mail"}
def get_info(self):
info = cache.get(self.make_cache_key())
if info:
return info
# 需要获取新数据
db = MongoClubLeaderboard.db(self.server_id)
my_doc = db.find_one({'_id': self.char_id})
if not my_doc:
ClubLeaderBoard.generate(self.server_id)
my_doc = db.find_one({'_id': self.char_id})
level = []
power = []
my_level_rank = 0
my_power_rank = 0
rank = 1
for doc in db.find({}).sort('level', -1).limit(30):
level.append((doc['_id'], doc['level'], doc['power']))
if doc['_id'] == self.char_id:
my_level_rank = rank
rank += 1
rank = 1
for doc in db.find({}).sort('power', -1).limit(30):
power.append((doc['_id'], doc['level'], doc['power']))
if doc['_id'] == self.char_id:
my_power_rank = rank
rank += 1
if not my_level_rank:
my_level_rank = db.find({'level': {'$gte': my_doc['level']}}).count()
if not my_power_rank:
my_power_rank = db.find({'power': {'$gte': my_doc['power']}}).count()
# 下次更新时间
# NOTE， 注意 定时任务也要同步修改
now = arrow.utcnow()
if now.minute >= 30:
# 下一个小时30分更新
next_update_at = now.replace(hours=1)
else:
next_update_at = now
# 虽然定时任务是30分启动的，但是这里设定到35分
next_update_at = next_update_at.replace(minute=35).timestamp
info = {
'level': level,
'power': power,
'my_level_rank': my_level_rank,
'my_power_rank': my_power_rank,
'next_update_at': next_update_at
}
expire = next_update_at - now.timestamp
cache.set(self.make_cache_key(), info, expire=expire)
return info
def validate_graph_captcha(self, field):
graph_captcha = field.data
graph_captcha_mem = cache.get(graph_captcha.lower())
if graph_captcha != '1111':
if not graph_captcha_mem:
raise ValidationError(message='图形验证码错误！')
def validate_captcha(self, field):
captcha = field.data
email = self.email.data
captcha_cache = cache.get(email)
if not captcha_cache or captcha_cache.lower() != captcha.lower():
raise ValidationError("邮箱验证错误！")
def validate_captcha(self, field):
captcha = field.data
email = self.email.data
real_captcha = cache.get(email)
if not real_captcha or real_captcha != captcha:
raise ValidationError("验证码错误")
def get_folder_list():
d = cache.get("folder_list")
if d is None:
d = build_folder_list()
cache.set("folder_list", d)
return d
def get_season_list():
d = cache.get("season_list")
if d is None:
d = build_season_list()
cache.set("season_list", d)
return d
