def get_app(): app = Flask("kardboard") app.config.from_object("kardboard.default_settings") if os.getenv("KARDBOARD_SETTINGS", None): app.config.from_envvar("KARDBOARD_SETTINGS") app.secret_key = app.config["SECRET_KEY"] app.db = PortAwareMongoEngine(app) app.jinja_env.add_extension("kardboard.util.Markdown2Extension") app.jinja_env.filters["slugify"] = slugify app.jinja_env.filters["timesince"] = timesince configure_logging(app) try: from flaskext.exceptional import Exceptional except ImportError: pass exceptional_key = app.config.get("EXCEPTIONAL_API_KEY", "") if exceptional_key: exceptional = Exceptional(app) app._exceptional = exceptional return app
def setUp(self): app = Flask(__name__) app.debug = True app.secret_key = '1234' self.app = app csrf = SeaSurf() csrf._csrf_disable = False self.csrf = csrf # Initialize CSRF protection. self.csrf.init_app(app) self.csrf.exempt_urls(('/foo',)) @app.route('/foo/baz', methods=['POST']) def foobaz(): return 'bar' @app.route('/foo/quz', methods=['POST']) def fooquz(): return 'bar' @app.route('/bar', methods=['POST']) def bar(): return 'foo'
def create_app(): app = Flask(__name__) app.secret_key = 'not a secret key' # FIXME duplicated in database.py if is_production(): app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://postgres:jackathon@localhost/watchtower' elif is_scan(): #app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://postgres:jackathon@75.101.157.206/watchtower' # TODO assumes static private ip app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://postgres:jackathon@10.73.181.115/watchtower' else: app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////var/watchtower/watchtower.db' db.init_app(app) # admin setup admin = Admin(app) admin.add_view(ModelView(Page, db.session)) class MyModelView(ModelView): def __init__(self, model, session, name=None, category=None, endpoint=None, url=None, **kwargs): for k, v in kwargs.iteritems(): setattr(self, k, v) super(MyModelView, self).__init__(model, session, name=name, category=category, endpoint=endpoint, url=url) def is_accessible(self): # Logic return True #admin.add_view(MyModelView(Version, db.session, column_list=['id', 'foreign_key'])) admin.add_view(ModelView(Version, db.session,)) admin.add_view(ModelView(Element, db.session,)) admin.add_view(ModelView(User, db.session,)) return app
def setup(): app = Flask(__name__) app.config['CSRF_ENABLED'] = False app.secret_key = '1' admin = Admin(app) return app, admin
def create_app(): app = Flask(__name__) # Set crucial variables app.secret_key = os.environ['SECRET_KEY'] app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URL'] # Set non crucial variables app.config['MAILGUN_API_URL'] = os.environ.get('MAILGUN_API_URL', '') app.config['MAILGUN_API_KEY'] = os.environ.get('MAILGUN_API_KEY', '') app.config['MAILGUN_TEST_OPTION'] = True if os.environ.get('MAILGUN_TEST_OPTION', 'True') == 'True' else False app.config['NOTIFICATION_EMAIL'] = os.environ.get('MAILGUN_SMTP_LOGIN', '') app.config['REDDIT_PASSWORD'] = os.environ.get('WPC_REDDIT_PASSWORD', '') app.config['REDDIT_USERNAME'] = os.environ.get('WPC_REDDIT_USERNAME', '') app.config['YOUTUBE_KEY'] = os.environ.get('WPC_YOUTUBE_KEY', '') app.config['GA_TRACKING_CODE'] = os.environ.get('GA_TRACKING_CODE', '') app.config['REDDIT_API_ID'] = os.environ.get('WPC_APP_ID', '') app.config['REDDIT_API_SECRET'] = os.environ.get('WPC_APP_SECRET', '') app.config['RTMP_LOGIN'] = os.environ.get('RTMP_LOGIN', '') app.config['RTMP_PASSWORD'] = os.environ.get('RTMP_PASSWORD', '') app.config['RTMP_SERVER'] = os.environ.get('RTMP_SERVER', '127.0.0.1') app.config['SERVER_NAME'] = os.environ.get('SERVER_NAME', '') app.config['REDDIT_WEB_APP_USER_AGENT'] = "/r/WatchPeopleCode web app(main contact: /u/godlikesme)" app.config['REDDIT_BOT_USER_AGENT'] = "/r/WatchPeopleCode flairs&streams bot (main contact: /u/godlikesme)" Bootstrap(app) loggers_and_levels = [(app.logger, logging.INFO), (logging.getLogger('sqlalchemy'), logging.WARNING), (logging.getLogger('apscheduler.scheduler'), logging.INFO)] setup_logging(loggers_and_levels, logentries_id=os.environ.get('LOGENTRIES_ID', None)) app.logger.info("App created!") return app
def create_application(): global app if not config.check(): return None if not os.path.exists(config.get('webapp', 'cache_dir')): os.makedirs(config.get('webapp', 'cache_dir')) app = Flask(__name__) app.secret_key = '?9huDM\\H' app.teardown_appcontext(teardown_db) if config.get('webapp', 'log_file'): import logging from logging.handlers import TimedRotatingFileHandler handler = TimedRotatingFileHandler(config.get('webapp', 'log_file'), when = 'midnight') if config.get('webapp', 'log_level'): mapping = { 'DEBUG': logging.DEBUG, 'INFO': logging.INFO, 'WARNING': logging.WARNING, 'ERROR': logging.ERROR, 'CRTICAL': logging.CRITICAL } handler.setLevel(mapping.get(config.get('webapp', 'log_level').upper(), logging.NOTSET)) app.logger.addHandler(handler) from supysonic import frontend from supysonic import api return app
def create_app(): app = Flask(__name__, static_url_path='/argonath/static') app.config.from_object('argonath.config') app.secret_key = 'wolegeca' logging.basicConfig(format='%(levelname)s:%(asctime)s:%(message)s', level=logging.INFO) for ext in (db, openid2): ext.init_app(app) for bp in blueprints: import_name = '%s.views.%s:bp' % (__package__, bp) app.register_blueprint(import_string(import_name)) for fl in (max, min, paginator_kwargs): app.add_template_global(fl) @app.before_request def init_global_vars(): user_dict = json.loads(request.cookies.get(app.config['OPENID2_PROFILE_COOKIE_NAME'], '{}')) g.user = user_dict and User.get_or_create(user_dict['username'], user_dict['email']) or None g.start = request.args.get('start', type=int, default=0) g.limit = request.args.get('limit', type=int, default=20) return app
def create_app(): app = Flask(__name__) auto=Autodoc(app) from open_event.views.views import app as routes app.register_blueprint(routes) migrate = Migrate(app, db) db.init_app(app) manager = Manager(app) manager.add_command('db', MigrateCommand) cors = CORS(app) app.secret_key = 'super secret key' app.config.from_object('config.ProductionConfig') app.config['UPLOADS_FOLDER'] = os.path.realpath('.') + '/static/' app.config['FILE_SYSTEM_STORAGE_FILE_VIEW'] = 'static' app.config['STATIC_URL'] = '/static/' app.config['STATIC_ROOT'] = 'staticfiles' app.config['STATICFILES_DIRS'] = (os.path.join(BASE_DIR, 'static'),) app.logger.addHandler(logging.StreamHandler(sys.stdout)) app.logger.setLevel(logging.ERROR) admin_view = AdminView("Open Event") admin_view.init(app) admin_view.init_login(app) return app, manager, db
def create_app(): app = Flask(__name__) load_config(app) app.debug = app.config['DEBUG'] app.secret_key = app.config['SECRET_KEY'] # init flask extensions db.init_app(app) mail.init_app(app) login_manager.init_app(app) app.context_processor(inject_roles) # init my modules upload.init_app(app) filters.init_app(app) views.init_app(app) # register routes app.register_blueprint(views.bp_basic) app.register_blueprint(views.bp_responsable) app.register_blueprint(views.bp_activite) app.register_blueprint(views.bp_brn) return app
def create_app(configfile=None): # We are using the "Application Factory"-pattern here, which is described # in detail inside the Flask docs: # http://flask.pocoo.org/docs/patterns/appfactories/ app = Flask(__name__) app.secret_key = "realsecretkey" # We use Flask-Appconfig here, but this is not a requirement AppConfig(app) # Install our Bootstrap extension Bootstrap(app) # Our application uses blueprints as well; these go well with the # application factory. We already imported the blueprint, now we just need # to register it: app.register_blueprint(frontend) # Because we're security-conscious developers, we also hard-code disabling # the CDN support (this might become a default in later versions): app.config['BOOTSTRAP_SERVE_LOCAL'] = True # We initialize the navigation as well nav.init_app(app) return app
def create_app(): options = { 'port' : 0, 'unitTesting': False } WebConfig.config(options) b = Borg() app = Flask(__name__) app.config['DEBUG'] = True app.config['SECRET_KEY'] = b.secretKey app.config['SECURITY_PASSWORD_HASH'] = b.passwordHash app.config['SECURITY_PASSWORD_SALT'] = b.passwordSalt app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://' + b.auth_dbUser + ':' + b.auth_dbPasswd + '@' + b.auth_dbHost + '/' + b.auth_dbName b.logger.setLevel(b.logLevel) b.logger.debug('Error handlers: {0}'.format(app.error_handler_spec)) app.secret_key = os.urandom(24) logger = logging.getLogger('werkzeug') logger.setLevel(b.logLevel) enable_debug = b.logLevel = logging.DEBUG cors = CORS(app) db.init_app(app) user_datastore = SQLAlchemyUserDatastore(db,User, Role) security = Security(app, user_datastore) from main import main as main_blueprint app.register_blueprint(main_blueprint) with app.app_context(): db.create_all() return app
def create_app(config_filename='config.default.DevelopmentConfig'): app = Flask(__name__) app.config.from_object(config_filename) app.secret_key = app.config['SECRET_KEY'] app.permanent_session_lifetime = timedelta(minutes=app.config['SESSION_ALIVE_MINUTES']) app.session_interface = ItsdangerousSessionInterface() # SOCKET # url = '127.0.0.1' # client_socket.connect((url, 8000)) # logging module log_filepath = os.path.join(app.config['ROOT_DIR'], 'app_server/log') log.init(log_filepath=log_filepath, log_level=app.config['LOG_LEVEL']) log.info("CREATE HIMS APP : "+__name__) db.init_app(app) bcrypt.init_app(app) login_manager.init_app(app) from youngs_server.api.auth_controllers import api_auth from youngs_server.api.member_controllers import api_member from youngs_server.api.lecture_controllers import api_lecture from youngs_server.api.question_controllers import api_question app.register_blueprint(api_auth) app.register_blueprint(api_member) app.register_blueprint(api_lecture) app.register_blueprint(api_question) return app
def create_app(config_name): if config_name != 'test': print "Application created based on config_name: %s" % (config_name) app = Flask(__name__) app._static_folder = 'static' app.debug = True app_config = config[config_name] app.config.from_object(app_config) config[config_name].init_app(app) app.secret_key = 'tell you' db.init_app(app) moment.init_app(app) login_manager.init_app(app) mail.init_app(app) pages.init_app(app) from .send_mail import sendmail as send_mail_blueprint app.register_blueprint(send_mail_blueprint) from .webviews import webviews as webviews app.register_blueprint(webviews) return app
def register_server(): app = Flask(__name__) settings_entry = os.environ.get('SKELETONS_SETTINGS_ENTRY', 'skeletons') server_settings = get_config(settings_entry) app.config['server_settings'] = server_settings app.config['SESSION_COOKIE_NAME'] = server_settings.cookie_name app.secret_key = server_settings.secret_key app.register_blueprint(greeting_blueprint, url_prefix='/greeting') @app.before_request def before_request(): pass @app.teardown_request def teardown_request(error=None): pass @app.after_request def after_request(response): return response @app.errorhandler(404) def page_not_found(e): return jsonify({'error': 'Invalid API path'}), 404 @app.errorhandler(HTTPError) def http_error(e): return jsonify({'error': e.msg}), e.status_code return app
def init_app(): db_path = 'db1.sqlite' # 初始化并配置 flask app = Flask(__name__) # 这一行 加了就没 warning app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True # 设置你的加密 key app.secret_key = 'TODO fixme' app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///{}'.format(db_path) # 初始化 db db.init_app(app) db.app = app # 必须在函数中 import 蓝图 # 否则循环引用(因为蓝图中 import 了 model, model 引用了这个文件里面目的 db) # from .auth import blue as auth from .controllers import main as controllers from .api import main as api1 # 注册蓝图 # app.register_blueprint(auth) app.register_blueprint(controllers) app.register_blueprint(api1, url_prefix='/api') # 把 app 引用返回 return app
def create_app(config=config): app = Flask(__name__) app.config.from_object(config) app.secret_key = 'tekitouna himitu no kagi' init_extensions(app) init_views(app) return app
def create_app(): app = Flask(__name__) auto = Autodoc(app) cal = Calendar() event = Event() from open_event.views.views import app as routes app.register_blueprint(routes) migrate = Migrate(app, db) db.init_app(app) manager = Manager(app) manager.add_command("db", MigrateCommand) cors = CORS(app) app.secret_key = "super secret key" app.config.from_object("config.ProductionConfig") app.config["UPLOADS_FOLDER"] = os.path.realpath(".") + "/static/" app.config["FILE_SYSTEM_STORAGE_FILE_VIEW"] = "static" app.config["STATIC_URL"] = "/static/" app.config["STATIC_ROOT"] = "staticfiles" app.config["STATICFILES_DIRS"] = (os.path.join(BASE_DIR, "static"),) app.logger.addHandler(logging.StreamHandler(sys.stdout)) app.logger.setLevel(logging.ERROR) admin_view = AdminView("Open Event") admin_view.init(app) admin_view.init_login(app) return app, manager, db
def get_app(): """load modules and return WSGI application""" import os from flask import Flask import sys from common import * global get_app, _app _app = Flask(__name__) get_app = lambda: _app # avoid duplicate import _app.config.from_object(app_config) _app.secret_key = "hokey dokey, here's the key" # login_manager = LoginManager() # login_manager.init_app(_app) # @login_manager.user_loader # def load_user(username): # from model.user import User # user = User.get_one(username=username) # user._authenticated = True # return user return _app
def make_json_app(import_name, **kwargs): """ Creates a JSON-oriented Flask app. All error responses that you don't specifically manage yourself will have application/json content type, and will contain JSON like this (just an example): { "message": "405: Method Not Allowed" } """ def make_json_error(ex): pprint.pprint(ex) pprint.pprint(ex.code) #response = jsonify(message=str(ex)) response = jsonify(ex) response.status_code = (ex.code if isinstance(ex, HTTPException) else 500) return response app = Flask(import_name, **kwargs) #app.debug = True app.secret_key = id_generator(24) for code in default_exceptions.iterkeys(): app.error_handler_spec[None][code] = make_json_error return app
def setup(): app = Flask(__name__) app.config["CSRF_ENABLED"] = False app.secret_key = "1" admin = Admin(app) return app, admin
def create_application(): global app if not config.check(): return None if not os.path.exists(config.get('base', 'cache_dir')): os.makedirs(config.get('base', 'cache_dir')) app = Flask(__name__) app.secret_key = '?9huDM\\H' app.teardown_appcontext(teardown_db) if config.get('base', 'log_file'): import logging from logging.handlers import TimedRotatingFileHandler handler = TimedRotatingFileHandler(config.get('base', 'log_file'), when = 'midnight') handler.setLevel(logging.WARNING) app.logger.addHandler(handler) from supysonic import frontend from supysonic import api return app
def create_app(db_uri): app = Flask(__name__) app.engine = create_engine(db_uri, convert_unicode=True) from monkeyapp.views import api app.register_blueprint(api) app.secret_key = "devays key" return app
def app_init(cfg='../config.py'): ''' Initialises the flask app. ''' app = Flask( __name__, static_folder=os.path.abspath('static')) app.register_blueprint(API, url_prefix='/api') app.config.from_pyfile(cfg) app.debug = app.config.get('DEBUG') app.secret_key = app.config.get('SECRET_KEY') oauth = OAuth() '''GOOGLE_CLIENT_ID = conf.GOOGLE_CLIENT_ID GOOGLE_CLIENT_SECRET = conf.GOOGLE_CLIENT_SECRET ''' google = oauth.remote_app('google', base_url='https://www.google.com/accounts/', authorize_url='https://accounts.google.com/o/oauth2/auth', request_token_url=None, request_token_params={ 'scope': 'https://www.googleapis.com/auth/userinfo.email', 'response_type': 'code'}, access_token_url='https://accounts.google.com/o/oauth2/token', access_token_method='POST', access_token_params={'grant_type': 'authorization_code'}, consumer_key=app.config.get('GOOGLE_CLIENT_ID'), consumer_secret=app.config.get('GOOGLE_CLIENT_SECRET')) return app, google
def create_app(configpath): app = Flask('Neuronal activity analyzer', template_folder='templates', static_folder='webgui/static') app.config.from_pyfile(configpath) app.secret_key = app.config['SECRET_KEY'] # Create folders if they don't exist folders = [app.config['VIDEO_FOLDER'], app.config['UPLOAD_FOLDER'], app.config['DATA_FOLDER']] for folder in folders: if not os.path.isdir(folder): os.mkdir(folder) app.register_blueprint(main_blueprint) app.register_blueprint(file_select_blueprint) app.register_blueprint(segmentation_blueprint) app.register_blueprint(roi_editor_blueprint) app.register_blueprint(statistics_blueprint) app.register_blueprint(batch_blueprint) app.after_request(disable_cache) app.config['JSONIFY_PRETTYPRINT_REGULAR'] = False compress.init_app(app) return app
def create_app(): app = Flask(__name__, static_url_path='/neptulon/static') app.config.from_object('neptulon.config') app.secret_key = app.config['SECRET_KEY'] logging.basicConfig(format='%(levelname)s:%(asctime)s:%(message)s', level=logging.INFO) db.init_app(app) mail.init_app(app) oauth.init_app(app) for bp in blueprints: import_name = '%s.views.%s:bp' % (__package__, bp) app.register_blueprint(import_string(import_name)) for fl in (max, min, paginator_kwargs): app.add_template_global(fl) @app.before_request def init_global_vars(): g.user = None if 'id' in session: g.user = User.get(session['id']) g.redir = request.args.get('redirect', '') g.start = request.args.get('start', type=int, default=0) g.limit = request.args.get('limit', type=int, default=20) return app
def create_app(debug=settings.DEBUG): app = Flask( __name__, template_folder=settings.TEMPLATE_FOLDER, static_folder=settings.STATIC_FOLDER, ) # 注册所有的蓝图 app.register_blueprint(bp_test) app.register_blueprint(bp_ball) # 配置jinja模板 app.jinja_env.globals.update(JINJA2_GLOBALS) app.jinja_env.filters.update(JINJA2_FILTERS) # 配置secret_key app.secret_key = 'secret_key' @app.before_request def before_request(): g.file = open('./nothing') @app.after_request def after_request(exception): g.file.close() return app
def test_content_type(sign_func): responses.add(responses.GET, "https://flask.atlassian.net/") app = Flask(__name__) app.secret_key = "anything" app.debug = True backend = MemoryBackend({ "oauth_token": "faketoken", "oauth_token_secret": "fakesecret", "oauth_session_handle": "fakehandle", "oauth_expires_in": "157680000", "oauth_authorization_expires_in": "160272000", }) jira_bp = make_jira_blueprint( "https://flask.atlassian.net", consumer_key="fakekey", backend=backend, ) app.register_blueprint(jira_bp) @app.route("/test") def api_request(): jira_bp.session.get("/") return "success" resp = app.test_client().get("/test") headers = responses.calls[0].request.headers assert "Content-Type" in headers assert headers["Content-Type"] == "application/json"
def create_app(init=False): app = Flask(__name__, static_url_path="/elegon/static", template_folder="templates") app.config.from_object("elegon.config") app.secret_key = "c534d51a57638e8a8a51c36d4a4128b89f8beb22" for ext in (db, openid2): ext.init_app(app) for bp in blueprints: import_name = "%s.ui.%s:bp" % (__package__, bp) app.register_blueprint(import_string(import_name)) for fl in (max, min, paginator_kwargs, enumerate): app.add_template_global(fl) with app.app_context(): db.create_all() @app.before_request def init_global_vars(): user_dict = json.loads(request.cookies.get(app.config["OPENID2_PROFILE_COOKIE_NAME"], "{}")) g.user = user_dict and User.get_or_create(user_dict["username"], user_dict["email"]) or None g.start = request.args.get("start", type=int, default=0) g.limit = request.args.get("limit", type=int, default=20) init_logging() if init: init_scheduler() start_scheduler() signal.signal(signal.SIGTERM, stop_scheduler) signal.signal(signal.SIGHUP, stop_scheduler) return app
def create_app(database): global app # create our little application :) app = Flask(__name__) app.config.from_object(config) app.secret_key = config.SECRET_KEY # db import from libs.db import init_connection # db setup if database: init_connection(database) # presenters from presenters.home import home # register modules app.register_blueprint(home) # template filters @app.template_filter('test_format') def test_format(input): return input[::-1] return app
def setUp(self): app = Flask(__name__) app.debug = True app.secret_key = '1234' app.config['SEASURF_INCLUDE_OR_EXEMPT_VIEWS'] = 'include' self.app = app csrf = SeaSurf() csrf._csrf_disable = False self.csrf = csrf # Initialize CSRF protection. self.csrf.init_app(app) @csrf.include @app.route('/foo', methods=['POST']) @app.route('/foo/<term>', methods=['POST']) def foo(term=None): return 'bar' @app.route('/bar', methods=['POST']) @app.route('/bar/<term>', methods=['POST']) def bar(term=None): return 'foo'