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 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 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 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 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