def create_app():
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///hire.db'
api.init_app(app)
db.init_app(app)
with app.app_context():
db.create_all()
cand = Candidate(firstname='Harry',
middlename='Ian',
lastname='Laurenceau',
city='Chicago',
state='MD')
db.session.add(cand)
db.session.commit()
ma.init_app(app)
@app.route('/health')
def healthcheck():
return {'status': 'UP'}
@app.route('/history/<int:id>', methods=['POST'])
def add_history(id):
ceh = CandidateEmploymentHistorySchema()
employment_history = request.json
#employment_history['startdate'] = datetime.strptime(employment_history['startdate'], '%d-%m-%Y')
#employment_history['enddate'] = datetime.strptime(employment_history['enddate'], '%d-%m-%Y')
c = ceh.load(employment_history)
print(c, type(c.startdate))
return 'success'
return app
def create_flask_app(config_object=None):
"""Flask app factory method"""
app = Flask(__name__)
if config_object is not None:
app.config.from_object(config_object)
else:
app.config.from_mapping(
BCRYPT_LOG_ROUNDS=10,
SECRET_KEY=environ["FLASK_SECRET_KEY"],
SQLALCHEMY_TRACK_MODIFICATIONS=False,
SQLALCHEMY_DATABASE_URI=environ["DATABASE_PATH"],
)
# init database
db.init_app(app)
bcrypt.init_app(app)
Migrate(app, db)
__add_default_courses(app)
# init api
api.init_app(app)
# init swagger
app.register_blueprint(SWAGGER_UI_BLUEPRINT, url_prefix=SWAGGER_URL)
return app
def create_app(script_info=None):
# instantiate the app
app = Flask(__name__)
# set config
app_settings = os.getenv("APP_SETTINGS")
app.config.from_object(app_settings)
# set up extensions
db.init_app(app)
cors.init_app(app, resources={r"*": {"origins": "*"}})
bcrypt.init_app(app)
# register api
from app.api import api
api.init_app(app)
# shell context for flask cli
@app.shell_context_processor
def ctx():
return {"app": app, "db": db}
return app
def create_app(app_name=APP_NAME, test_config=None, **kwargs):
"""
Function which creates Flask app instance and initializes database, API, and celery when given celery argument.
Only celery worker calls this function without celery argument given, for its purpose of having its own instances.
:param app_name: Application name. Can be set in definitions file.
:param test_config: -
:param kwargs: keyword arguments which may contain 'celery' key with celery app instance as argument.
:return: Flask app instance
"""
app = Flask(app_name)
if kwargs.get("celery"):
init_celery(kwargs.get("celery"), app)
if test_config:
app.config.update(test_config)
else:
app.config.from_mapping(
SQLALCHEMY_DATABASE_URI=SQLALCHEMY_DB_URI,
SQLALCHEMY_TRACK_MODIFICATIONS=SQLALCHEMY_TRACK_MODIFICATIONS,
)
with app.app_context():
init_database(app)
api.init_app(app)
return app
def create_app():
"""
flask application initialization skeleton
:return Flask:
"""
app_dir_path = os.path.dirname(os.path.realpath(__file__))
root_path = os.path.abspath(os.path.join(app_dir_path, os.pardir))
app = Flask(__name__, instance_relative_config=True, root_path=root_path)
app.config.from_object(os.getenv('APP_SETTINGS', 'app.config.LocalConfig'))
if os.path.exists(os.path.join(app.instance_path, 'log_config.conf')):
fileConfig(os.path.join(app.instance_path, 'log_config.conf'),
defaults={
'logfilename':
os.path.join(app.root_path,
app.config.get('LOGFILE_PATH'))
},
disable_existing_loggers=False)
with app.app_context():
from app.api import api
from app.db import db
from app.routes import configure_routes
configure_routes(api)
api.init_app(app)
db.init_app(app)
db.create_all()
return app
def create_app(environemnt):
"""
App factory for the server.
Instantiates a Flask object.
Configures the app according to the environment.
Initializes the extensions.
Adds the middleware to check headers.
Returns the app instance.
:param: environment
Environemnt to configure the server to
:returns:
"""
app = Flask(__name__)
app.config.from_object(cfg_map[environemnt])
app.redis = Redis.from_url(app.config.get("REDIS_URL"))
app.task_queue = Queue(app.config.get("REDIS_QUEUE_NAME"),
connection=app.redis)
mongo_client = MongoClient(
app.config.get("MONGO_URI"),
authSource=app.config.get("MONGO_AUTH_SOURCE"),
)
app.mongo = mongo_client[app.config.get("MONGO_DATABASE")]
from app import bcrypt
from app import cors
from app import db
from app import migrate
db.init_app(app)
cors.init_app(app, resources={r"/*": {"origins": "*"}})
bcrypt.init_app(app)
migrate.init_app(app, db)
from app.api import api
api.init_app(app)
from app.api.auth.models import Token # noqa: F401
from app.api.sentiment.models import Sentiment # noqa: F401
from app.api.users.models import User # noqa: F401
@app.before_request
def check_headers():
if ("swagger" not in request.path and "admin" not in request.path
and request.method != "OPTIONS"):
accepts = request.headers.get("Accept")
if not accepts or accepts != "application/json":
abort(415, "Only content type supported is application/json")
if request.method in ["POST", "PUT"]:
content_type = request.headers.get("Content-Type")
if not content_type or content_type != "application/json":
abort(
415,
"POST/PUT requests should define Content-Type header",
)
return app
def make_app():
_app = Flask(__name__)
_app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URI']
_app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db.init_app(_app)
api.init_app(_app)
Migrate(app=_app, db=db)
return _app
def initialize_app(flask_app, testing=False):
configure_app(flask_app, testing=testing)
MongoEngine(flask_app)
blueprint = Blueprint('api', __name__, url_prefix='/api')
api.init_app(blueprint)
api.add_namespace(images_tasks_namespace)
api.add_namespace(text_tasks_namespace)
flask_app.register_blueprint(blueprint)
def create_app(flask_config_name=None):
'''' create flask app '''
## Load Config
env_flask_config_name = os.getenv('FLASK_CONFIG')
if not env_flask_config_name and flask_config_name is None:
flask_config_name = 'development'
elif flask_config_name is None:
flask_config_name = env_flask_config_name
try:
if CONFIG_NAME_MAPPER[flask_config_name] is None:
return None
except KeyError:
return None
## Creat app
app = Flask(__name__)
app.config.from_pyfile(CONFIG_NAME_MAPPER[flask_config_name])
app.config.SWAGGER_UI_JSONEDITOR = True
app.config.SWAGGER_UI_DOC_EXPANSION = 'list'
# CORS(app, reousrces={r'/api/*':{"origins":app.config['CORS_ORIGIN']}})
## Set logger
#logging.getLogger('flask_cors').level = logging.DEBUG
#logging.getLogger('elasticsearch').level = logging.WARNING
logging.basicConfig(format=app.config['LOGGER_FORMAT'], level=app.config['LOGGER_LEVEL'])
## db init
from app.dao import daoPool
daoPool.init_app(app)
from app.model.userModel import User
me = User('admin', '*****@*****.**', None, None)
daoPool.sqlDAO.session.add(me)
daoPool.sqlDAO.session.commit()
## Oauth init
from app import oauth
oauth.init_oauth(app)
## Api init
from app.api import api
api.init_app(app)
return app
def register_plugin(app):
api.init_app(app)
db.init_app(app)
ma.init_app(app)
CORS().init_app(app)
log.init_app(app)
mail.init_app(app)
with app.app_context():
# db.drop_all()
db.create_all()
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
db.init_app(app)
migrate.init_app(app, db)
from app.api import api
bp = Blueprint('api', __name__)
api.init_app(bp)
app.register_blueprint(bp, url_prefix='/api')
return app
def setup_api():
blueprint = setup_api.__dict__.get('blueprint')
if blueprint:
return blueprint
blueprint = setup_api.__dict__['blueprint'] = Blueprint('api', __name__)
api.init_app(blueprint)
setup_tickets_endpoint()
setup_tasks_endpoint()
return blueprint
def create_app(environemnt):
"""
App factory for the server.
Instantiates a Flask object.
Configures the app according to the environment.
Initializes the extensions.
Adds the middleware to check headers.
Returns the app instance.
:param: environment
Environemnt to configure the server to
:returns:
Instance of the flask app
"""
app = Flask(__name__)
app.config.from_object(cfg_map[environemnt])
db.init_app(app)
cors.init_app(app, resources={r"/*": {"origins": "*"}})
bcrypt.init_app(app)
migrate.init_app(app, db)
from app.api import api
api.init_app(app)
from app.api.auth.models import Token # noqa: F401
from app.api.sentiment.models import Sentiment # noqa: F401
from app.api.users.models import User # noqa: F401
@app.before_request
def check_headers():
if (
"swagger" not in request.path
and "admin" not in request.path
and request.method != "OPTIONS"
):
accepts = request.headers.get("Accept")
if not accepts or accepts != "application/json":
abort(415, "Only content type supported is application/json")
if request.method in ["POST", "PUT"]:
content_type = request.headers.get("Content-Type")
if not content_type or content_type != "application/json":
abort(
415,
"POST/PUT requests should define Content-Type header",
)
return app
def create_app(env='DEV'):
"""创建app"""
app = Flask('OPERA_API', static_folder=DevConfig.STATIC_URL)
if env == 'DEV':
CORS(app) # 跨域支持
app.config.from_object(DevConfig)
elif env == 'PROD':
app.config.from_object(ProdConfig)
elif env == 'TEST':
app.config.from_object(TestConfig)
jwt = JWTManager(app)
BindJwt.init(jwt) # 初始化jwt-auth
db.init_app(app) # 初始化MYSQL数据库
mongo.init_app(app) # 初始化MONGO数据库
api.init_app(app) # 绑定restful api
return app
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
flask_logger = create_logger(app)
if not app.debug and not app.testing:
if not os.path.exists(Config.LOG_FOLDER):
os.mkdir(Config.LOG_FOLDER)
file_handler = RotatingFileHandler(Config.LOG_FILE, maxBytes=10240, backupCount=10)
file_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
file_handler.setLevel(logging.INFO)
flask_logger.addHandler(file_handler)
flask_logger.setLevel(logging.INFO)
# app.logger.info('Upwbp startup')
with app.app_context():
api.init_app(app)
# from app import routes
return app
def create_app(script_info=None):
app = Flask(__name__)
app.url_map.strict_slashes = False
app_settings = os.getenv("APP_SETTINGS")
app.config.from_object(app_settings)
# register api
from app.api import api
api.init_app(app)
# shell context for flask cli
@app.shell_context_processor
def ctx():
return {"app": app}
return app
def create_app(test_config=None):
'''
This function creates and configures the application.
'''
app = Flask(__name__)
if test_config is None:
app.config.from_pyfile("config.py", silent=True)
else:
app.config.update(test_config)
app.config['RESTPLUS_VALIDATE'] = True
app.config['ERROR_404_HELP'] = False
blueprint = Blueprint('api', __name__)
api.init_app(blueprint)
app.register_blueprint(blueprint)
api.add_namespace(ns_default)
return app
def create_app(script_info=None):
# instantiate the app
app = Flask(__name__)
# set config
app_settings = os.getenv("APP_SETTINGS")
app.config.from_object(app_settings)
# set up extensions
db.init_app(app)
cors.init_app(app, resources={r"*": {"origins": "*"}})
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
logger.setLevel(logging.DEBUG)
handler = RotatingFileHandler('./logs/application.log', maxBytes=1024)
handler.setFormatter(formatter)
app.logger.addHandler(handler)
mail.init_app(app)
from .api.models.client_rating import ClientRating
from .api.models.message import Message
from .api.models.offer import Offer
from .api.models.orders import Orders
from .api.models.sharer_rating import SharerRating
from .api.models.tag import Tag
from .api.models.user import User
guard.init_app(app, User)
# register api
from app.api import api
api.init_app(app)
# shell context for flask cli
@app.shell_context_processor
def ctx():
return {"app": app, "db": db}
return app
def create_app():
"""Функция, реализующая паттерн Application Factory
(нужна для создания экземпляра приложения с нужной конфигурацией)"""
app = Flask(__name__)
app.config.from_object(f'app.config.{app.config["ENV"]}Config')
app.register_blueprint(main_bp)
app.register_blueprint(auth_bp)
app.register_blueprint(errors_bp)
init_logs(app)
ASSETS.init_app(app)
session.init_app(app)
db.init_app(app)
csrf.init_app(app)
cdn.init_app(app)
compress.init_app(app)
babel.init_app(app)
api.init_app(app)
login_manager.init_app(app)
TALISMAN.init_app(app, content_security_policy=CSP, force_https=False)
return app
def initialize_app(flask_app):
configure_app(flask_app)
blueprint = Blueprint('app', __name__, url_prefix='')
api.init_app(blueprint)
api.add_namespace(juggling_namespace)
flask_app.register_blueprint(blueprint)
from flask import Flask, Blueprint
from app.api import api
import os
basedir = os.path.dirname(os.path.abspath(__file__))
db_file = 'sqlite:///' + os.path.join(basedir, './db/born.db')
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = db_file
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
from app import tables
from app.api.born import ns as born_api
blueprint = Blueprint('api', __name__, url_prefix='/api')
api.init_app(blueprint)
api.add_namespace(born_api)
app.register_blueprint(blueprint)
def extensions(app):
""""""
db.init_app(app)
api.init_app(app)
def create_app() -> Flask: # pylint: disable=too-many-statements
"""
Flask Factory pattern.
Reference:
http://flask.pocoo.org/docs/1.0/patterns/appfactories/
"""
iguazu = Flask(__name__)
iguazu.url_map.strict_slashes = False
# Secret Key is required by Flask-Session.
iguazu.secret_key = config.SECRET
# Setting debug mode.
iguazu.debug = bool(config.DEBUG)
# Updating logger messages.
logging.basicConfig(level=config.LOG_LEVEL, format=config.LOG_FORMAT)
# Loading DB connector.
iguazu.config['MONGODB_DB'] = config.MONGO_NAME
iguazu.config['MONGODB_HOST'] = config.MONGO_HOST
iguazu.config['MONGODB_PORT'] = config.MONGO_PORT
iguazu.config['MONGODB_USERNAME'] = config.MONGO_USER
iguazu.config['MONGODB_PASSWORD'] = config.MONGO_PASS
mongo.init_app(iguazu)
# Loading login handler.
iguazu.config["JWT_SECRET_KEY"] = config.SECRET
iguazu.config["JWT_HEADER_NAME"] = config.JWT_HEADER_NAME
jwt.init_app(iguazu)
# Loading celery config.
celery.conf.update(iguazu.config)
iguazu.config["CELERY_RESULT_BACKEND"] = config.CELERY_RESULT_BACKEND
iguazu.config["CELERY_BROKER_URL"] = config.CELERY_BROKER_URL
def call(self, *args, **kwargs):
"""
Main call.
"""
with iguazu.app_context():
return self.run(*args, **kwargs)
celery.Task.__call__ = call
# Loading cache connector.
iguazu.config["REDIS_URL"] = config.REDIS_URI
redis.init_app(iguazu)
# Creating an admin.
# WARNING: This piece of code has been created for the demo.
# This user will be used for testing purposes.
if config.ADMIN_USER and config.ADMIN_PASS:
with iguazu.app_context():
logger.warning("Setting admin password.")
try:
admin = UsersController.create({
UsersController.USERNAME: config.ADMIN_USER,
UsersController.PASSWORD: config.ADMIN_PASS,
}, {})
except UsernameAlreadyTakenException:
logger.warning("Admin already exists!")
else:
logger.warning("Admin created! | sf_admin=%s", admin)
# Registering app views.
api.init_app(iguazu)
# End of app factory.
logger.info("App started!")
return iguazu
def create_app():
"""Factory pattern"""
# Create flask app
app = Flask(
__name__,
# template_folder='templates',
instance_path=str(pathlib.Path(__file__).parent.joinpath("instance")),
)
app.wsgi_app = ProxyFix(app.wsgi_app,
x_for=1,
x_proto=1,
x_host=1,
x_port=1)
app.config.from_object('app.config.DevelopmentConfig')
logging.basicConfig(level=logging.DEBUG)
# app.debug = True
# Initialize extensions
db.init_app(app) # SQLAlchemy
cors.init_app(app, resources={r"*": {"origins": "*"}})
bcrypt.init_app(app)
# Register api
from app.api import api
api.init_app(app)
# Build a sample db on the fly
app_dir = op.realpath(os.path.dirname(__file__))
database_path = op.join(app_dir, app.config['DATABASE_FILE'])
# if os.path.exists(database_path):
# os.remove(database_path)
# seed_db(app)
# shell context for flask cli
@app.shell_context_processor
def ctx():
return {'app': app, 'db': db}
# Flask views
@app.route('/')
def index():
# return """<a href="/admin/">Click here to get to the admin views</a>"""
return render_template_string("""
<html><body>
<a href="/admin/">Click here to get to the admin views</a><br>
<a href="/docs/">Click here to go to the API documentation</a>
</html></body>
""")
@app.route('/test/', methods=['GET', 'POST'])
def test():
return render_template('test.html')
@app.route('/hello/', methods=['GET', 'POST'])
def hello():
# POST request
if request.method == 'POST':
current_app.logger.debug('Incoming..')
current_app.logger.debug(request.get_json()) # parse as JSON
return 'OK', 200
# GET request
else:
message = {'greeting': 'Hello from Flask!'}
return message # serialize and use JSON headers
# Add the database 'models' (tables) to the admin page
from app.models import PowerUnit, PowerUnitMeta, User, MetaData
from app.admin import SecuredAdminIndexView, PowerUnitView, PowerUnitMetaView, UserView, MetaDataView
# Create admin interface
flask_adm = Admin(app,
name='IJACK',
template_mode='bootstrap3',
index_view=SecuredAdminIndexView(name='Admin',
url='/admin',
endpoint='admin'))
flask_adm.add_view(
UserView(User, db.session, name='Users', endpoint='admin.users'))
flask_adm.add_view(
PowerUnitView(PowerUnit,
db.session,
name='Power Units',
endpoint='admin.power_units'))
flask_adm.add_view(
PowerUnitMetaView(PowerUnitMeta,
db.session,
name='Power Unit Meta',
endpoint='admin.power_units_meta'))
flask_adm.add_view(
MetaDataView(MetaData,
db.session,
name='Meta Data',
endpoint='admin.meta_data'))
return app
def assign_plugins(app):
db.init_app(app)
cors.init_app(app)
guard.init_app(app, User)
api.init_app(app)
"%(asctime)s [%(threadName)-12.12s] [%(levelname)-5.5s] %(message)s",
handlers=[
logging.FileHandler("{0}/{1}.log".format('log', 'output')),
logging.StreamHandler()
])
app = Flask(__name__)
@app.route('/train')
def hello_world():
return render_template('train.html')
@app.route('/chatroom_employee')
def chatroom_employee():
return render_template('chatroom_employee.html')
@app.route('/chatroom_employer')
def chatroom_employer():
return render_template('chatroom_employer.html')
app.wsgi_app = ProxyFix(app.wsgi_app)
from app.api import api
api.init_app(app)
app.run(host='0.0.0.0', debug=False)
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
api.init_app(app)
return app
def initialize_app(flask_app):
configure_app(flask_app)
CORS(flask_app)
JWT(flask_app, authenticate, identity)
api.init_app(flask_app)
init_db()
def extensions(app):
"""An extension for typing the external instances to application instance"""
api.init_app(app)
db.init_app(app)
def init_ext(app):
api.init_app(app)
