def create_app(self): """ Set up an app object with testing config """ app = Flask(__name__) app.config.from_object("config") db.init_app(app) app.db = db return app
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 create_app(): app = Flask(__name__) app.config.from_pyfile("config/config.cfg") # cors = CORS(app, resources={r"/*": { "origins": app.config["FRONTEND_DOMAIN"] }}) # Misc Config # os.environ["TZ"] = app.config["TIMEZONE"] # Database Config if app.config["ENVIRONMENT"] == "development": #without id password mongo = MongoClient(app.config["MONGO_HOSTNAME"], app.config["MONGO_PORT"]) app.db = mongo[app.config["MONGO_APP_DATABASE"]] else: mongo = MongoClient("localhost") mongo[app.config["MONGO_AUTH_DATABASE"]].authenticate( app.config["MONGO_AUTH_USERNAME"], app.config["MONGO_AUTH_PASSWORD"]) app.db = mongo[app.config["MONGO_APP_DATABASE"]] app.register_blueprint(user_blueprint, url_prefix="/user") @app.route("/") def index(): return JsonResp({"status": "Online"}, 200) return app
def create_app(config=None): """ Creates an Flask application instance. Optionally takes in a configuration object OR fully-qualified object path. Config may also be provided through a pyfile pointed by FLASK_CORE_CONFIG envvar. If DB_CONNECTION_STRING is provided, a SQLAlchemy object will be instantiated and available at app.db :param config: Configuration object or string :return: Flask application instance """ app = Flask(__name__) if config is None: config = app.config # Attempt to load config from pyfile as well, if it exists config.from_envvar("FLASK_CORE_CONFIG", silent=True) # Validate our config if "validate" in dir(config): config.validate() # Load our config options into flask app.config.from_object(config) # Bootstrap our logging under gunicorn if "gunicorn" in os.environ.get("SERVER_SOFTWARE", ""): gunicorn_logger = logging.getLogger("gunicorn.error") app.logger.handlers = gunicorn_logger.handlers app.logger.setLevel(gunicorn_logger.level) # Log out our config so its visible app.logger.info("Running configuration:") for k, v in app.config.items(): app.logger.info("\t%s -> %s", k, v) # setup our database connection app.db = None if "DB_CONNECTION_STRING" in app.config and app.config["DB_CONNECTION_STRING"] is not None: app.db = create_engine( app.config["DB_CONNECTION_STRING"], pool_pre_ping=app.config.get("DB_AUTO_RECONNECT", True) ) # Register core blueprints app.register_blueprint(core_bp) # Register all our middleware app.wsgi_app = Handler(app.wsgi_app) # Set up magic flag generator app.after_request(grep_flag) # Register our logging helper app.before_request(log_request) return app
def create_app(config_dict={}): global env, config # Set up scruffy environment env = Environment( dir=Directory('~/.flexo', create=False, config=ConfigFile('config', defaults=File('default.conf', parent=PackageDirectory()), apply_env=True) ) ) config = env.config # Setup flask app app = Flask(__name__, static_url_path='/static') app.secret_key = config.secret app.config["MONGODB_SETTINGS"] = {'host': config.db_uri} app.config.update(config_dict) app.register_blueprint(main) # Setup database app.db = MongoEngine(app) # Setup login_manager login_manager.init_app(app) login_manager.login_view = 'login' # Setup API api = Api(app) api.add_resource(MetricAPI, '/api/metric') api.add_resource(ExerciseAPI, '/api/exercise') # Make sure there's at least an admin user if len(User.objects) == 0: User(name='admin', password='******').save() return app
def create_app(): application = Flask(__name__) application.config['SQLALCHEMY_DATABASE_URI'] = DATABASE_URI # application.config['BABEL_DEFAULT_LOCALE'] = 'ru-ru' application.config['SECRET_KEY'] = SECRET_KEY application.permanent_session_lifetime = timedelta(minutes=30) Triangle(application) assets.init_app(application) api.init_app(application) api.application = application db.init_app(application) admin.init_app(application) login_manager.init_app(application) application.db = db application.api = api babel = Babel(application) @babel.localeselector def get_locale(): return request.accept_languages.best_match(["ru"]) init_logging(application) return application
def create_app(config, app=None): class Result(object): def __init__(self, **kwargs): for k, v in kwargs.items(): setattr(self, k, v) if app is None: app = Flask(__name__) app.config.from_object(config) app.collect = Collect(app) app.celery = make_celery(app) app.db = MongoEngine(app) app.user_datastore = MongoEngineUserDatastore( app.db, User, Role, ) app.security = Security(app, app.user_datastore) create_api(app) app.socketio = SocketIO(app, logger=True) werkzeug = os.environ.get('WERKZEUG_RUN_MAIN', 'true') if werkzeug == 'true': app.socket_thread = SocketThread( app.socketio, app.config['REDIS_HOST'] ) app.socket_thread.start() return app
def create_app(config=None): log.debug('creating app with config: %s', config) import models from evesso.auth import auth, login_manager from evesso.chat import socketio import evesso.default_config app = Flask(__name__, instance_relative_config=True, static_folder='../static/build/app/', static_url_path='/static') app.config.from_object(evesso.default_config) #if config != '': app.config.from_pyfile(config) setup_logging(app) db.init_app(app) app.db = db db.scoped_session = scoped_session socketio.init_app(app) app.socketio = socketio oauth.init_app(app) app.eve_oauth = eve_oauth login_manager.init_app(app) app.login_manager = login_manager app.register_blueprint(auth) return app
def create_app(config_filename): app = Flask(__name__) app.config.from_object(config_filename) CsrfProtect(app) # Register extensions for ext in all_extensions: print(ext) ext.init_app(app) # Add DB resource to app object for use later. app.db = db # Creates DB if it doesn't exist. Comment out to avoid checking every time. if not os.path.exists(app.config['DBFILE_PATH']): print("Need to create {} at {}".format(app.config['DB_NAME'], app.config['APP_DIR'])) @app.before_first_request def initialize_database(): print("Creating {} at {}".format(app.config['DB_NAME'], app.config['APP_DIR'])) db.create_all() # Register blueprints app.register_blueprint(pages.blueprint) pages.blueprint.extra_init(app) app.register_blueprint(user.views.blueprint) app.logger.setLevel(logging.WARNING) register_errorhandlers(app) return app
def create_app(config_obj): app = Flask(__name__) app.config.from_object(config_obj) app.db = SQLAlchemy(app) app.db.register_base(models.Base) login_manager = LoginManager(app) # Register a user loader @login_manager.user_loader def load_user(user_id): return app.db.session.query(User).get(user_id) # Flask Migrate Migrate(app, app.db) # Endpoints add_healthcheck(app) # App Version app.version = get_release() # Trello API app.trello = TrelloClient(api_key=app.config.get('TRELLO_APP_KEY')) # Register Views IndexView.register(app, route_base='/') return app
def create_app(): # We could pass a config object here app = Flask(__name__) app.debug = os.environ.get('TIMERBOARD_PRODUCTION', True) app.config.from_envvar("TIMERBOARD_SETTINGS") with open(os.environ["TIMERBOARD_SETTINGS"]) as fh: app.myconfig = json.loads(fh.read()) app.config["SQLALCHEMY_DATABASE_URI"] = app.myconfig["SQLALCHEMY_DATABASE_URI"] # Register template filters here # app.add_template_filter(some_method) #app.config.from_object(config) #app.config.from_pyfile(config_filename) app.secret_key = os.urandom(24) assets.init_app(app) login_manager.init_app(app) app.db = SQLAlchemy(app) with app.app_context(): app.db.create_all() from users.views import mod as users_blueprint from assets import mod as assets_blueprint from login import mod as login_blueprint app.register_blueprint(users_blueprint) app.register_blueprint(assets_blueprint) app.register_blueprint(login_blueprint) @app.teardown_appcontext def shutdown_session(exception=None): app.db.session.remove() return app
def create_app(config, app=None): class Result(object): def __init__(self, **kwargs): for k, v in kwargs.items(): setattr(self, k, v) if app is None: app = Flask(__name__) app.config.from_object(config) app.collect = Collect(app) db.init_app(app) app.db = db app.blueprint = Blueprint( 'app', __name__, template_folder='templates', static_folder='static', static_url_path='/static/app', ) app.register_blueprint(app.blueprint) from .models.auth import User, Role, UserRoles app.user_datastore = PeeweeUserDatastore( app.db, User, Role, UserRoles, ) app.security = Security(app, app.user_datastore) app.jwt = JWTManager(app) create_api(app) return app
def init_app(app: Flask): db.init_app(app) app.db = db from src.models.user_model import UserModel from src.models.ticket_model import TicketModel
def create_app(config, app=None): if app is None: app = Flask(__name__) app.config.from_object(config) @app.route('/media/<path:path>') def send_media(path): fullPath = f"../{app.config['MEDIA_PATH']}/{path}" try: return send_file(fullPath) except FileNotFoundError: return 'No such file', 404 app.sendmail = lambda to, message: sm(app.config, to, message) app.collect = Collect(app) db.init_app(app) app.db = db from .models.user import User from .models.role import Role, UserRoles app.user_datastore = PeeweeUserDatastore( app.db, User, Role, UserRoles, ) app.security = Security(app, app.user_datastore) app.jwt = JWTManager(app) create_api(app) app.cors = CORS(app, supports_credentials=True) cli.register(app) return app
def create_app(settings): app = Flask(__name__, template_folder='../templates', static_folder='../static') app.secret_key = settings['secret'] app.db = MongoClient(settings['mongo_connection_string'], maxPoolSize=200).get_database( settings['default_database']) app.redis_queue = Redis(host=settings['redis_host'], db=10, password=settings['redis_password']) app.config.update(CELERY_BROKER_URL=settings['mongo_connection_string']) from src.views.auth import init_view init_view(app, settings) from src.views.index import init_view init_view(app, settings) from src.views.configs import init_view init_view(app, settings) from src.views.jobs import init_view init_view(app, settings) from src.views.healtcheck import init_view init_view(app, settings) return app
def create_app(config_file=None): app = Flask(__name__, static_folder='./asset/static') app.json_encoder = KqueenJSONEncoder app.register_blueprint(api, url_prefix='/api/v1') app.register_blueprint(metrics, url_prefix='/metrics') app.register_blueprint(swaggerui_blueprint, url_prefix=swagger_url) # load configuration config = current_config(config_file) config.setup_policies() secret_key = config.get('SECRET_KEY') if not secret_key or len(secret_key) < 16: raise ImproperlyConfigured( 'The SECRET_KEY must be set and longer than 16 chars.') app.config.from_mapping(config.to_dict()) # setup database app.db = EtcdBackend() # setup JWT JWT(app, authenticate, identity) # setup metrics setup_metrics(app) return app
def create_app(config='CTFd.config'): app = Flask("CTFd") with app.app_context(): app.config.from_object(config) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking db.init_app(app) db.create_all() app.db = db global mail mail = Mail(app) #Session(app) from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) return app
def create_app(config, app=None): class Result(object): def __init__(self, **kwargs): for k, v in kwargs.items(): setattr(self, k, v) if app is None: app = Flask(__name__) app.config.from_object(config) app.collect = Collect(app) db.init_app(app) app.db = db from .models.auth import User, Role, UserRoles app.user_datastore = PeeweeUserDatastore( app.db, User, Role, UserRoles, ) app.security = Security(app, app.user_datastore) app.jwt = JWTManager(app) create_api(app) return app
def create_app(): app = Flask(__name__) app.config.from_mapping(APP_CONFIG) app.db = get_db(app) app.register_blueprint(med_api) @app.route("/") def index(): return "This is a traditional API to tasty tacos." @app.route("/heartbeat") def heartbeat(): return jsonify({"status": "Tacos online."}), 200 @app.errorhandler(401) def unauthorized(e): return jsonify(error=f"{e}"), 401 @app.errorhandler(404) def not_found(e): return jsonify(error=f"{e}"), 404 @app.errorhandler(500) def server_error(e): return jsonify(error=f"{e}"), 500 return app
def generate_application(config=None): """Generate an application from a given configuration file.""" application = Flask(__name__) application.config.from_object(config or 'swimteam_server.config.dev') CORS(application, send_wildcard=True) application.url_map.converters['regex'] = RegexConverter # application.register_blueprint(blueprint_file.generate_blueprint_callback(application.config)) # create db instance DB.app = application DB.init_app(application) application.db = DB DB.create_all() # flask_restless STANDARD_METHODS = ['GET', 'POST', 'PUT', 'DELETE'] results_per_page = -1 # turn off pagination manager = flask_restless.APIManager(application, flask_sqlalchemy_db=DB) # https://stackoverflow.com/questions/1796180/how-can-i-get-a-list-of-all-classes-within-current-module-in-python # TODO: fix this # clsmembers = inspect.getmembers(sys.modules['vehicles.models.models'], inspect.isclass) # for cls_tuple in clsmembers: # klass = cls_tuple[1] # # check if is sqlalchemy class # if hasattr(klass, '__tablename__'): # manager.create_api(klass, methods=STANDARD_METHODS, results_per_page=results_per_page) # hardcode for now # manager.create_api(models.Location, methods=STANDARD_METHODS, results_per_page=results_per_page) MIGRATE.init_app(application, DB) return application
def create_app(): app = Flask(__name__) client = MongoClient('mongodb+srv://aravind:'+urllib.parse.quote('@Ravind1')+'@cluster0.zgjkp.mongodb.net/microblog?retryWrites=true&w=majority') app.db = client.microblog @app.route('/',methods=['GET','POST']) def Hello(): # print([e for e in app.db.entries.find({})]) entries1=[] if request.method == 'POST': entry_content = request.form.get('content') date = datetime.datetime.today().strftime('%d-%m-%y') formatted_date=datetime.datetime.strptime(date,'%d-%m-%y').strftime('%b %d') # entries.append((entry_content, formatted_date)) app.db.entries.insert({'content':entry_content, 'date':formatted_date}) entries1 = [ ( entry['content'], entry['date'] ) for entry in app.db.entries.find({}) ] return render_template('home.html', entries=entries1) return app
def _app(): """prepare application and pass configuration for testing environment""" app = Flask(__name__, instance_path=os.path.join(os.path.abspath(basedir), 'phonebook', '')) app.test_request_context().push() # load the test config if passed in app.config.from_object(phonebook.config.TestingConfig) # ensure the app instance folder exists try: os.makedirs(app.instance_path) except OSError as e: pass # register db initiator with app.app_context(): from phonebook import db db.destroy_all() db.init_db() db.init_app(app) app.db = db.get_db() import phonebook.phone_book_api as phone_book_api # register server control blueprint app.register_blueprint(phone_book_api.bp, url_prefix='/') return app
def create_app(test_config=None): # create and configure the app app = Flask(__name__, instance_relative_config=True) app.config.from_pyfile('config.py') # a simple page that says hello @app.route('/hello') def hello(): return 'Hello, World! ' + app.config['TWILIO_AUTH_TOKEN'] project_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) print('Project dir: ', project_dir) # Attach shared objects to app context from app import utils, bot, db, conversation app.wit_interface = utils.WitInterface(app.config['WIT_AUTH_TOKEN']) app.responses_data = utils.Data(os.path.join(project_dir, 'data', 'bot_answers.json')) app.db = db.DataBase(app.config['MONGO_CONNECTION_STRING'], app.config['MONGO_USERNAME'], app.config['MONGO_PASSWORD']) app.db.set_context_collection(app.config['MONGO_BOT_DB'], app.config['MONGO_CONTEXT_COLLECTION']) app.chat_bot = conversation.Conversation(os.path.join(project_dir, app.config['BRAIN_FILE']), os.path.join(project_dir, app.config['LEARN_FILES'])) app.movie_info = utils.Movies_Data(os.path.join(project_dir, app.config['MOVIE_DB'])) # Routes # app.add_url_rule('/bot', 'bot_intro', bot.say_hi, methods=['GET']) app.add_url_rule('/bot', 'bot_response', bot.converse, methods=['POST']) return app
def create_app(config='CTFd.config'): app = Flask(__name__) with app.app_context(): app.config.from_object(config) app.jinja_loader = ThemeLoader(os.path.join(app.root_path, app.template_folder), followlinks=True) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking url = make_url(app.config['SQLALCHEMY_DATABASE_URI']) if url.drivername == 'postgres': url.drivername = 'postgresql' db.init_app(app) try: if not (url.drivername.startswith('sqlite') or database_exists(url)): create_database(url) db.create_all() except OperationalError: db.create_all() except ProgrammingError: ## Database already exists pass else: db.create_all() app.db = db cache.init_app(app) app.cache = cache if not get_config('ctf_theme'): set_config('ctf_theme', 'original') #Session(app) from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) from CTFd.plugins import init_plugins init_plugins(app) return app
def init_app(db_name=None): """Initialize the app. Because the database name has to be set before the app inits, we allow it to be passed in outside of configs, because we can't set it on app.config['DATABASE'] before we actually have an app. This is mainly for testing, because it could be set via env vars, but we don't want the test to override any env vars that are already set. """ # create a Flask app, force SSL when debug is False app = Flask(__name__, static_folder='./ui/static') app.config.from_pyfile('config.py') # load custom config file custom_config = app.config['CUSTOM_CONFIG_PATH'] if os.environ.get(custom_config) is not None: app.config.from_envvar(custom_config) # setup app.db = db.connect(db_name) setup_auth(app) SSLify(app, subdomains=True) # register blueprints app.register_blueprint(api, url_prefix='/api') app.register_blueprint(auth) app.register_blueprint(ui) return app
def setup(): """Setup function for tests.""" # global variable shouldn't be used but is quite useful here # pylint: disable=W0603 global TEMP_DIR TEMP_DIR = mkdtemp() if not os.path.exists(FAKE_DIR): os.mkdir(FAKE_DIR) Git(os.path.join(FAKE_DIR, 'documents.git')).init() app = Flask( __name__, static_folder=os.path.join(PATH, 'static'), template_folder=os.path.join(PATH, 'templates')) app.config.from_object(config) app.db = SQLAlchemy(app) nuts = application.Koztumize(app) application.app = app application.nuts = nuts app.config['MODELS'] = os.path.join(TEMP_DIR, 'models') git = Git(app.config['MODELS']) git.init() git.remote('add', '-t', 'models', 'origin', app.config['GIT_REMOTE']) git.pull() git.checkout('models') execute_sql(app, 'db.sql') import koztumize.routes import koztumize.tests.document
def create_app(): app = Flask("CTFd", static_folder="../static", template_folder="../templates") with app.app_context(): app.config.from_object('CTFd.config') app.permanent_session_lifetime = timedelta(minutes=30) from CTFd.models import db, Users, EquipmentsStatus from CTFd import models db.init_app(app) db.create_all() app.db = db # app.setup = True global mail mail = Mail(app) Session(app) from CTFd.views import init_views init_views(app) from CTFd.errors import init_errors init_errors(app) from CTFd import auth auth.init_auth(app) from CTFd import panSky panSky.init_views(app) #from CTFd.auth import init_auth #init_auth(app) from CTFd.utils import init_utils init_utils(app) return app
def get_app(): app = Flask('flask_seed') app.config.from_object('default_settings') if os.getenv('FLASK_SEED_SETTINGS', None): app.config.from_envvar('FLASK_SEED_SETTINGS') app.secret_key = app.config['SECRET_KEY'] # app.g = globals.load() app.db = MongoEngine(app) app.jinja_env.add_extension('util.Markdown2Extension') app.jinja_env.filters['slugify'] = slugify app.jinja_env.filters['timesince'] = timesince app.jinja_env.filters['timeuntil'] = timeuntil app.jinja_env.filters['jsonencode'] = jsonencode app.jinja_env.globals['newrelic_head'] = newrelic_head app.jinja_env.globals['newrelic_foot'] = newrelic_foot if not app.config.get('TEMPLATE_DEBUG', True): compiled_templates = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'compiled_templates') compiled_files = path.path(compiled_templates).files() if len(compiled_files) <= 1: app.jinja_env.compile_templates(compiled_templates, zip=None, py_compile=True) app.jinja_env.loader = ModuleLoader(compiled_templates) return app
def create_app(): app = Flask(__name__) app.secret_key = urandom(24) from models import db, User, Event, Challenge, WorkingOn, File, Config from config import Conf app.config.from_object(Conf) db.init_app(app) #initialize db db.app = app app.db = db #set the app's db to db db.create_all() #create tables from utils import init_utils, init_errors from core import core from admin import admin from auth import auth init_utils(app) #init_errors(app) app.register_blueprint(core) app.register_blueprint(admin) app.register_blueprint(auth) return app
def create_app(config='CTFd.config'): app = Flask("CTFd") with app.app_context(): app.config.from_object(config) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking db.init_app(app) db.create_all() app.db = db global mail mail = Mail(app) Session(app) from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) return app
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 app.jinja_env.filters['jsonencode'] = jsonencode app.jinja_env.globals['newrelic_head'] = newrelic_head app.jinja_env.globals['newrelic_foot'] = newrelic_foot 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 app.wsgi_app = FixGunicorn(app.wsgi_app) return app
def create_app(self): app = Flask(__name__) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False if os.environ['FLASK_ENV'] == 'production' or os.environ[ 'FLASK_ENV'] == 'prod_testing': app.secret_key = bytes(os.environ['SECRET_KEY'], encoding='utf-8') # app.permanent_session_lifetime = timedelta(hours=24) app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('PROD_DB') DATABASE_URL = app.config['SQLALCHEMY_DATABASE_URI'] conn = psycopg2.connect(DATABASE_URL, sslmode='require') if os.environ['LOGS'] != 'off': print('app.py: Prod DB') print('connection', conn) elif os.environ['FLASK_ENV'] == 'development': app.secret_key = bytes(os.environ['SECRET_KEY'], encoding='utf-8') # app.permanent_session_lifetime = timedelta(hours=24) if os.environ['LOGS'] != 'off': print('app.py: dev DB') app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DEV_DB'] elif os.environ['FLASK_ENV'] == 'dev_testing': app.testing = True app.secret_key = b'12345678910-not-my-real-key' if os.environ['LOGS'] != 'off': print('app.py: testing DB') app.config['SQLALCHEMY_DATABASE_URI'] = "sqlite:///:memory:" engine = create_engine('sqlite:///:memory:') db = SQLAlchemy(app) app.db = db return {'app': app, 'db': db}
def create_app(): from flask import Flask app = Flask(__name__) from web.common.setting import Config app.config.from_object(Config) from flask_sqlalchemy import SQLAlchemy orm = SQLAlchemy(app) from web.common.utils import DBUtil db = DBUtil(orm) app.db = db """ 批量注册蓝图 find_modules:查找指定包下面的所有模块 参数说明: import_path:包路径 include_packages:若为True则返回包内的子包,默认False recursive:是否递归搜索子包,默认False """ from werkzeug.utils import find_modules, import_string for module_name in find_modules("web", recursive=True): """ import_string:动态导入需要的模块或对象 参数说明: import_name:要导入的模块或对象名称 silent:若为True则忽略导入错误,返回None,默认False """ module = import_string(module_name) if hasattr(module, "bp"): app.register_blueprint(module.bp) return app
def create_app(): app = Flask(__name__, instance_relative_config=True, static_folder='../react_application/build/static', template_folder="../react_application/build") CORS(app, supports_credentials=True) # Import configuration settings app.config.from_object(config.TestingConfig) app.config.from_pyfile('config.py') with app.app_context(): # Set up database connection pool app.db = database.connect_to_analysis_db() # Import blueprints containing routes and views from flask_server.views.users import users_bp from flask_server.views.apks import apks_bp from flask_server.views.workers import workers_bp from flask_server.views.rendering import rendering_bp from flask_server.views.signatures import signatures_bp app.register_blueprint(users_bp) app.register_blueprint(apks_bp) app.register_blueprint(workers_bp) app.register_blueprint(rendering_bp) app.register_blueprint(signatures_bp) return app
def create_app(): app = Flask(__name__) client = MongoClient(os.environ.get("MONGODB_URI")) app.db = client.sample @app.route("/", methods=["GET", "POST"]) def home(): if request.method == "POST": entry_content = request.form.get("content") formatted_date = datetime.datetime.today().strftime("%Y-%m-%d") app.db.entries.insert({ "content": entry_content, "date": formatted_date }) entries_with_date = [ (entry["content"], entry["date"], datetime.datetime.strptime(entry["date"], "%Y-%m-%d").strftime("%b %d")) for entry in app.db.entries.find({}) ] #entries_with_date.reverse() return render_template("index.html", entries=entries_with_date) return app
def create_app(): app = Flask(__name__) api = Api(app) # Mongo DB Settings app.config['MONGODB_DATABASE'] = 'yoda' # add api endpoint basic code evaluation api.add_resource(ycode.TestCode, '/') # add api endpoint testcase list view and detail view of testcase based on Object ID api.add_resource(ycode.GetTestCase, '/testcases', '/testcases/<string:testcase_id>') # add api endpoint to create a testcase api.add_resource(ycode.NewTestCase, '/testcase/new' ) # TODO: Check if MongoDB is up and running app.db = MongoKit (app) # Register MongoDB documents app.db.register([RootDocumentModel]) app.db.register([CodeDocumentModel]) app.db.register([CodeSetDocumentModel]) app.db.register([TestCaseDocumentModel]) @app.errorhandler(500) def internal_error(exception): return "Some internal error has taken place. Alert somebody!" return app
def create_app(): """ Create and bootstrap a flask application """ app = Flask(__name__) config_file = get_config_file() app.config.from_json(config_file) DB.init_app(app) app.db = DB # Initialize extension CSRF Protection (Flask-WTF) # csrf.init_app(app) # Initialize extension Flask-Login login_manager.init_app(app) # Initialize extension Flask-OAuthlib oauth.init_app(app) # initialize jwt auth extension jwt_auth.init_app(app) bootstap(app) # register blueprints register_blueprints(app) return app
def create_app(): """ Initializing the app """ app = Flask(__name__) app.config.update(Config.__dict__) # Set up extensions db.init_app(app) app.db = db Migrate(app, db) CORS(app) # TODO: Don't allow all in production assets.init_app(app) login_manager.init_app(app) # Install views from views.oauth import bp as oauth_bp app.register_blueprint(oauth_bp) # Install API from views import account from views import authorization api.init_app(app) # Install models from models.account import User return app
def create_app(config_name): app = Flask(__name__) CORS(app) app.config.from_object(config[config_name]) config[config_name].init_app(app) admin.init_app(app) db.init_app(app) app.db = db thread = Thread(target=start_service, args=(app, )) thread.start() thread = Thread(target=get_messages, args=(app, )) thread.start() admin.add_view(ModelView(ContactModel, db.session)) admin.add_view(ModelView(GroupModel, db.session)) admin.add_view(ModelView(MessageModel, db.session)) admin.add_view(ModelView(UserModel, db.session)) from .controllers.main import main_blueprint app.register_blueprint(main_blueprint) return app
def create_app(config_name): """ The factory function,create application object :param config_name: 'development' or 'production' :return: application object """ app = Flask(__name__) # logs setup_log(config_name) app.config.from_object(config_dict[config_name]) # timed task scheduler = APScheduler() scheduler.init_app(app) scheduler.start() JWTManager(app) db = create_conn(config_name) app.db = db from .modules.auth import auth_blue app.register_blueprint(auth_blue) from .modules.systemConfig import system_config_blue app.register_blueprint(system_config_blue) return app
def init_app(app: Flask): db.init_app(app) app.db = db from ..models.user_model import UserModel from ..models.post_model import PostModel from ..models.profile_model import ProfileModel
def get_app(): app = Flask('flask_seed') app.config.from_object('default_settings') if os.getenv('FLASK_SEED_SETTINGS', None): app.config.from_envvar('FLASK_SEED_SETTINGS') app.secret_key = app.config['SECRET_KEY'] # app.g = globals.load() app.db = MongoEngine(app) app.jinja_env.add_extension('util.Markdown2Extension') app.jinja_env.filters['slugify'] = slugify app.jinja_env.filters['timesince'] = timesince app.jinja_env.filters['timeuntil'] = timeuntil app.jinja_env.filters['jsonencode'] = jsonencode app.jinja_env.globals['newrelic_head'] = newrelic_head app.jinja_env.globals['newrelic_foot'] = newrelic_foot if not app.config.get('TEMPLATE_DEBUG', True): compiled_templates = os.path.join( os.path.abspath(os.path.dirname(__file__)), 'compiled_templates') compiled_files = path.path(compiled_templates).files() if len(compiled_files) <= 1: app.jinja_env.compile_templates(compiled_templates, zip=None, py_compile=True) app.jinja_env.loader = ModuleLoader(compiled_templates) return app
def app_factory(config: t.Optional[t.Dict[str, t.Any]] = None) -> Flask: """ Bootstraps a Flask application and adds dependencies to the resulting object. After bootstrap, it's a good idea to never import from `run` or the source of the bootstraped Flask application. Instead, all boostrapped extensions should be accessed with Flask's `current_app`. Example: from flask import current_app as app ... def my_method(): with app.app_context(): result = app.db.session.query(MyModel).first() Args: config (Optional[Dict[str, Any]]): A configuration object to update the app's config with Returns: Flask: The bootstrapped flask application object """ app = Flask(__name__) app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get( "SQLALCHEMY_DATABASE_URI") app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = bool( os.environ.get("SQLALCHEMY_TRACK_MODIFICATIONS", 0)) app.config["DEBUG"] = True app.config.update(**(config or {})) app.db = database_factory(app) app.ma = serializer_dactroy(app) app.twilio = twilio_factory(app) cors_header(app) return app
def create_app(config_name): config_name = config_name or os.getenv('FLASK_CONFIG') app_config = config[config_name] app = Flask(__name__) app.config.from_object(app_config) db.init_app(app) ma.init_app(app) app.db = db app.app_context().push() app_config.init_app(app) from app.api.v1 import channel_controller, store_controller, vote_controller app.register_blueprint(channel_controller, url_prefix='/api/v1') app.register_blueprint(vote_controller, url_prefix='/api/v1') app.register_blueprint(store_controller, url_prefix='/api/v1') CORS(app) CSRFProtect(app) Migrate(app, db) return app
def create_app(cmdline=False, test_config=None): blueprints = get_blueprints() app = Flask(__name__) if test_config: app.config.update(**test_config) else: app.config.from_envvar('RELENGAPI_SETTINGS') # add the necessary components to the app app.db = db.make_db(app) app.celery = celery.make_celery(app) relengapi.principal.init_app(app) relengapi.login_manager.init_app(app) api.init_app(app) for name, bp in blueprints: if cmdline: logger.info(" * registering blueprint %s", name) app.register_blueprint(bp, url_prefix='/%s' % name) # set up a random session key if none is specified if not app.config.get('SECRET_KEY'): logger.warning(" * setting per-process session key - sessions will be reset on " "process restart") app.secret_key = os.urandom(24) @app.before_request def add_db(): g.db = app.db @app.route('/') def root(): # render all of the blueprints' templates first bp_widgets = [] for bp in app.blueprints.itervalues(): bp_widgets.extend(bp.root_widget_templates or []) bp_widgets.sort() bp_widgets = [tpl for (_, tpl, condition) in bp_widgets if not condition or condition()] return render_template('root.html', bp_widgets=bp_widgets) @app.route('/versions') @api.apimethod() def versions(): dists = {} for dist in pkg_resources.WorkingSet(): dists[dist.key] = { 'project_name': dist.project_name, 'version': dist.version, } blueprints = {} for ep in pkg_resources.iter_entry_points('relengapi_blueprints'): blueprints[ep.name] = { 'distribution': ep.dist.key, 'version': ep.dist.version, } return dict(distributions=dists, blueprints=blueprints) return app
def create_app(): app = Flask(__name__) app.register_blueprint(hashes, url_prefix="/hash") app = error_routes(app) app.db = Hash() return app
def create_app(__name__=__name__): app = Flask(__name__) try: app.config.from_pyfile(CONFIG_FILEPATH) except IOError: pass auto_register_modules(app) app.db = SQLAlchemy(app) return app
def create_app(package_name): app = Flask(package_name) from project.database import db_init app.db = db_init() from project.routes import routes_init routes_init(app) return app
def create_app(set_config=set_config): app = Flask(__name__) set_config(app) db.init_app(app) app.db = db register_uris(app) return app
def create_app(set_config=set_config): app = Flask(__name__) set_config(app) db.init_app(app) app.db = db register_uris(app) app.response_class = ApiResponse return app
def app(request): app = Flask(__name__) app.client = app.test_client() app.db = connect(**{'db': db_name()}) from project.routes import routes_init routes_init(app) def teardown(): app.db.drop_database(db_name()) request.addfinalizer(teardown) return app
def create_app(config='CTFd.config'): app = Flask("CTFd") with app.app_context(): app.config.from_object(config) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking, mysql app.config['MYSQL_DATABASE_USER'] = '******' app.config['MYSQL_DATABASE_PASSWORD'] = '******' app.config['MYSQL_DATABASE_DB'] = 'EmpData' app.config['MYSQL_DATABASE_HOST'] = 'localhost' mysql.init_app(app) cursor = mysql.connection.cursor() # cursor.execute('CREATE DATABASE IF NOT EXISTS info_sec;') # cursor.execute('USE info_sec;') # cursor.execute('CREATE TABLE IF NOT EXISTS info_sec.security_table \ # (\ # username varchar(255),\ # pass char(255));') db.init_app(app) db.create_all() app.db = db #Session(app) from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) return app
def get_app(): app = Flask('breezeminder') settings_file = os.environ.get('BREEZEMINDER_SETTINGS', 'breezeminder.settings.local') app.config.from_object(settings_file) app.config['BREEZEMINDER_ENV'] = settings_file.split('.')[-1].upper() app.config['SHOW_ADS'] = app.config.get('ADSENSE_CLIENT', None) is not None app.secret_key = app.config['SECRET_KEY'] app.db = PortAwareMongoEngine(app) logger.configure_logging(app) return app
def create_app(self, config): if self.app: return self.app app = Flask(__name__) app.config.from_object(config) db.init_app(app) db.create_all(app=app) app.db = db self.register_blueprint(app) self.app = app return app
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 = MongoEngine(app) app.jinja_env.add_extension('kardboard.util.Markdown2Extension') app.jinja_env.filters['slugify'] = slugify app.jinja_env.filters['timesince'] = timesince app.jinja_env.filters['timeuntil'] = timeuntil app.jinja_env.filters['jsonencode'] = jsonencode app.jinja_env.globals['newrelic_head'] = newrelic_head app.jinja_env.globals['newrelic_foot'] = newrelic_foot if app.config.get('COMPILE_TEMPLATES', False): compiled_templates = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'compiled_templates') compiled_files = path.path(compiled_templates).files() if len(compiled_files) <= 1: app.jinja_env.compile_templates(compiled_templates, zip=None, py_compile=True) app.jinja_env.loader = ModuleLoader(compiled_templates) configure_logging(app) app.wsgi_app = FixGunicorn(app.wsgi_app) statsd_conf = app.config.get('STATSD_CONF', {}) statsd_connection = statsd.Connection( host=statsd_conf.get('host', '127.0.0.1'), port=statsd_conf.get('port', 8125), sample_rate=statsd_conf.get('sample_rate', 1), ) machine_name = socket.getfqdn().split('.')[0] environment_name = app.config.get('ENV_MAPPING', {}).get(machine_name, 'default') prefix_name = '%s.%s.kardboard' % (environment_name, machine_name) app.statsd = statsd.Client(prefix_name, statsd_connection) if SENTRY_SUPPORT and 'SENTRY_DSN' in app.config.keys(): sentry = Sentry(app) sentry return app
def create_app(app_name, config): app = Flask(app_name) app.config.from_object(config) app.db = SQLAlchemy(app) app.migrate = Migrate(app,app.db) app.bcrypt = Bcrypt(app) app.api = Api(app, prefix='/api/v1') app.api_registry = [] return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config.get(config_name, "default")) # Create database with the config settings app.db = create_db(app) from .api import api1_0 as api1_0_blueprint app.register_blueprint(api1_0_blueprint, url_prefix="/api/v1_0") from .api import login_blueprint app.register_blueprint(login_blueprint, url_prefix="") return app