def create_app():
# 创建flask对象app
app = Flask(__name__,
static_folder=static_folder,
template_folder=template_folder)
# 创建总路由
app.register_blueprint(user_blueprint, url_prefix='/user')
app.register_blueprint(house_blueprint, url_prefix='/house')
app.register_blueprint(order_blueprint, url_prefix='/order')
# 配置数据库
app.config['SQLALCHEMY_DATABASE_URI'] = get_sqlalchemy_uri(MYSQL_DATABASE)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db.init_app(app)
# 配置redis-->session
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = redis.Redis(host=REDIS_DATABASE['HOST'],
port=REDIS_DATABASE['PORT'])
se = Session()
se.init_app(app)
# 配置debug模式
# app.config['SECRET_KEY'] = 'secret_key'
# app.debug = True
# bar = DebugToolbarExtension()
# bar.init_app(app)
return app
def create_app(config_file=None, settings_override=None):
app = Flask(__name__)
sess = Session()
if config_file:
app.config.from_pyfile(config_file)
else:
app.config.from_envvar(config_variable_name)
if settings_override:
app.config.update(settings_override)
sess.init_app(app)
db = SQLAlchemy(app)
db.init_app(app)
with app.app_context():
db.create_all()
s = db.session
app.config["FLASK_ADMIN_SWATCH"] = "cerulean"
admin = Admin(app, name="foo", template_mode="bootstrap3")
admin.add_view(ModelView(Task, s))
admin.add_view(ModelView(User, s))
admin.add_view(ModelView(Project, s))
admin.add_view(ModelView(WorkDay, s))
admin.add_view(ModelView(TodoList, s))
return app
def init_ext(app):
sess = Session()
db.init_app(app)
sess.init_app(app)
Bootstrap(app)
#实例化migrate
migrate = Migrate(app=app, db=db)
def create_app():
from flask import Flask
app = Flask(__name__)
app.register_blueprint(blueprint=blue)
# session 默认是没有持久化存储
# 使用session，需要做配置
app.config[
'SECRET_KEY'] = '@#$%^&*()dfghjuiko@#$%^&*()fghj123123123134gagu'
## flask-session
# 配置方式一
# SESSION_TYPE = 'redis'
# app.config.from_object(__name__)
# 配置方式二
app.config['SESSION_TYPE'] = 'redis'
# 初始化，方式一
# Session(app)
# 初始化，方式二
sess = Session()
sess.init_app(app)
## ORM
# /// 相对路径
# //// 绝对路径
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db.init_app(app)
return app
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
app.config["APP_VERSION"] = __version__
login.init_app(app)
bootstrap.init_app(app)
db.init_app(app)
# setup a Flask session to store data between requests
# app.secret_key = 'super secret key'
app.config['SESSION_TYPE'] = 'filesystem'
sess = Session()
sess.init_app(app)
# register the blueprints
from image_labeller.auth import bp as auth_bp
app.register_blueprint(auth_bp)
from image_labeller.main import bp as main_bp
app.register_blueprint(main_bp)
from image_labeller.admin import bp as admin_bp
app.register_blueprint(admin_bp)
# create database tables
with app.app_context():
db.create_all()
return app
def create_app():
sess = Session()
app.config.from_object(DevCfg)
sess.init_app(app)
database.init('telecom',
host='mysql',
user='******',
passwd='1q2w3e4r5t',
max_connections=50,
stale_timeout=3000)
import app.clients.controllers as clients
import app.profile.controllers as profile
import app.contacts.controllers as contacts
import app.index.controllers as index
import app.admin.controllers as admin
import app.appeal.controllers as appeal
app.register_blueprint(clients.module)
app.register_blueprint(profile.module)
app.register_blueprint(contacts.module)
app.register_blueprint(index.module)
app.register_blueprint(admin.module)
app.register_blueprint(appeal.module)
app.register_error_handler(404, handlers.page_not_found)
app.register_error_handler(405, handlers.forbidden)
return app
def create_app():
app = Flask(__name__)
sess = Session()
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
@app.route("/event_handler", methods=['GET', 'POST'])
def main():
"""Main function to handle all requests."""
if request.method == "POST":
# GitHub sends the secret key in the payload header
if match_webhook_secret(request):
event = request.headers["X-GitHub-Event"]
event_to_action = {"pull_request": handle_pull_request}
supported_event = event in event_to_action
if supported_event:
return event_to_action[event](request.json)
else:
# TODO: replace with a more appropriate request
return handle_unauthorized_requests()
else:
app.logger.info("Received an unauthorized request")
return handle_unauthorized_requests()
else:
return redirect("https://pep8speaks.com")
app.secret_key = os.environ.setdefault("APP_SECRET_KEY", "")
app.config['SESSION_TYPE'] = 'filesystem'
sess.init_app(app)
app.debug = False
return app
def create_app():
app = Flask(__name__,
static_folder=static_folder,
template_folder=template_folder)
@app.route('/')
def index():
return render_template('index.html')
# 注册蓝图
app.register_blueprint(user_blueprint, url_prefix='/user')
app.register_blueprint(house_blueprint, url_prefix='/house')
app.register_blueprint(order_blueprint, url_prefix='/order')
# 设置数据库的配置
app.config['SQLALCHEMY_DATABASE_URI'] = get_sqlalchemy_uri(MYSQL_DATABASE)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# redis --> session - 通过redis启动session
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = redis.Redis(host=REDIS_DATABASE['HOST'],
port=REDIS_DATABASE['PORT'])
app.config['SECRET_KEY'] = 'secret_key'
# app.debug = True
db.init_app(app)
se = Session()
se.init_app(app)
# bar = DebugToolbarExtension()
# bar.init_app(app)
return app
def init_ext(app):
migrate = Migrate(app=app, db=db)
se = Session()
se.init_app(app)
db.init_app(app)
mail.init_app(app)
cache.init_app(app, {"CACHE_TYPE": "redis"})
def create_app(config_name):
# set config env
Config = config_dict.get(config_name)
# call log_file()
register_log(Config.LEVEL_NAME)
# init app
app = Flask(__name__)
app.config.from_object(Config)
# config database
db.init_app(app)
# config redis
global redis_store
redis_store = StrictRedis(host=Config.redis_host,
port=Config.redis_port,
decode_responses=True)
# config session
sess = Session()
sess.init_app(app)
# config csrf
csrf = CSRFProtect(app)
# register bluepints
from App.modules.index import index_bp
app.register_blueprint(index_bp)
# print(app.url_map)
return app
def create_app():
app = Flask(__name__)
#密钥
app.config["SECRET_KEY"] = "shibushishayawoshelemiyao"
#指定session存储方案
app.config["SESSION_TYPE"]="redis"
#设置缓存开头，一般以自己pythonpoackage的app名字为开头
app.config["SESSION_KEY_PREFIX"] = "myapp"
# 定制化的将session存在redis的指定库中
app.config["SESSION_REDIS"] = StrictRedis(host="127.0.0.1", db=5)
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
#创建数据库文件
# app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///sqlite3.db"
app.config["SQLALCHEMY_DATABASE_URI"] = "mysql+pymysql://root:[email protected]:3306/flask02"
#实例化第三方插件
#实例化Session
sess = Session()
sess.init_app(app)
db.init_app(app)
app.register_blueprint(blue)
return app
def register_extensions(app):
"""Register Flask extensions."""
# Flask Session
app.config['SESSION_TYPE'] = 'filesystem'
app.config['SECRET_KEY'] = '?Y\Kj;!X%AcmjF%CF(_k)p8,S<<6uhUJ'
sess = Session()
sess.init_app(app)
def init_ext(app):
migrate.init_app(app)
db.init_app(app)
sess = Session()
sess.init_app(app)
def init_ext(app):
se = Session()
se.init_app(app)
# db绑定
db.init_app(app)
# 实例化migrate
migrate = Migrate(app=app,db=db)
def register_extensions(app):
"""Register Flask extensions."""
# Flask Session
app.config['SESSION_TYPE'] = 'filesystem'
app.config['SECRET_KEY'] = os.urandom(24)
sess = Session()
sess.init_app(app)
def _configure_session(self):
app.config['SESSION_TYPE'] = 'sqlalchemy'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///{home}/sessions.db'.format(home=HOME)
db = SQLAlchemy(app)
app.config['SESSION_SQLALCHEMY'] = db
flask_session = Session()
flask_session.init_app(app)
db.create_all()
def create_app():
app = Flask(__name__)
app.config.from_object(config)
app.register_blueprint(cms_bp)
app.register_blueprint(front_bp)
db.init_app(app)
sess = Session()
sess.init_app(app)
return app
def init_ext(app):
# 获取Session对象，并初始化app
se = Session()
se.init_app(app)
# 绑定db和app
db.init_app(app)
# 绑定login_manager和app
login_manager.login_view = 'user.login'
login_manager.init_app(app)
def create_app():
sess = Session()
server = Flask(__name__)
server.config.from_object(BaseConfig)
register_dashapps(server)
register_blueprints(server)
sess.init_app(server)
return server
def create_app(config):
app = Flask(__name__, static_folder='base/static')
app.config.from_object(config)
app.secret_key = 'super secret key'
app.config['SESSION_TYPE'] = 'filesystem'
register_extensions(app)
register_blueprints(app)
sess = Session()
sess.init_app(app)
return app
def register_session(app):
"""
Creates the flask session.
:param app: Current Flask application
:type app: <Flask 'app'> obj
"""
sess = Session()
sess.init_app(app)
Session(app)
def create_app():
# For running locally without connecting to the database
if os.environ.get("OVER_HEROKU", False) is not False:
urlparse.uses_netloc.append("postgres")
url = urlparse.urlparse(os.environ["DATABASE_URL"])
conn = psycopg2.connect(
database=url.path[1:],
user=url.username,
password=url.password,
host=url.hostname,
port=url.port
)
cursor = conn.cursor()
# Make the objects available across all the modules
builtins.conn = conn
builtins.cursor = cursor
app = Flask(__name__)
sess = Session()
@app.route("/", methods=['GET', 'POST'])
def main():
if request.method == "GET":
return redirect("https://pep8speaks.com")
elif request.method == "POST":
# GitHub sends the secret key in the payload header
if utils.match_webhook_secret(request):
event = request.headers["X-GitHub-Event"]
event_to_action = {
"pull_request": handlers.handle_pull_request,
"pull_request_review": handlers.handle_review,
"pull_request_review_comment": handlers.handle_review_comment,
"integration_installation": handlers.handle_integration_installation,
"integration_installation_repositories": handlers.handle_integration_installation_repo,
"installation_repositories": handlers.handle_integration_installation_repo,
"ping": handlers.handle_ping,
"issue_comment": handlers.handle_issue_comment,
"installation": handlers.handle_installation,
}
try:
return event_to_action[event](request)
except KeyError:
handlers.handle_unsupported_requests(request)
else:
return render_template('index.html')
app.secret_key = os.environ.setdefault("APP_SECRET_KEY", "")
app.config['SESSION_TYPE'] = 'filesystem'
sess.init_app(app)
app.debug = False
return app
def create_app(self):
logging.getLogger('connexion.operation').setLevel('ERROR')
app = connexion.App(__name__, specification_dir='../swagger/')
app.app.config['SESSION_TYPE'] = 'redis'
app.app.config['SESSION_REDIS'] = redis.from_url('redis://10.5.0.2')
sess = Session()
sess.init_app(app.app)
app.app.config['SECRET_KEY'] = os.urandom(24)
app.app.json_encoder = JSONEncoder
app.add_api('swagger.yaml', arguments={'title': 'Project Eval API'})
return app.app
def create_app(config=None):
app = Flask(__name__)
session = Session()
app.config['SESSION_TYPE'] = 'filesystem'
app.config['SECRET_KEY'] = SECRET_KEY
app.config.from_object("app.config")
session.init_app(app)
DB.init()
Bootstrap(app)
register_blueprints(app)
return app
def create_app():
app = Flask(__name__)
CORS(app, resources={r"/api/*": {"origins": "*"}})
app.config.from_pyfile("../config.py")
#override elements from environment settings
for variable, value in os.environ.items():
#if variable.startswith("MYSQL_"):
app.config[variable] = value
#set language
app.available_locales = ['fr_FR', 'en_FR']
app.available_languages = {
'fr': {
'lang': 'Français',
'icon': 'fr'
},
'en': {
'lang': 'English',
'icon': 'us'
}
}
app.default_language = 'fr'
app.languages = {}
languages = {}
#parse files located in language directory
language_list = glob.glob("biblioapp/language/*.json", recursive=False)
for lang in language_list:
filename = lang.split('/')
lang_code = filename[2].split('.')[0]
with open(lang, 'r', encoding='utf8') as file:
languages[lang_code] = json.loads(file.read())
app.languages = languages
#Session(app)
sess = Session()
sess.init_app(app)
bootstrap = Bootstrap(app)
login_manager.init_app(app)
from biblioapp.routes.user_routes import set_routes_for_user
from biblioapp.routes.static_routes import set_routes_for_static_pages
from biblioapp.routes.module_routes import set_routes_for_module
from biblioapp.routes.positions_routes import set_routes_for_positions
from biblioapp.routes.books_routes import set_routes_for_books
from biblioapp.routes.customize_routes import set_routes_for_customization
set_routes_for_user(app)
set_routes_for_static_pages(app)
set_routes_for_module(app)
set_routes_for_positions(app)
set_routes_for_books(app)
set_routes_for_customization(app)
return app
def create_app():
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret_key'
app.config['SESSION_KEY_PREFIX'] = 'flask'
app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(
days=7) # 设置session的保存时间。
app.config['MYSQL_DATABASE_CHARSET'] = 'utf8mb4'
manager = Manager(app)
sess = Session(app)
sess.init_app(app)
app.debug = True
return app
def create_app():
app = Flask(__name__)
app.secret_key = ''.join(random.choice(string.ascii_lowercase) for i in range(256))
app.config['SESSION_TYPE'] = 'filesystem'
sess = Session()
sess.init_app(app)
@app.route('/')
def default():
return hello_world()
return app
def init_ext(app):
migrate = Migrate(app=app,db=db)
se = Session()
se.init_app(app)
db.init_app(app)
# 调试插件的实例化
debug = DebugToolbarExtension()
debug.init_app(app)
#缓存
cache.init_app(app,config=CACHE.get("default"))
bootstrap.init_app(app)
def create_app():
app = Flask(__name__)
app.register_blueprint(vp_api)
app.register_blueprint(funnel_api)
app.register_blueprint(ci_api)
app.register_blueprint(renew_api)
app.register_blueprint(device_api)
app.register_blueprint(cart_api)
cors = CORS(app)
sess = Session()
sess.init_app(app)
return app
def create_app(settings_override=None, drop_create_db=False):
app = Flask(__name__)
config_path = path.join(app.root_path, "..", "config/poker.yml")
with open(config_path, "r") as config_file:
config = yaml.load(config_file, Loader=yaml.FullLoader)
app.config.update(config["db"])
app.config.update(config["session"])
# for debug environment to hit error handlers
app.config["PRESERVE_CONTEXT_ON_EXCEPTION"] = False
if settings_override:
app.config.update(settings_override)
from poker.database import db
from poker.database import models
db.init_app(app)
sess = Session()
sess.init_app(app)
if drop_create_db:
with app.app_context():
db.drop_all()
db.create_all()
app.session_interface.db.create_all()
@app.route("/")
def index():
return "Welcome to Hanson's poker API!"
@app.errorhandler(Exception)
def rollback_database(exception):
try:
db.session.rollback()
except Exception:
pass
return exception
@app.teardown_request
def database_cleanup(exception):
try:
db.session.commit()
except Exception:
pass
configure_blueprints(app)
return app
def init(conf=None, verbose=0, logfile=None, gunicorn=True, unittest=False, debug=False):
"""Initialize the whole application.
:param conf: Configuration file to use
:type conf: str
:param verbose: Set the verbosity level
:type verbose: int
:param logfile: Store the logs in the given file
:type logfile: str
:param gunicorn: Enable gunicorn engine instead of flask's default
:type gunicorn: bool
:param unittest: Are we running tests (used for test only)
:type unittest: bool
:param debug: Enable debug mode
:type debug: bool
:returns: A :class:`burpui.server.BUIServer` object
"""
from flask_login import LoginManager
from flask_bower import Bower
from .utils import basic_login_from_request, ReverseProxied
from .server import BUIServer as BurpUI
from .routes import view
from .api import api, apibp
logger = logging.getLogger('burp-ui')
# The debug argument used to be a boolean so we keep supporting this format
if isinstance(verbose, bool):
if verbose:
verbose = logging.DEBUG
else:
verbose = logging.CRITICAL
else:
levels = [
logging.CRITICAL,
logging.ERROR,
logging.WARNING,
logging.INFO,
logging.DEBUG
]
if verbose >= len(levels):
verbose = len(levels) - 1
if not verbose:
verbose = 0
verbose = levels[verbose]
if logfile:
from logging.handlers import RotatingFileHandler
handler = RotatingFileHandler(
logfile,
maxBytes=1024 * 1024 * 100,
backupCount=5
)
else:
from logging import StreamHandler
handler = StreamHandler()
if verbose > logging.DEBUG:
LOG_FORMAT = (
'[%(asctime)s] %(levelname)s in '
'%(module)s.%(funcName)s: %(message)s'
)
else:
LOG_FORMAT = (
'-' * 80 + '\n' +
'%(levelname)s in %(module)s.%(funcName)s ' +
'[%(pathname)s:%(lineno)d]:\n' +
'%(message)s\n' +
'-' * 80
)
handler.setLevel(verbose)
handler.setFormatter(Formatter(LOG_FORMAT))
logger.setLevel(verbose)
logger.addHandler(handler)
logger.debug(
'conf: {}\n'.format(conf) +
'verbose: {}\n'.format(logging.getLevelName(verbose)) +
'logfile: {}\n'.format(logfile) +
'gunicorn: {}\n'.format(gunicorn) +
'debug: {}\n'.format(debug) +
'unittest: {}'.format(unittest)
)
if not unittest:
from ._compat import patch_json
patch_json()
if gunicorn:
from gevent import monkey
monkey.patch_all()
# We initialize the core
app = BurpUI()
app.enable_logger()
app.gunicorn = gunicorn
app.config['CFG'] = None
# FIXME: strange behavior when bundling errors
# app.config['BUNDLE_ERRORS'] = True
app.config['REMEMBER_COOKIE_HTTPONLY'] = True
app.jinja_env.globals.update(
isinstance=isinstance,
list=list,
version_id='{}-{}'.format(__version__, __release__)
)
if debug and not gunicorn: # pragma: no cover
app.config['DEBUG'] = True and not unittest
app.config['TESTING'] = True and not unittest
# Still need to test conf file here because the init function can be called
# by gunicorn directly
app.config['CFG'] = lookup_config(conf)
logger.info('Using configuration: {}'.format(app.config['CFG']))
app.setup(app.config['CFG'])
# manage application secret key
if app.secret_key and (app.secret_key.lower() == 'none' or
(app.secret_key.lower() == 'random' and gunicorn)):
logger.warning('Your setup is not secure! Please consider setting a'
' secret key in your configuration file')
app.secret_key = 'Burp-UI'
if not app.secret_key or app.secret_key.lower() == 'random':
from base64 import b64encode
app.secret_key = b64encode(os.urandom(256))
app.wsgi_app = ReverseProxied(app.wsgi_app, app)
# Manage gunicorn special tricks & improvements
if gunicorn: # pragma: no cover
logger.info('Using gunicorn')
from werkzeug.contrib.fixers import ProxyFix
if app.storage and app.storage.lower() == 'redis':
if app.redis:
part = app.redis.split(':')
host = part[0]
try:
port = int(part[1])
except:
port = 6379
else:
host = 'localhost'
port = 6379
logger.debug('Using redis {}:{}'.format(host, port))
try:
from redis import Redis
from flask_session import Session
red = Redis(host=host, port=port)
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = red
app.config['SESSION_USE_SIGNER'] = app.secret_key is not None
app.config['SESSION_PERMANENT'] = False
ses = Session()
ses.init_app(app)
except Exception as e:
logger.warning('Unable to initialize redis: {}'.format(str(e)))
pass
api.cache.init_app(
app,
config={
'CACHE_TYPE': 'redis',
'CACHE_REDIS_HOST': host,
'CACHE_REDIS_PORT': port,
'CACHE_REDIS_DB': 1
}
)
# clear cache at startup in case we removed or added servers
with app.app_context():
api.cache.clear()
else:
api.cache.init_app(app)
app.wsgi_app = ProxyFix(app.wsgi_app)
else:
api.cache.init_app(app)
# We initialize the API
api.init_bui(app)
api.version = __version__
api.release = __release__
api.__url__ = __url__
api.__doc__ = __doc__
app.register_blueprint(apibp)
# Then we load our routes
view.init_bui(app)
view.__url__ = __url__
view.__doc__ = __doc__
app.register_blueprint(view)
# And the login_manager
app.login_manager = LoginManager()
app.login_manager.login_view = 'view.login'
app.login_manager.login_message_category = 'info'
app.login_manager.session_protection = 'strong'
app.login_manager.init_app(app)
app.config.setdefault(
'BOWER_COMPONENTS_ROOT',
os.path.join('static', 'vendor')
)
app.config.setdefault('BOWER_REPLACE_URL_FOR', True)
bower = Bower()
bower.init_app(app)
@app.before_request
def setup_request():
if app.scookie:
from flask import request
criteria = [
request.is_secure,
request.headers.get('X-Forwarded-Proto', 'http') == 'https'
]
app.config['SESSION_COOKIE_SECURE'] = \
app.config['REMEMBER_COOKIE_SECURE'] = any(criteria)
@app.login_manager.user_loader
def load_user(userid):
"""User loader callback"""
if app.auth != 'none':
return app.uhandler.user(userid)
return None
@app.login_manager.request_loader
def load_user_from_request(request):
"""User loader from request callback"""
if app.auth != 'none':
return basic_login_from_request(request, app)
return app
return err_msg + ": " + traceback.format_exc(), 409
t0 = time.time()
template_dir = os.path.join(os.path.dirname(__file__), "templates")
server = Flask(__name__, static_url_path='', template_folder=template_dir)
server.debug = False
server.config['SESSION_TYPE'] = "redis"
server.config['SESSION_KEY_PREFIX'] = "mxcube:session:"
server.config['SECRET_KEY'] = "nosecretfornow"
server.register_error_handler(Exception, exception_handler)
_session = Session()
_session.init_app(server)
socketio = SocketIO(manage_session=False)
socketio.init_app(server)
# the following test prevents Flask from initializing twice
# (because of the Reloader)
if not server.debug or os.environ.get("WERKZEUG_RUN_MAIN") == "true":
mxcube.init(hwr, cmdline_options.hwr_directory,
cmdline_options.allow_remote,
cmdline_options.ra_timeout,
cmdline_options.video_device,
cmdline_options.log_file)
from core import loginutils
logger.setupLogging(app) assets.setupAssets(app) login_manager = LoginManager() login_manager.init_app(app) socketio = SocketIO() socketio.init_app(app) mail = Mail() mail.init_app(app) sess = Session() sess.init_app(app) app.url_map.strict_slashes = False from pingpong.controllers.AdminController import adminController from pingpong.controllers.ApiController import apiController from pingpong.controllers.AuthenticationController import authenticationController from pingpong.controllers.ErrorController import errorController from pingpong.controllers.IsmController import ismController from pingpong.controllers.CourtesyController import courtesyController from pingpong.controllers.LeaderboardController import leaderboardController from pingpong.controllers.MainController import mainController from pingpong.controllers.MatchController import matchController from pingpong.controllers.OfficeController import officeController from pingpong.controllers.PlayerController import playerController
