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)
