def get_coverart(self, album): path = "app/static/media/" filename = "%s.jpg" % album.id musicbrainzngs.set_useragent("python-musicplayer-flask","0.1","*****@*****.**") covers = cache.get('covers') if album.id in covers: return covers.append(album.id) cache.set("covers", covers) if not album.musicbrainz_albumid or album.coverimage: return #raise NameError('musicbrainz_albumid not set') try: data = musicbrainzngs.get_image_list(album.musicbrainz_albumid) except Exception as e: return e if len(data['images']) == 0: raise NameError('No images returned from service') urllib.request.urlretrieve(data['images'][0]['image'], "%s%s" % (path, filename)) ci = open("%s%s" % (path, filename), 'rb') album.coverimage.put(ci, content_type = 'image/jpeg') return
def fetchCategory(category_id=0, slug='', name=''): from app import cache if category_id: cache_key = 'category_' + str(category_id) query_cond = 'category_id' entity = category_id elif slug: cache_key = 'category_' + slug query_cond = 'slug_url' entity = slug elif name: cache_key = 'category_' + name.replace(' ', '_') query_cond = 'category_name' entity = name else: return {} category = cache.get(cache_key) if category: return category cursor = mysql.connect().cursor() cursor.execute( "SELECT * FROM categories WHERE " + query_cond + " = %s", (entity, )) category = Utils.fetchOneAssoc(cursor) category = WebUtils.extendCategoryProperties(category) cache.set(cache_key, category) return category
def request_access_token(self, use_cache=True): if use_cache: cache_token = cache.get(ease_mob_token_cache_key) if cache_token: return cache_token params = { "grant_type": "client_credentials", "client_id": self.client_id, "client_secret": self.client_secret } request = requests.post(self.generate_token_url(), headers=self.request_header, data=json.dumps(params)) access_token = request.json().get("access_token", None) # 请求access_token失败的log if not access_token: log.error( json.dumps({ "params": params, "result": request.json(), })) if access_token: cache.set(ease_mob_token_cache_key, access_token, 60 * 60 * 24) return access_token
def increase(self, key): user_statistic = self.get() if key == 1: user_statistic['added'] += 1 elif key == 2: user_statistic['wrong'] += 1 cache.set(self.key, user_statistic, timeout=int(self.tomorrow.total_seconds()))
def edit_job(job_id: int) -> "render_template('job/add_job.html')": edit = True job = Job.find_job_by_id(job_id) form = JobForm(obj=job) if request.method == "POST" and form.validate_on_submit(): job_id = str(job_id) form.populate_obj(job) job.last_edited = get_date_now() cache.delete(job_id) cache.set(key=job_id, value=job) job.save() log = f"You successful edited a job with ID {job_id} on the {format_date(job.applied_date)}" log_account_activity(session["username"], log) flash("You have successfully edited your job", "success") return secure_redirect_or_403( url_for('job_app.get_job_with_id', job_id=job_id)) return render_template("job/add_job.html", form=form, login_form=LoginForm(), edit=edit, job_id=job_id)
def create_token_seller(): token = cache.get('token-seller') if token is None: ## prepare request input data = {'client_key': 'seller_2', 'client_secret': 'seller2'} ## do request req = call_client(request) res = req.post('/signin', data=json.dumps(data), content_type='application/json' ) # seperti nembak API luar (contoh weather.io) ## store response res_json = json.loads(res.data) logging.warning('RESULT : %s', res_json) ## assert / compare with expected result assert res.status_code == 200 ## save token into cache cache.set('token-seller', res_json['token'], timeout=60) ## return because it useful for other test return res_json['token'] else: return token
def rentbook(): from app import cache data = request.form['text'] if not data: return "Please enter book_id and locality after /rent" print request.form cache.set(request.form['user_id'] + '_book_id', data.split(' ')[0], timeout=10000) area = ' '.join(data.split(' ')[1:]) validation = User.validateLocality(area) if validation['is_valid']: response = { "username": "******", "mrkdwn": True, "text": "*" + validation['delivery_message'] + "*\n Please enter /contact full_address phone_number. Eg.: /contact 58,1st Main Road 9898989898" } return Response(json.dumps(response), mimetype='application/json') else: return validation[ 'delivery_message'] + ": Sorry. Ostrich doesn't deliver here yet :slightly_frowning_face:"
def get_num_commits(): num = cache.get('num_commits') if num is None: num = sum((len(requests.get(GITHUB_API%i).json()) for i in range(1, MAX_PAGES))) cache.set('num_commits', num, timeout=5*60) print "caclulated" return num
def get_top_technology(category, order = 'DESC', limit = 5): """获取最高使用率的不同种类的技术类型""" result = cache.get('top_' + category + '_item_' + order) if result is None: rs = db.session.execute('select technology.title, count(website.id) from website \ left join website_tech on website_tech.website_id = website.id \ left join technology on technology.id = website_tech.tech_id \ and technology.title in (\ select distinct technology.title from technology \ where technology.category = \'' + category + '\' \ and technology.title != \'Unknown\') \ group by technology.title \ order by count(website.id) ' + order + ' limit 1,' + str(limit)) # 添加网站总数 result = [] for i in rs: if i[0] and i[0] != 'Unknown': result.append({ 'title' : i[0], 'total' : i[1] }) cache.set('top_' + category + '_item_' + order, result, timeout=app.config['SQL_CACHE_TIMEOUT']) return result
def on_move(self, data): current, playlist = get_playlist() to = data['to'] playlist.insert(int(data['to']), playlist.pop(playlist.index(int(data['from'])))) cache.set('playlist', playlist) self.broadcast('update', {'current':current, 'playlist':playlist})
def show_tech_json(title, page = 1, pagesize = app.config['PAGE_SIZE']): result = cache.get('tech_' + title + '_website_' + str(page) + '_' + str(pagesize)) if not result: websites = Website.query\ .filter(Website.technologies.any(Technology.title == title))\ .order_by(Website.frequency.desc())\ .paginate(page, pagesize, True) websites.items = filter_website(websites.items) result = [] for i in websites.items: techs = [] for t in i.technologies: if t.title != 'Unknown': techs.append({ 'title': t.title, 'detail' : t.detail }) result.append({ 'hostname' : i.hostname, 'port' : i.port, 'technologies' : techs }) cache.set('tech_' + title + '_website_' + str(page) + '_' + str(pagesize), result, timeout=app.config['SQL_CACHE_TIMEOUT']) return jsonify(status = 'ok', page = page, pagesize = pagesize, websites = result)
def edit_profile(): if request.remote_addr != "127.0.0.1": return "UNAUTHORIZED ACCESS ATTEMPT REJECTED" form = ProfileForm() if form.validate_on_submit(): if cache.get('ip_dict_valid'): cache.set('rerun_setup', True) cache.set('ip_dict_valid', True) file = request.files['picture'] file.save(os.path.join(basedir,"app/static/profile.jpg")) pickling = {} #Get form data here! pickling["name"] = form.name.data pickling["location"] = form.location.data pickling["organization"] = form.organization.data pickling["about"] = form.about.data pickling["project"] = form.project.data pickling["project_description"] = form.project_description.data pickle.dump(pickling, open('pickledUser.p', 'wb')) #form.picture.save(filename) return redirect(url_for('profile')) #Get cpickle stuff here return render_template('edit_profile.html', form=form)
def beg(params, user_info): if user_info['data']['id'] == params['be_focused_user_id']: return Utils.formatError(CONST['CODE']['BAD_REQUEST']['value'], '无法添加自己为新朋友') addressBookdata = AddressBook.getAdddressBookByFocusedUserId( user_info['data']['id'], params['be_focused_user_id']) if addressBookdata != None: return Utils.formatError(CONST['CODE']['BAD_REQUEST']['value'], '已添加') msg_uuid = Utils.unique_id() userData = Users().getOne({Users.id == user_info['data']['id']}) data = { 'data': userData, 'action': 'beg_add', 'msg_uuid': msg_uuid, 'be_focused_user_id': params['be_focused_user_id'], 'focused_user_id': user_info['data']['id'] } socketio.emit('beg', Utils.formatBody(data), namespace='/api', room='@broadcast.' + str(params['be_focused_user_id'])) #,callback=success) #只缓存最新的一条 cache.set('@broadcast.beg' + str(params['be_focused_user_id']), data) return Utils.formatBody({}, msg='发送成功')
def create_token(isInternal): # Checking whether internal or not and prepare the data if isInternal: cachename = "test-internal-token" data = {'email': '*****@*****.**', 'kata_sandi': 'l3l11234'} else: cachename = "test-non-internal-token" data = {'email': '*****@*****.**', 'kata_sandi': 'l3l1123456'} token = cache.get(cachename) if token is None: # Do Request req = call_client(request) res = req.post('/token', json=data, content_type='application/json') # Store Response res_json = json.loads(res.data) logging.warning('RESULT : %s', res_json) # Assertion assert res.status_code == 200 # Save token into cache cache.set(cachename, res_json['token'], timeout=60) # Return, because it is useful for other test return res_json['token'] else: return token
def create_token_int(): token = cache.get('test-token-int') # supaya tokennya bisa diambil lagi if token is None: data = { 'client_key': 'internal1', 'client_secret': 'th1s1s1nt3rn4lcl13nt' } # do request req = call_client(request) res = req.get('/auth', query_string=data, content_type='application/json') # store response res_json = json.loads(res.data) logging.warning('RESULT : %s', res_json) # assert if the result is as expected assert res.status_code == 200 # save token into cache cache.set('test_token-int', res_json['token'], timeout=60) return res_json['token'] else: return token
def get(self): ''' 新增博客缓存 将博客信息按照blog_id_{blog_id}的形式存储在缓存中 ''' if 'manager_id' not in session: return {'status_code': 400, 'message': 'illegal request'}, 400 manager_id = session['manager_id'] parser = reqparse.RequestParser() parser.add_argument('blog_id', type=int) args = parser.parse_args() blog_id = args['blog_id'] # cache.delete('blog_id_%s'%blog_id) blog = cache.get('blog_id_%s' % blog_id) if not blog: blog = getBlog(blog_id=blog_id, user_id=manager_id) if blog is None: return { 'status_code': 400, 'message': 'some error happened in mysql, please check log' }, 400 cache.set('blog_id_%s' % blog_id, blog, timeout=600) updateBlogRead(blog_id=blog_id, user_id=manager_id) return { 'status_code': 200, 'message': 'get successfully', 'blog': blog }
def create_token(isInternal=False): if isInternal: cachename = 'test-admin-token' data = {"username": "******", "password": "******"} else: cachename = 'test-nonadmin-token' data = {"username": "******", "password": "******"} token = cache.get(cachename) # prepare request input if token is None: # do request req = call_client(request) res = req.post('/login', json=data) # store respons res_json = json.loads(res.data) logging.warning('RESULT: %s', res_json) # assert / compare with expected result assert res.status_code == 200 # save token into cache cache.set(cachename, res_json['token'], timeout=60) # return, bcz it usefull for other test return res_json['token'] else: return token
def create_token_internal(): token = cache.get('test-token') if token is None: # prepare request input data = { 'phone_number': '085735950340', 'password': '******', } # do request req = call_client(request) res = req.get('/login', query_string=data, content_type='application/json') # store response res_json = json.loads(res.data) app.logger.warning('RESULT : %s', res_json) # assert / compare with expected result assert res.status_code == 200 # save token into cache cache.set('test-token', res_json['token'], timeout=60) # return, because it usefull for other test return res_json['token'] else: return token
def get_coverart(self, album): path = "app/static/media/" filename = "%s.jpg" % album.id musicbrainzngs.set_useragent("python-musicplayer-flask", "0.1", "*****@*****.**") covers = cache.get('covers') if album.id in covers: return covers.append(album.id) cache.set("covers", covers) if not album.musicbrainz_albumid or album.coverimage: return #raise NameError('musicbrainz_albumid not set') try: data = musicbrainzngs.get_image_list(album.musicbrainz_albumid) except Exception as e: return e if len(data['images']) == 0: raise NameError('No images returned from service') urllib.request.urlretrieve(data['images'][0]['image'], "%s%s" % (path, filename)) ci = open("%s%s" % (path, filename), 'rb') album.coverimage.put(ci, content_type='image/jpeg') return
def get(self): ''' 获取用户信息 ''' parser = reqparse.RequestParser() parser.add_argument('token', type=str) args = parser.parse_args() token = args['token'] if not token: return { 'status_code': 400, 'message': '' }, 400 user_message = cache.get(token) ### 从缓存中获取用户信息 if user_message is None: return { 'status_code': 400, 'message': '登陆已过期' }, 400 cache.set(token, user_message, timeout=10080) return { 'status_code': 200, 'messaga': '', 'data': { 'user_message': user_message } }
def url_hits(): patterns = fetch_dynamic_patterns(app.config["URL_PATTERNS_FILE"]) logs = fetch_logs(app.config["LOG_FILE_TO_ANALYZE"]) urlhits = sorted( [(k[1], v) for k, v in logan.dynamic_urls(logs, patterns).iteritems()], key=lambda x: x[1], reverse=True )[:20] cache.set("url_hits", dict(urlhits), timeout=60 * 60)
def create_token(punya_toko=False): if punya_toko: cachename = 'test-punya-toko-token' data = {'email': '*****@*****.**', 'password': '******'} else: cachename = 'test-token' data = {'email': '*****@*****.**', 'password': '******'} token = cache.get(cachename) if token is None: #prepare request input #do request req = call_client(request) res = req.post('/auth/login', json=data) #store response res_json = json.loads(res.data) logging.warning('RESULT : %s', res_json) ## assert / compare with expected result assert res.status_code == 200 ## save token into cache cache.set(cachename, res_json['token'], timeout=60) ## return, because it useful for other test return res_json['token'] else: return token
def create_token(isinternal=True): if isinternal: cachename = 'test-internal-token' data = {'client_name': 'admin', 'client_password': '******'} else: cachename = 'test-noninternal-token' data = {'client_name': 'non-admin', 'client_password': '******'} token = cache.get(cachename) if token is None: # data={ # 'client_name':'admin', # 'client_password':'******' # } req = app.test_client(request) res = req.get('/login', query_string=data) res_json = json.loads(res.data) logging.warning('RESULT: %s', res_json) if res.status_code == 200: assert res.status_code == 200 cache.set(cachename, res_json['token'], timeout=60) return res_json['token'] else: pass else: return token
def createTokenUser(): token = cache.get('token-user') if token is None: # prepare request input data = {'email': '*****@*****.**', 'password': '******'} # do request req = call_client(request) res = req.post('/v1/auth', data=json.dumps(data), content_type='application/json') # store response res_json = json.loads(res.data) logging.warning('RESULT : %s', res_json) # assert / compare with expected result assert res.status_code == 200 # save token into cache cache.set('token-user', res_json['token'], timeout=60) # return because it useful for other test return res_json['token'] else: return token
def index(key): """Confirm with the user that the requested action is to be performed.""" message = cache.get('{0}/message'.format(key)) agreement = cache.get('{0}/agreement'.format(key)) severity = cache.get('{0}/severity'.format(key)) backward = cache.get('{0}/previous'.format(key)) forward = cache.get('{0}/next'.format(key)) form = ConfirmationForm() if form.validate_on_submit(): if form.confirmed.data: cache.set(forward, True) return redirect(forward) else: return redirect(backward) form.confirmed.label.text = agreement flash(message, severity) page_vars = { 'title': 'Confirm Action', 'form': form, 'cancel_path': backward } return render_template('confirm/index.html', **page_vars)
def getData(self, collection_id): from app import cache cache_key = 'collection_' + str(collection_id) collection_data = cache.get(cache_key) if collection_data: return collection_data cursor = mysql.connect().cursor() cursor.execute( """SELECT c.*, (select group_concat(ci.item_id order by ci.sort_order asc separator ',') from collections_items ci where ci.collection_id = c.collection_id) as item_ids, (select group_concat(concat(cm.meta_key,":",cm.meta_value) separator '&') from collections_metadata cm where cm.collection_id = c.collection_id) as metadata FROM collections c WHERE c.collection_id = %s""", (collection_id, )) data = Utils.fetchOneAssoc(cursor) if data['metadata']: collections_metadata_raw = data['metadata'] data['metadata'] = {} for props in collections_metadata_raw.split('&'): props_formatted = props.split(':') data['metadata'][props_formatted[0]] = props_formatted[1] if data['item_ids']: data['item_ids'] = [int(_) for _ in data['item_ids'].split(',')] data['items'] = Search().getById(data['item_ids']) else: data['items'] = [] if not data: data = {} cache.set(cache_key, data) return data
def create_token(role): if role == 'officer': cache_user = "******" elif role == 'surveyor': cache_user = "******" else: cache_user = "******" token = cache.get(cache_user) if token is None: # prepare request input if role == 'officer': data = {"nip": "P2001", "pin": "11223344"} elif role == 'surveyor': data = {"nip": "P2002", "pin": "11223344"} else: data = {"npwpd": "P1002", "pin": "11223344"} # do request req = call_user(request) res = req.post("/login/", json=data) # store response res_json = json.loads(res.data) logging.warning("RESULT: %s", res_json) # compare with expected result assert res.status_code == 200 assert res_json["message"] == "Token is successfully created" # save token into cache cache.set(cache_user, res_json["token"], timeout=30) # return return res_json["token"] return token
def create_token(role): if role == "user": cachename = 'test-token-user' data = { 'username': '******', 'password': "******" } elif role == "agent": cachename = 'test-token-agent' data = { 'username': '******', 'password': "******" } elif role == "seller": cachename = 'test-token-seller' data = { 'username': '******', 'password': "******" } elif role == "ok": cachename = 'test-token-admin' data = { 'username': '******', 'password': "******" } token = cache.get(cachename) if token is not None: return token req = call_client(request) res = req.get('/login', query_string=data) resjson = json.loads(res.data) logging.warning('RESULT: %s', resjson) assert res.status_code==200 cache.set(cachename, resjson['token'], timeout=60) return resjson['token']
def create_token_noninternal(): token = cache.get('test-token-noninternal') if token is None: ##prepare request input data = {'client_id': 'testusername', 'client_secret': 'testpassword'} # do request req = call_client(request) res = req.post('/login', data=json.dumps(data), content_type='application/json') ## store responese res_json = json.loads(res.data) logging.warning('RESULT : %s', res_json) # assert /compare with expected result assert res.status_code == 200 ## save token into cache cache.set('test-token-noninternal', res_json['token'], timeout=60) ## return, because it useful for other test return res_json['token'] else: return token
def create_token_noninternal(): token = cache.get('test-token-noninternal') if token is None: ##prepare request input data = {'client_key': 'CLIENT01', 'client_secret': 'SECRET01'} # do request req = call_client(request) res = req.get('/token', query_string=data) ## store responese res_json = json.loads(res.data) logging.warning('RESULT : %s', res_json) # assert /compare with expected result assert res.status_code == 200 ## save token into cache cache.set('test-token-noninternal', res_json['token'], timeout=60) ## return, because it useful for other test return res_json['token'] else: return token
def show_tech_json(title, page=1, pagesize=app.config['PAGE_SIZE']): result = cache.get('tech_' + title + '_website_' + str(page) + '_' + str(pagesize)) if not result: websites = Website.query\ .filter(Website.technologies.any(Technology.title == title))\ .order_by(Website.frequency.desc())\ .paginate(page, pagesize, True) websites.items = filter_website(websites.items) result = [] for i in websites.items: techs = [] for t in i.technologies: if t.title != 'Unknown': techs.append({'title': t.title, 'detail': t.detail}) result.append({ 'hostname': i.hostname, 'port': i.port, 'technologies': techs }) cache.set('tech_' + title + '_website_' + str(page) + '_' + str(pagesize), result, timeout=app.config['SQL_CACHE_TIMEOUT']) return jsonify(status='ok', page=page, pagesize=pagesize, websites=result)
def get_top_technology(category, order='DESC', limit=5): """获取最高使用率的不同种类的技术类型""" result = cache.get('top_' + category + '_item_' + order) if result is None: rs = db.session.execute( 'select technology.title, count(website.id) from website \ left join website_tech on website_tech.website_id = website.id \ left join technology on technology.id = website_tech.tech_id \ and technology.title in (\ select distinct technology.title from technology \ where technology.category = \'' + category + '\' \ and technology.title != \'Unknown\') \ group by technology.title \ order by count(website.id) ' + order + ' limit 1,' + str(limit)) # 添加网站总数 result = [] for i in rs: if i[0] and i[0] != 'Unknown': result.append({'title': i[0], 'total': i[1]}) cache.set('top_' + category + '_item_' + order, result, timeout=app.config['SQL_CACHE_TIMEOUT']) return result
def set_article_cache(column_id, column_url, id): """设置专栏文章缓存""" articles = get_all_articles_cache(column_id, 'column_' + column_url) article = Article.query.get_or_404(id) # I don't even know what I did. _data = { 'id': article.id, 'title': article.title, 'secrecy': article.secrecy } prev_article = next_article = None if articles[0] != _data: prev_article = articles[int(articles.index(_data)) - 1] if articles[-1] != _data: next_article = articles[int(articles.index(_data)) + 1] data = article.to_dict() data['next_article'] = { 'id': next_article['id'], 'title': next_article['title'] } if next_article else None data['prev_article'] = { 'id': prev_article['id'], 'title': prev_article['title'] } if prev_article else None cache_key = '_'.join(['article', column_url, str(id)]) cache.set(cache_key, data, timeout=60 * 60 * 24 * 30) return data
def create_token_internal(): token = cache.get('token-internal') if token is None: ## prepare request input data = { 'client_key': 'aul', 'client_secret': '123' } ## do request req = call_client(request) res = req.get('/login', query_string=data) # seperti nembak API luar (contoh weather.io) ## store response res_json = json.loads(res.data) logging.warning('RESULT : %s', res_json) ## assert / compare with expected result assert res.status_code == 200 ## save token into cache cache.set('token-internal', res_json['token'], timeout=60) ## return because it useful for other test return res_json['token'] else: return token
def get(self, params): # 查询首页顶部用户 if params["position"] == 1: return self.home_top_user_request(params) # 查询首页下部推荐用户中的活跃用户 active_user_list = [] # 查询所有缓存的活跃用户 if params["refresh"] == 0 and (params["last_id"] != 0 or params["offset"] != 0): cache_user_list = cache.get(self.home_active_user_cache_key) if cache_user_list: active_user_list = cache_user_list # 如果没有缓存的活跃用户,则查询数据库,并重新缓存结果 if not active_user_list and params["refresh"] == 0: active_user_list = HomeRecommendModel.query_home_active_users( 24, params) if active_user_list: cache.set(self.home_active_user_cache_key, active_user_list, self.home_active_user_cache_time) # 从缓存的活跃用户中分页获取要显示的用户列表 offset = params["offset"] if offset == 0: result_list = active_user_list[params["last_id"]:offset + self.per_page] if not result_list: result_list = [] else: result_list = [] # 如果缓存用户不足一页,则从home_recommend表中随机查询其它的用户 if result_list and len(result_list) < self.per_page: params["active_ids"] = array_column(result_list, "user_id") params["limit"] = self.per_page - len(result_list) if params["limit"] > 0: params["active_list"] = array_column(active_user_list, "user_id") if not params["offset"]: db_count = db.session.query(func.count( HomeRecommendModel.id)).scalar() params["offset"] = randint(1, db_count) if db_count else 0 params["last_id"] = 0 result_list_add = HomeRecommendModel.query_home_random_users( params) else: result_list_add = [] # 合并活跃用户和普通用户 home_recommend = result_list + result_list_add if not home_recommend: return json_success_response([]) return json_success_response( HomeRecommendHandler.format_home_users(home_recommend))
def query_black_people(user_id, refresh=False): """ 查询被我拉黑或我拉黑的用户的列表 :param user_id: 查询用户id :param refresh: 是否刷新缓存 """ cache_key = cache_black_key + str(user_id) if not refresh: result = cache.get(cache_key) if result: return result black_model_list = UserBlackModel.query.filter_by(user_id=user_id, status=1).all() if not black_model_list: black_model_list = [] black_id_list = array_column(black_model_list, "black_user_id") be_black_model_list = UserBlackModel.query.filter_by(black_user_id=user_id, status=1).all() if not be_black_model_list: be_black_model_list = [] be_black_id_list = array_column(be_black_model_list, "user_id") id_list = list(set(black_id_list).union(set(be_black_id_list))) if id_list: cache.set(cache_key, id_list) return id_list
def create_token_admin_non_super(): token = cache.get('token-non-super') if token is None: ## prepare request input data = {"username": "******", "password": "******"} ## do request req = call_client(request) res = req.post('/api/login/admin', data=json.dumps(data), content_type='application/json' ) # seperti nembak API luar (contoh weather.io) ## store response res_json = json.loads(res.data) logging.warning('RESULT : %s', res_json) ## assert / compare with expected result assert res.status_code == 200 ## save token into cache cache.set('token-non-internal', res_json['token'], timeout=60) ## return because it useful for other test return res_json['token'] else: return token
def wrapper(*args, **kwargs): key = 'memo' + request.path + str(request.form.values()) key = key.translate(dict.fromkeys(range(33))) output = cache.get(key) if output is None: output = func(*args, **kwargs) cache.set(key, output, 3600) return output
def get_home_page(commits): page = cache.get('homepage') if page is None: users = User.objects() page = render_template("home.html", users=users, commits=commits) cache.set('homepage', page, timeout=60) print 'rendered homepage' return page
def decorated_function(*args, **kwargs): cache_key = key % request.path rv = cache.get(cache_key) if rv is not None: return rv rv = f(*args, **kwargs) cache.set(cache_key, rv, timeout=timeout) return rv
def view(ip): cached = cache.get(ip+"page") if cached: return cached else: output = urllib2.urlopen("http://"+ip+":1337/profile").read().replace("^url_placeholder^", ip) cache.set(ip+"page", output) return output
def get_playlist(): current = cache.get('current') playlist = cache.get('playlist') if playlist == None: playlist = [] cache.set('playlist', playlist) #playlist = [] return current, playlist
def top_users(update=False): key = "all_uses" all_users = cache.get(key) if all_users is None or update: logging.error("Users DB QUERY") all_users = Users.query.all() all_users = list(all_users) cache.set(key, all_users) return all_users
def get_playlist(): """Get the primary keys of the songs in the current playlist""" current = cache.get("current") playlist = cache.get("playlist") if playlist == None: playlist = [] cache.set("playlist", playlist) # playlist = [] return current, playlist
def top_arts(update=False): key = "top" all_art = cache.get(key) if all_art is None or update: logging.error("DB QUERY") all_art = AsciiArt.query.order_by(AsciiArt.id.desc()).all() all_art = list(all_art) cache.set(key, all_art) return all_art
def send_script(uri): compiled = cache.get(uri) if compiled is None: try: s = Script.get(Script.uri == uri) compiled = s.compiled except Script.DoesNotExist: abort(404) cache.set(uri, compiled, timeout=CACHE_TIMEOUT) return Response(compiled, status=200, content_type='application/javascript')
def add_collection(path): covers = [] cache.set("covers", covers) for file in mp3_files(path): try: mp3_obj = mp3_file(file) #print("%s %s - %s" % (time.strftime("%I:%M:%S"), mp3_obj.song.songtitle, mp3_obj.artist.albumartist)) except Exception as e: print(e) print("Something's up with this file %s" % file)
def introduce_reply(loc, name): ip_dict = cache.get('ip_dict') ip_dict[request.remote_addr] = {'name':name, 'location':loc} cache.set('ip_dict', ip_dict) try: pickled = pickle.load(open('pickledUser.p', 'rb')) except Exception: pickled = {'name': "error", 'location': "error"} infodict = {'name':pickled['name'], 'location':pickled['location']} return json.dumps(infodict)
def request_user_slack(user_id): identifier = 'slack_id/%s' % user_id username = cache.get(identifier) if username is None: username = request_username_slack(user_id) if username is not None: cache.set(identifier, username) if username is not None: user = User.query.filter_by(username=username.lower()).first() return user return None
def get(uid): cached = cache.get('web_user_{}'.format(uid)) if cached: return cached else: user = User.where('uid', uid).get()[0] if user: cache.set('web_user_{}'.format(uid), user) return user else: return False
def get(cid): cached = cache.get("web_chat_{}".format(cid)) if cached: return cached else: chat = Chat.where("cid", cid).get()[0] if chat: cache.set("web_chat_{}".format(cid), chat) return chat else: return False
def append_song_to_playlist(song): global sleeper current, playlist = get_playlist() if not playlist and not current: path = get_path_from_song(song) player.loadfile(path) song.plays += 1 current = song.id sleeper = start_sleeper(song.length) else: playlist = playlist + [song.id] cache.set('playlist', playlist) cache.set('current', current) return current, playlist
def append_song_to_playlist(song): """Append a song to the playlist and play it if the playlist is empty.""" global sleeper current, playlist = get_playlist() if not playlist and not current: path = get_path_from_song(song) player.loadfile(path) song.plays += 1 current = song.id sleeper = start_sleeper(song.length) else: playlist = playlist + [song.id] cache.set("playlist", playlist) cache.set("current", current) return current, playlist
def stamps_ranking(page=1, limit=5): key = 'stamps/ranking.v1.%s.%s' % (page, limit) obj = cache.get(key) if obj is None: posts, total = Feed.ranking(page=page, limit=limit) obj = render_template('main/stamp/partials/_ranking.html', posts=posts, page=page, limit=limit, total=total) cache.set(key, obj, 3600) return obj
def stamps_welcome(page=1, limit=20): key = 'stamps/welcome.v1.%s.%s' % (page, limit) obj = cache.get(key) if obj is None: posts, total = Feed.posts(page=page, limit=limit) obj = render_template('main/stamp/partials/_index.html', posts=posts, page=page, limit=limit, total=total) cache.set(key, obj, 3600) return obj
def get_access_token(): token = cache.get(TOKEN_KEY) token_expired_at = cache.get(TOKEN_EXPIRED_AT_KEY) if token: return token, token_expired_at b = WechatBasic( appid=settings.APP_ID, appsecret=settings.SECRET) print 'get_access_token at:', datetime.datetime.now() d = b.get_access_token() token = d['access_token'] expired_at = d['access_token_expires_at'] cache.set(TOKEN_KEY, token, int(expired_at - time.time())*60) cache.set(TOKEN_EXPIRED_AT_KEY, expired_at, int(expired_at - time.time())*60) return token, expired_at
def index(): stats = cache.get('web_stats') if not stats: stats = { 'users_count': User.all().count(), 'chats_count': Chat.all().count(), 'messages_count': sum(u.msg_count for u in UserStat.all()) } cache.set('web_stats', stats, 300) return render_template('index.html', page_title='Confstat', users_count=stats['users_count'], chats_count=stats['chats_count'], messgaes_count=stats['messages_count'])
def stamps_category(category, page=1, limit=20): key = 'stamps/category.v1.%s.%s.%s' % (category.id, page, limit) obj = cache.get(key) if obj is None: posts, total = Feed.category(category, page=page, limit=limit) obj = render_template('main/stamp/partials/_category.html', category=category, posts=posts, page=page, limit=limit, total=total) cache.set(key, obj, 3600) return obj
def next_song(): global sleeper old_sleeper = sleeper current, playlist = get_playlist() try: current = playlist.pop(0) song = Song.query.filter_by(id=current).first() song.plays += 1 path = get_path_from_song(song) player.loadfile(path) db.session.commit() sleeper = start_sleeper(song.length) except: current = None; player.stop(); cache.set('current',current) cache.set('playlist', playlist) sockets.UpdateNamespace.broadcast('update', {'current':current, 'playlist':playlist}) old_sleeper.kill()
def next_song(): """Start the next song playing and update the playlist.""" global sleeper old_sleeper = sleeper current, playlist = get_playlist() try: current = playlist.pop(0) song = Song.query.filter_by(id=current).first() song.plays += 1 path = get_path_from_song(song) player.loadfile(path) db.session.commit() sleeper = start_sleeper(song.length) except: current = None player.stop() cache.set("current", current) cache.set("playlist", playlist) sockets.UpdateNamespace.broadcast("update", {"current": current, "playlist": playlist}) old_sleeper.kill()