def setUpClass(self): self.app = create_app() self.app_ctx = self.app.app_context() self.app_ctx.push() user = User(username='******', password=generate_password_hash('nik')) db.session.add(user) user1 = User(username='******', password=generate_password_hash('dan')) db.session.add(user1) newcommunity = Community(title='com', type='public') user = User.query.filter_by(username='******').first() newcommunity.moderators_users.append(user) newcommunity.subscribe_user.append(user) db.session.add(newcommunity) post = Post(title='mypost1', html_page='', author=user.username, community=1, rating=2) db.session.add(post) post = Post(title='mypost2', html_page='', author=user.username, community=1) db.session.add(post) addNotification('nik', 'xoxo') db.session.commit() self.client = self.app.test_client()
def setUp(self): """configure virtual test environment.""" os.environ['APP_SETTING'] = 'Testing' self.app = create_app(config_name='testing') self.app_context = self.app.app_context() self.app_context.push() self.client = self.app.test_client()
def setUp(self): """Define test variables and initialize app.""" self.app = create_app("testing") api.init_app(self.app) api.add_namespace(questions_namespace) api.add_namespace(users_namespace) self.client = self.app.test_client()
def setUpClass(self): # create app package pkg = ZipFile('test.zip', 'w') pkg.write('testapp/application.py', arcname='application.py') pkg.write('testapp/manifest.json', arcname='manifest.json') pkg.write('testapp/requirements.txt', arcname='requirements.txt') pkg.write('testapp/wsgi.py', arcname='wsgi.py') pkg.close() # run self.pkg = os.path.join(os.path.dirname('.'), 'test.zip') if not os.path.exists(self.pkg): raise RuntimeError('Error creating test package: {0}'.format(self.pkg)) self.app = app.test_client() # monkey patch app to load custom test_settings utils.applications.app = create_app('test_settings') self.application = Application()
def setUpClass(self): self.app = create_app() self.app_ctx = self.app.app_context() self.app_ctx.push() user = User(username='******', password=generate_password_hash('nik')) db.session.add(user) newcommunity = Community(title='com', type='public') db.session.add(newcommunity) post = Post(title='mypost1', html_page='', author=user.username, community=1, rating=2) db.session.add(post) post = Post(title='mypost2', html_page='', author=user.username, community=1) db.session.add(post) db.session.commit() self.client = self.app.test_client()
import os from config import Config, setConfig, create_app from waitress import serve if __name__ == '__main__': is_prod = False config = Config() if os.environ.get('WORK_ENV') == 'PROD': config.debug = False is_prod = True else: config.debug = True setConfig(config) app = create_app(config) serve(app, port=8000, host="0.0.0.0")
def setUpClass(self): self.app = create_app() self.app_ctx = self.app.app_context() self.app_ctx.push() self.client = self.app.test_client()
from config import db, create_app from models import Country, City db.create_all(app=create_app()) app = create_app() app.app_context().push() # Data to initialize database with COUNTRIES = [ {'country': 'ni'} ] CITIES = [ {'city': 'Leon', 'active': True, 'country_id': 1}, {'city': 'Chinandega', 'active': True, 'country_id': 1}, {'city': 'Matagalpa', 'active': True, 'country_id': 1}, {'city': 'Managua', 'active': True, 'country_id': 1}, {'city': 'Granada', 'active': True, 'country_id': 1}, ] # Create the database db.create_all() # Iterate over the PEOPLE structure and populate the database for country in COUNTRIES: c = Country(country=country['country']) db.session.add(c) db.session.commit() for city in CITIES:
from flask import Flask, render_template import config app = config.create_app() from routes.others import others app.register_blueprint(others, url_prefix='/ic') from routes.admin import admin app.register_blueprint(admin, url_prefix='/ic/admin') from routes.authentication import authentication app.register_blueprint(authentication, url_prefix='/ic') @app.route('/') def index(): return render_template('index.html') if __name__ == '__main__': from models.models import db db.create_all() app.run(debug=True)
from flask import Flask from flask_sqlalchemy import SQLAlchemy from config import Config, create_app app = Flask(__name__) app.config.from_object(Config()) db = SQLAlchemy(app) create_app(app) if __name__ == "__main__": app.run(debug=True, host='0.0.0.0')
from flask import request, abort, jsonify, render_template import requests from config import create_app app = create_app(__name__) @app.cache.cached(timeout=60) @app.route("/") def index(): # main page return render_template("index.html", akid=request.values.get("akid")) @app.route("/prefill", methods=["GET"]) def prefill(): # prefill user info from akid akid = request.values.get("akid") if not akid: return abort(400, "akid param required") try: (mailing_id, user_id, token_hash) = akid.split(".") except ValueError: return abort(400, "malformed akid") user_url = "%s/rest/v1/user/%s" % (app.config["AK_BASE"], user_id) try: r = requests.get(user_url, auth=app.config["AK_AUTH"], timeout=(3.05, 20)) except requests.Timeout:
from flask import request from schemas import CategoryTypeListSchema from models import CategoryType, GenderEnum, Retailer, Category, db from config import create_app app = create_app() @app.route('/') def hello_world(): return 'Hello World!' @app.route('/get_categories_type_list/') def get_categories_type_list(): type_schema = CategoryTypeListSchema() category_types = CategoryType.query.all() return type_schema.jsonify(category_types, many=True) @app.route('/get_category_type/<typeid>/') def get_category_type(typeid): category_type = CategoryType.query.filter_by(id=typeid) if category_type.count(): type_schema = CategoryTypeListSchema() return type_schema.jsonify(category_type.first()) return f"CategoryType with this id: {typeid} haven't found" # POST: # {
import settings from app.api.v1 import api from app.api.v1.question import ns as questions_namespace from app.api.v1.user import ns as users_namespace from config import create_app config_name = settings.APP_ENVIRONMENT_SETTINGS # config_name = "development" app = create_app(config_name) api.init_app(app) api.add_namespace(questions_namespace) api.add_namespace(users_namespace) if __name__ == '__main__': app.run()
import requests from celery import Celery from flask_cors import CORS import os from dotenv import load_dotenv from config import create_app from config.config import app_config from config.redis_db import redis_db app = create_app('development') load_dotenv() # Add Redis URL configurations app.config["CELERY_BROKER_URL"] = os.getenv("REDIS_CONFIG") app.config["CELERY_RESULT_BACKEND"] = os.getenv("REDIS_CONFIG") app.config.from_object(app_config["development"]) # Add periodic tasks celery_beat_schedule = { "time_scheduler": { "task": "run.paginate_requested_data", # Run every second "schedule": 300.0, } } # configure celery celery = Celery(app.name) celery.conf.update(
from config import create_app app = create_app(config_name='development') from api.views.auth import shauri_blueprint from api.views.products import shauri_blueprint app.register_blueprint(shauri_blueprint, url_prefix = '/v2/api/')
def setUp(self): app = create_app(Config()) app.app_context().push() self.app = app.test_client()
def dev(): app = create_app('dev') app.run()
from config import create_app from flask import Flask, request, redirect, session from datetime import timedelta import os flask_app = create_app() flask_app.config['SECRET_KEY'] = os.urandom(24) #每一次服务器启动后,SECRET_KEY(盐)不一样 flask_app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=7) #配置过期时间 @flask_app.before_request def is_login(): # 判断是否登录 # 白名单设置,判断为登录页面时 if request.path == "/login": # 跳过处理 return None # 判断session是不存在时 if not session.get("userinfo"): # 重定向到登录页面 return redirect("/login") if __name__ == '__main__': flask_app.run("0.0.0.0", 8000, debug=True)
# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from flaskext.mongoalchemy import MongoAlchemy from config import create_app from uuid import uuid4 from datetime import datetime app = create_app() db = MongoAlchemy(app) class Log(db.Document): config_collection_name = 'logs' uuid = db.ComputedField(db.StringField(), lambda x: str(uuid4()), one_time=True) date = db.ComputedField(db.DateTimeField(), lambda x: datetime.utcnow(), one_time=True) level = db.IntField() name = db.StringField() message = db.StringField() @classmethod def clear(obj): Log._session.remove_query(Log).execute()
# -*- coding: utf-8 -*- import collections import csv import sys import os import json from flask import render_template, redirect, Markup, request import markdown import config import oauth import requests as rq sys.path.append("kwoc") app, sess = config.create_app() sess.init_app(app) # Load stats.json file dir_path = os.path.dirname(os.path.realpath(__file__)) root_dir = '/'.join(dir_path.split('/')[:-1]) stats_json = root_dir + '/gh_scraper/stats/stats.json' with open(stats_json, 'r') as f: stats_dict = json.load(f) # Separate people with non-zero contributions non_zero_contributions = {} zero_contributions = {} for user, userdata in stats_dict.items(): contribs = 0 contribs += userdata['no_of_commits']
import os from dotenv import load_dotenv from config import create_api, create_app, scheduler from utils.handle import handle_success dotenv_path = os.path.join(os.path.dirname(__file__), '.env') if os.path.exists(dotenv_path): load_dotenv(dotenv_path) app = create_app(os.getenv('FLASK_CONFIG') or 'default') api = create_api(app) @app.route('/') def root_path(): return handle_success() @scheduler.task('interval', id='do_job_1', seconds=5, misfire_grace_time=900) def job1(): print('Job 1 executed')
from config import create_app server = create_app() if __name__ == '__main__': server.run(debug=True, host='0.0.0.0')
import os from flask_bootstrap import Bootstrap from werkzeug.utils import secure_filename from flask import request, render_template, flash, redirect, url_for import prophet_util import config import validations as val app = config.create_app(__name__) @app.route('/', methods=['GET']) def index(): return render_template('index.html') @app.route('/', methods=['POST']) def upload(): if 'upload' not in request.files: flash('No file uploaded', 'danger') return redirect(url_for('index')) file = request.files['upload'] if file and config.allowed_file(file.filename): filepath = get_filepath(file) file.save(filepath) app.config['UPLOADED_FILE'] = filepath validations = val.validate_csv(filepath) if not validations: prophet_util.create_plots(filepath) return redirect(url_for('show'))
msg = db.blpop(settings.TASK_QUEUE_NAME) print('Running task: {0}'.format(msg)) func, task_id, args, kwargs = pickle.loads(msg[1]) qkey = settings.TASK_QUEUE_NAME key = '{0}:{1}'.format(qkey, task_id) data = {'date': time.time(), 'task_id': task_id, 'status': 'running', 'result': None} db.set(key, json.dumps(data)) try: rv = func(*args, **kwargs) data['status'] = 'complete' except Exception, e: import traceback traceback.print_exc() rv = e data['status'] = 'error' if not isinstance(rv, dict): rv = str(rv) data['result'] = rv if rv is not None: db.set(key, json.dumps(data)) db.expire(key, rv_ttl) if __name__=='__main__': print('Starting queue...') try: app = config.create_app() queue_daemon(app) except KeyboardInterrupt: print('Exiting...')
def setUp(self): self.app = create_app('testing') self.app_context = self.app.app_context() self.app_context.push() db.create_all()
def setUp(self): self.app = create_app('testing') self.server = fakeredis.FakeServer() self.fake_redis_db = fakeredis.FakeStrictRedis(server=self.server) self.client = app.test_client(self)
#!/usr/bin/env python # Copyright 2012 Arcus Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from flask.ext.cache import Cache import config cache = Cache(config.create_app())
from utils.article import get_text, analyze_text from utils.celery import make_celery from models.article_model import ArticleModel from config import create_app from db import connect_db celery = make_celery(create_app()) @celery.task def parse_text_to_db(url): article = ArticleModel(url) text = get_text(url) tokens, entities, parse_tree = analyze_text(text) # upsert article item fields = { "url": url, "text": text, "tokens": tokens, "entities": entities, "tree": parse_tree } return article.upsert(fields) @celery.task def sync_articles(): # compares ids from pocket-list with articles # and starts analysis tasks on missing items
from gevent import monkey monkey.patch_all() import sys from config.loader import neo_config from config import create_app, socketio, NeoAPI, sockets if __name__ == '__main__': if neo_config.load_config(): neo_config.set_project_variables() app = create_app(neo_config) socketio.run(app=app, port=neo_config.port, host=neo_config.host, debug=neo_config.debug) sys.exit(0) else: print("An error occured loading the configuration file", file=sys.stderr) sys.exit(1)