def init_app(cls, app, env_name='development'): config_object = CONFIG[env_name] app.config.from_object(config_object) app.debug = config_object.DEBUG env = DotEnv() env.init_app(app, verbose_mode=True)
def create_app() -> Flask: app = Flask(__name__) dot_env = DotEnv() env_path = Path(os.path.abspath(__file__)).parent.parent stage = constants.STAGE if stage != "prod": stage = "dev" logger.debug("Initializing for stage", stage=stage) env_file = os.path.join(env_path, f".env.{stage}") dot_env.init_app(app, env_file=env_file, verbose_mode=True) rebar.init_app(app) logger.debug("Routes configured", routes=app.url_map) @app.before_request def before_request() -> None: name = (globals.request.environ.get("awsgi.event", {}).get("requestContext", {}).get("authorizer", {}).get("name")) endpoint = globals.request.full_path logger.info("Received request", endpoint=endpoint, name=name) @app.teardown_request def cleanup(exc: Union[Exception, None]) -> None: logger.debug("Cleaning logging context") structlog.threadlocal.clear_threadlocal() # put after rebar initialization to override rebar's default handler @app.errorhandler(errors.HttpJsonError) def handle_http_error(error: errors.HttpJsonError) -> None: """ Override default rebar exception handler for HttpJsonError. :param error: :return: """ raise @app.errorhandler(Exception) def handle_generic_error(error: Exception) -> Any: if app.debug: raise error (data, status_code) = __handle_generic_error(error) resp = json.jsonify(data) resp.status_code = status_code return resp return app
def read_env(app, config_class): """ config environment variables and override with .env declared ones. use configuration given by environment variable APP_ENV if "config_class" is not given """ env = DotEnv() env.init_app(app, env_file=".env") # get correct APP_ENV and right variable if not config_class: config_class = project_config.get(app.config.get('APP_ENV')) app.config.from_object(config_class) return app
def create_app(testing: bool = True): app = Flask(__name__, instance_relative_config=True) app.config.from_object("server.config") env = DotEnv(app) env.init_app(app) app.register_blueprint(api_bp) app.register_error_handler(404, page_not_found) @app.before_request def before_request() -> None: g.env = env g.testing = app.testing app.app_context().push() # this is needed for application global context return app
def init_app(app): print("app.config.__init__.init_app()") app.config.from_object("app.config.config." + os.getenv('FLASK_ENV', 'production').capitalize() + "Config") DotEnv().init_app(app, verbose_mode=True) # Configure logging logging.basicConfig(level=app.config['LOGGING_LEVEL'], format=app.config['LOGGING_FORMAT'], handlers=[logging.StreamHandler()])
def __init__(self): logging.basicConfig(level=logging.INFO) self.connexion_app = connexion.FlaskApp(__name__, specification_dir="./swagger") # CORS(self.connexion_app.app, support_credentials=True) env = DotEnv() env_loc = os.path.join( os.path.dirname(os.path.expanduser(os.path.expandvars(__file__))), '.env') env.init_app(self.connexion_app.app, env_file=env_loc, verbose_mode=False) # print(self.connexion_app.app.config) self.connexion_app.add_api( self.connexion_app.app.config["SWAGGER_FILE"], options={'swagger_ui': True}) self.port = int(self.connexion_app.app.config['CC_PORT']) or 8080 self.debug = bool(self.connexion_app.app.config["DEBUG"]) or False self.connexion_app.app.secret_key = self.connexion_app.app.config[ "SECRET_KEY"] or uuid.uuid4() orm_handler.db_init() @self.connexion_app.app.after_request def apply_cors(response): response.headers["Content-Type"] = "application/json" response.headers["Access-Control-Allow-Origin"] = "*" response.headers[ "Access-Control-Allow-Headers"] = "x-api-key, Origin, Accept, Content-Type, X-Requested-With, X-CSRF-Token" response.headers["Access-Control-Request-Headers"] = "*" response.headers[ "Access-Control-Allow-Methods"] = "GET, PUT, POST, OPTIONS, DELETE" response.headers["Access-Control-Allow-Credentials"] = "true" return response @self.connexion_app.app.teardown_appcontext def shutdown_session(exception=None): orm_handler.db_session.remove()
def create_app(): """ An flask application factory, as explained here: http://flask.pocoo.org/docs/patterns/appfactories/ """ app = Flask(__name__) #app.config.from_object(object_name) env = DotEnv() env.init_app(app=app, env_file=fs.getApplicationDirectory() + os.path.sep + '.env') for k, v in app.config.items(): if isinstance(v, str): v = v.lower().strip() if v == 'true': app.config[k] = True elif v == 'false': app.config[k] = False # initialize the cache cache.init_app(app) # initialize the debug tool bar debug_toolbar.init_app(app) login_manager.init_app(app) # Import and register the different asset bundles assets_env.init_app(app) assets_loader = PythonAssetsLoader(assets) for name, bundle in assets_loader.load_bundles().items(): assets_env.register(name, bundle) modules.init_app(app) return app
def create_app(): env = DotEnv() app = Flask(__name__) env.init_app(app) env.eval(keys={ 'DEBUG': bool, 'TESTING': bool }) mail = Mail(app) mail.init_app(app) @app.route("/", methods=['GET', 'POST']) def index(): """ Render the view of index page. """ form = FeedbackForm() return render_template('index.html', title='Tri Sinergi Mitra', current_page='TSM', form=form) @app.route("/send_feedback", methods=['POST']) def send_feedback(): """ Do action with python form """ if request.method == 'POST' : #result = request.form result = request.form['email'] msg_subject = "You got an email from {} / {} - {}".format(request.form['email'], request.form['full_name'], request.form['subject']) msg_body = request.form['body'] send_email(msg_subject,'*****@*****.**', ['*****@*****.**'], msg_body) return redirect(url_for('index')) else: flash('The message has not been sent due to unknown failure') return redirect(url_for('index')) def send_email(subject, sender, recipients, text_body): msg = Message(subject, sender=sender, recipients=recipients) msg.body = text_body mail.send(msg) return @app.errorhandler(404) def page_not_found_error(err): """ Render the view of error 404 page """ return render_template('404.html', title='TSM not found', current_page='404') @app.errorhandler(500) def internal_server_error(err): """ Render the view of error 500 page """ return render_template('500.html', title='TSM internal server error', current_page='500') return app
def create_app(): application = Flask(__name__) # Dotenv from flask_dotenv import DotEnv DotEnv(application) formatter = logging.Formatter( '[%(asctime)s] {%(name)s} %(levelname)s in %(module)s:\n\t %(message)s' ) level = logging.DEBUG # TODO: console_handler = logging.StreamHandler(sys.stdout) console_handler.setFormatter(formatter) console_handler.setLevel(level) loggers = ['root', 'flask.app', 'WechatAPI'] for logger in loggers: logger = logging.getLogger(logger) logger.setLevel(level) logger.addHandler(console_handler) if not application.debug: file_handler = logging.handlers.WatchedFileHandler( "{}/wechat.log".format(sys.path[0])) file_handler.setFormatter(formatter) file_handler.setLevel(logging.INFO) logger.addHandler(file_handler) application.logger.debug(application.config) application.logger.debug(os.environ) configure_extensions(application) @application.route("/") def index(): return "Oops" from app.github import github application.register_blueprint(github) from app.wechat_js_sdk import js_sdk application.register_blueprint(js_sdk, url_prefix='/wxjs') import app.wechat_handlers return application
def create_app(config_name): app = Flask(__name__) env = DotEnv(app) from app import models from app.models import Cars app.app_context().push() db.init_app(app) db.create_all() # temporary route @app.route('/') def home(): return render_template("index.html") @app.route('/list') def hello_world(): cars = Cars.query.all() return render_template("list.html", cars=cars) return app
def init_app(cls, app: Flask, env_files: List): """ .env file load """ env = DotEnv() config_py_path = os.path.realpath(__file__) app_path = os.path.dirname(config_py_path) project_root_path = os.path.dirname(app_path) app.config['ROOT_DIR'] = project_root_path for env_file in env_files: env_file = project_root_path + env_file env.init_app(app, env_file=env_file, verbose_mode=cls.DEBUG) env.eval(keys={ "MYSQL_PORT": int, "PORT": int, }) app.config['SQLALCHEMY_DATABASE_URI'] = SQLALCHEMY_DATABASE_URI.format( USER=app.config['MYSQL_DATABASE_USERNAME'], PASSWORD=app.config['MYSQL_ROOT_PASSWORD'], ADDR=app.config['MYSQL_DATABASE_HOST'], PORT=app.config['MYSQL_PORT'], NAME=app.config['MYSQL_DATABASE'])
def init_app(self, app): """ initializes the application secrets through a ".env" file """ env = DotEnv() env.init_app(app, verbose_mode=True)
import pdb import sys import json import click import datetime import mysql.connector from mysql.connector import pooling from flask import Flask, escape, request, jsonify, make_response from mysql.connector.errors import ProgrammingError from flask_dotenv import DotEnv pooling.CNX_POOL_MAXSIZE = 100 POOL_SIZE=32 app = Flask(__name__) env = DotEnv() env.init_app(app, verbose_mode=True) database_connect_configuration = dict( host=os.getenv('MYSQL_HOST', '127.0.0.1'), user=os.getenv('MYSQL_USER', 'root'), passwd=os.getenv('MYSQL_PASSWORD', ''), database=os.getenv('MYSQL_DATABASE', 'formbuilder'), auth_plugin='mysql_native_password', ) print(database_connect_configuration) try: config = database_connect_configuration.copy() config.update(pool_size=POOL_SIZE)
def init_app(self, app): print("Config: init_app") print(app.config) env = DotEnv() env.init_app(app, env_file="development.env", verbose_mode=True) print(app.config)
def init_app(app): env = DotEnv() env.init_app(app)
from extensions import db, migrate, login_manager from models import User from forms import RegistrationForm, LoginForm #flask imports from flask import Flask from flask_dotenv import DotEnv from werkzeug.urls import url_parse from flask import render_template, redirect, url_for, request, jsonify, flash from flask_login import current_user, login_user, logout_user, login_required import boto3 # create an instance of flask = app variable app = Flask(__name__) env = DotEnv(app) env.init_app(app) app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('DATABASE_URL') app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # grab the folder of the top-level directory of this project BASEDIR = os.path.abspath(os.path.dirname(__file__)) TOP_LEVEL_DIR = os.path.abspath(os.curdir) app.config.update(dict( SECRET_KEY=os.getenv('SECRET_KEY'), WTF_CSRF_SECRET_KEY=os.getenv('WTF_CSRF_SECRET_KEY') ))
# -*- coding: utf-8 -*- from os import environ from flask import Flask, request, jsonify from flask_cors import CORS from flask_dotenv import DotEnv from flask_mongoengine import MongoEngine, MongoEngineSessionInterface from flask_mongoengine.wtf import model_form from markupsafe import escape # Init modules env = DotEnv() db = MongoEngine() # Flask setup app = Flask(__name__) env.init_app(app, env_file="/var/www/html/frontend/.env" ) app.config['MONGODB_SETTINGS'] = { 'db': app.config["MONGO_DATABASE_NAME"], 'port': int(app.config["MONGO_HOST_PORT"]), 'host': '0.0.0.0', 'username':app.config["MONGO_CROP_USERNAME"], 'password':app.config["MONGO_CROP_PASSWORD"] } db.init_app(app) CORS(app) class User(db.Document): email = db.StringField(required=True) first_name = db.StringField(max_length=50) last_name = db.StringField(max_length=50)
def init_app(app): env_file_path = os.path.join(app.root_path, '../', '.env') if os.path.exists(env_file_path): env = DotEnv() env.init_app(app)
import os from flask import Flask from flask_sqlalchemy import SQLAlchemy from flask_login import LoginManager from flask_mail import Mail from flask_dotenv import DotEnv import logging from logging.handlers import SMTPHandler from flask_migrate import Migrate from flask_misaka import Misaka from flask_uploads import UploadSet, IMAGES, configure_uploads aplication = Flask(__name__) credentials = None env = DotEnv() env.init_app(aplication, env_file=os.path.join(os.getcwd(), '.env'), verbose_mode=True) from config import Config db = SQLAlchemy(aplication) misaka = Misaka(aplication, math=True, highlight=True) aplication.config.from_object(Config) migrate = Migrate(aplication, db) login = LoginManager(aplication) login.login_view = 'login' mail = Mail(aplication) images = UploadSet('images', IMAGES) configure_uploads(aplication, images) from app import views, models
def init_app(self, app): env = DotEnv() env.init_app(app, env_file=join(dirname(__file__), '../.env'))
def init_app(cls, app): env = DotEnv() path = os.getcwd().replace("config", "") env.init_app(app, env_file=os.path.join(path, ".env"), verbose_mode=True)
from flask_sqlalchemy import SQLAlchemy from flask import Flask from flask_dotenv import DotEnv import os print("Initializing Backend") app = Flask(__name__, static_folder='build') app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False env = DotEnv(app) env.init_app(app, env_file="./.env", verbose_mode=True) # For heroku launching if "DATABASE_URL" in os.environ: app.config["SQLALCHEMY_DATABASE_URI"] = os.environ["DATABASE_URL"] if "REACT_APP_SITEURL" in os.environ: app.config["REACT_APP_SITEURL"] = os.environ["REACT_APP_SITEURL"] if "SERVER_API_KEY" in os.environ: app.config["SERVER_API_KEY"] = os.environ["SERVER_API_KEY"] # Database db = SQLAlchemy(app) if app.config["DEBUG"]: app.debug = True else: app.debug = False
from flask import Flask from flask_marshmallow import Marshmallow from flask_sqlalchemy import SQLAlchemy from flask_vuejs import Vue from flask_dotenv import DotEnv db = SQLAlchemy() ma = Marshmallow() vue = Vue() dotenv = DotEnv() def create_app(): app = Flask(__name__) app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///tasks.sqlite" app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False # register flask extensions db.init_app(app) ma.init_app(app) vue.init_app(app) dotenv.init_app(app) from . import routes routes.use(app) return app
def create_app(config_name): """Initializes a modular flask application: - Initializes all the Flask extensions - Configures Celery Task queue - Hooks up all the blueprints """ app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) bootstrap.init_app(app) moment.init_app(app) db.init_app(app) login_manager.init_app(app) pagedown.init_app(app) celery.conf.update(app.config) env_file_path = os.path.join(app.root_path, '../', '.env') if os.path.exists(env_file_path): env = DotEnv() env.init_app(app) if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask_sslify import SSLify sslify = SSLify(app) from .controllers.main import main as main_blueprint app.register_blueprint(main_blueprint) from .controllers.auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/auth') from .api import api as api_blueprint app.register_blueprint(api_blueprint, url_prefix='/api') from .controllers.onboarding import onboarding as onboarding_blueprint app.register_blueprint(onboarding_blueprint, url_prefix='/onboarding') from .controllers.repos import repo as repo_blueprint app.register_blueprint(repo_blueprint, url_prefix='/repos') from .controllers.issues import issue as issue_blueprint app.register_blueprint(issue_blueprint, url_prefix='/repos/issues') from .controllers.boards import board as board_blueprint app.register_blueprint(board_blueprint, url_prefix='/boards') from .controllers.pull_requests import pull_request as pr_blueprint app.register_blueprint(pr_blueprint, url_prefix='/repos/pull_requests') from .controllers.github_members import github_member as \ github_member_blueprint app.register_blueprint(github_member_blueprint, url_prefix='/github_members') from .controllers.trello_members import trello_member as \ trello_member_blueprint app.register_blueprint(trello_member_blueprint, url_prefix='/trello_members') from .controllers.trello_lists import trello_list as trello_list_blueprint app.register_blueprint(trello_list_blueprint, url_prefix='/boards/lists') from .controllers.subscribed_lists import subscribed_list as \ subscribed_list_blueprint app.register_blueprint(subscribed_list_blueprint, url_prefix='/subscriptions/lists') from .controllers.subscriptions import subscription as subscription_blueprint app.register_blueprint(subscription_blueprint, url_prefix='/subscriptions') from .controllers.jira_subscriptions import jira_subscription as jira_subscription_blueprint app.register_blueprint(jira_subscription_blueprint, url_prefix='/jira/subscriptions') from .controllers.subscribed_jira_items import subscribed_item as subscribed_item_blueprint app.register_blueprint(subscribed_item_blueprint, url_prefix='/jira/subscriptions/items') from .controllers.jira_members import jira_member as jira_member_blueprint app.register_blueprint(jira_member_blueprint, url_prefix='/jira/members') from .controllers.projects import project as project_blueprint app.register_blueprint(project_blueprint, url_prefix='/jira/projects') from .controllers.jira_issues import jira_issue as jira_issue_blueprint app.register_blueprint(jira_issue_blueprint, url_prefix='/jira/issues') from .controllers.jira_issue_types import jira_issue_type as jira_issue_type_blueprint app.register_blueprint(jira_issue_type_blueprint, url_prefix='/jira/issue_types') return app
def init_app(cls, app): env = DotEnv() env.init_app(app, env_file=os.path.join(cls.ROOT_PATH, '.env')) env.alias(maps={'MAIL_USERNAME': '******'})
import os from flask import Flask, jsonify, request from flask_pymongo import PyMongo from flask_dotenv import DotEnv app = Flask(__name__) # We try to read in env vars if they exist env = DotEnv() env.init_app(app, verbose_mode=False) MONGO_URI = os.environ.get("MONGO_URI") mongo = PyMongo(app, uri=MONGO_URI, retryWrites=False) @app.route('/test', methods=['GET']) def get_all_frameworks(): test = mongo.db.test output = [] for q in test.find(): output.append({'stuff': q['stuff']}) return jsonify({'result': output}) @app.route('/test', methods=['POST']) def add_framework(): test = mongo.db.test
#flask_app.py from flask import Flask from flask_dotenv import DotEnv import os app = Flask(__name__) # https://github.com/grauwoelfchen/flask-dotenv env = DotEnv(app) @app.route("/") def hello(): return "<h1>Hello PyCon9</h1>" if __name__ == "__main__": app.run(host="0.0.0.0")
from slugify import slugify basicConfig(format="%(asctime)s\t- %(levelname)s\t- %(message)s", level=INFO) app = Flask(__name__) app.config["TELERIVET_API_KEY"] = environ["TELERIVET_API_KEY"] app.config["WEBHOOK_SECRET"] = environ["WEBHOOK_SECRET"] app.config["SQLALCHEMY_DATABASE_URI"] = environ.get( "DATABASE_URL") or "sqlite:///dev.db" db = SQLAlchemy(app) mn = minify(app) hz = Humanize(app) ev = DotEnv(app) @hz.localeselector def get_locale(): return "pt_BR" # Models class Category(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), unique=True, nullable=False) slug = db.Column(db.String(50), unique=True, nullable=False) def __repr__(self): return "<Category {}>".format(self.name)
from flask_dotenv import DotEnv # Load .env into flask config env = DotEnv()
def init_app(cls, app): env = DotEnv() env.init_app(app, verbose_mode=True)