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
Esempio n. 2
1
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
Esempio n. 3
0
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
Esempio n. 4
0
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
Esempio n. 5
0
File: app.py Progetto: snare/flexo
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
Esempio n. 6
0
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
Esempio n. 7
0
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
Esempio n. 8
0
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
Esempio n. 9
0
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
Esempio n. 10
0
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
Esempio n. 11
0
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
Esempio n. 12
0
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
Esempio n. 13
0
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
Esempio n. 14
0
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
Esempio n. 15
0
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
Esempio n. 16
0
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
Esempio n. 17
0
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
Esempio n. 18
0
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
Esempio n. 19
0
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
Esempio n. 20
0
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
Esempio n. 21
0
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
Esempio n. 22
0
    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
Esempio n. 23
0
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
Esempio n. 24
0
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
Esempio n. 25
0
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
Esempio n. 26
0
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
Esempio n. 27
0
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
Esempio n. 28
0
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
Esempio n. 29
0
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
Esempio n. 30
0
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
Esempio n. 31
0
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
Esempio n. 32
0
 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}
Esempio n. 33
0
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
Esempio n. 34
0
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
Esempio n. 35
0
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
Esempio n. 36
0
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
Esempio n. 37
0
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
Esempio n. 38
0
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
Esempio n. 39
0
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
Esempio n. 40
0
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
Esempio n. 41
0
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
Esempio n. 42
0
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
Esempio n. 43
0
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
Esempio n. 45
0
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
Esempio n. 46
0
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
Esempio n. 47
0
def create_app():
    app = Flask(__name__)

    app.register_blueprint(hashes, url_prefix="/hash")
    app = error_routes(app)

    app.db = Hash()

    return app
Esempio n. 48
0
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
Esempio n. 49
0
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
Esempio n. 50
0
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
Esempio n. 51
0
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
Esempio n. 52
0
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
Esempio n. 53
0
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
Esempio n. 54
0
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
Esempio n. 55
0
    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
Esempio n. 56
0
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
Esempio n. 57
0
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
Esempio n. 58
0
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