def create_app() -> Flask:
"""
Flask app factory
Creates an instance of a Flask application. Flask configuration options are used to enable various optional features
(such as logging to a file).
This method is used to load routes, CLI commands and blueprints that make up the Flask application.
:return: Flask application instance
"""
app = Flask(__name__)
app.config.from_object(_create_app_config())
if "LOGGING_LEVEL" in app.config:
app.logger.setLevel(app.config["LOGGING_LEVEL"])
flask_logging.default_handler.setFormatter(
Formatter(app.config["LOG_FORMAT"]))
if app.config["APP_ENABLE_FILE_LOGGING"]:
file_log = RotatingFileHandler(app.config["LOG_FILE_PATH"],
maxBytes=5242880,
backupCount=5)
file_log.setLevel(app.config["LOGGING_LEVEL"])
file_log.setFormatter(Formatter(app.config["LOG_FORMAT"]))
app.logger.addHandler(file_log)
if app.config["APP_ENABLE_SENTRY"]:
app.logger.info("Sentry error reporting enabled")
sentry_sdk.init(**app.config["SENTRY_CONFIG"])
app.logger.info(
f"{app.config['NAME']} ({app.config['VERSION']}) [{app.config['ENV']}]"
)
app.cli.add_command(version_cmd, "version")
data_cli_group = AppGroup("data", help="Interact with data sources.")
app.cli.add_command(data_cli_group)
data_cli_group.add_command(data_fetch_cmd, "fetch")
data_cli_group.add_command(data_validate_cmd, "validate")
airtable_cli_group = AppGroup("airtable",
help="Interact with Airtable service.")
app.cli.add_command(airtable_cli_group)
airtable_cli_group.add_command(airtable_status_cmd, "status")
airtable_cli_group.add_command(airtable_sync_cmd, "sync")
airtable_cli_group.add_command(airtable_reset_cmd, "reset")
return app
import click
from flask.cli import AppGroup
from variance.extensions import db
from variance.models.equipment import EquipmentModel
equipment_cli = AppGroup("equipment")
equipment_mod_cli = AppGroup("mod")
equipment_cli.add_command(equipment_mod_cli)
@equipment_cli.command("get")
@click.argument("name")
def cli_equipment_get(name):
u = EquipmentModel.query.filter_by(name=name).first()
if u is None:
click.echo("No equipment with that name found!")
return -1
click.echo("Equipment ID: %u" % u.id)
@equipment_cli.command("list")
def cli_equipment_list():
e_list = EquipmentModel.query.all()
if e_list is None:
click.echo("Equipment list is empty!")
return -1
for a in e_list:
click.echo("%u : %s - %s" % (a.id, a.name, a.description))
from flask.cli import AppGroup
from .hawk_api_request import hawk_api_request as hawk_api_request_command
cmd_group = AppGroup('generic', help='Generic commands')
cmd_group.add_command(hawk_api_request_command)
from flask.cli import AppGroup
from jobs.save_gsc import save_gsc
from jobs.load_gbq import load_gbq
from jobs.compress_gcs_data import compress_gcs_data
job = AppGroup('job')
job.add_command(save_gsc)
job.add_command(load_gbq)
job.add_command(compress_gcs_data)
import click
from flask.cli import AppGroup
from variance.extensions import db
from variance.models.nutrition import ConsumableModel
consumable_cli = AppGroup("consumable")
consumable_mod_cli = AppGroup("mod")
consumable_cli.add_command(consumable_mod_cli)
@consumable_cli.command("list")
def cli_consumable_list():
c_list = ConsumableModel.query.all()
if c_list is None:
click.echo("Consumable list is empty!")
return -1
for c in c_list:
click.echo(str(c))
@consumable_cli.command("view")
@click.argument("id")
def cli_consumable_view(id):
c = ConsumableModel.query.get(id)
if c is None:
click.echo("Could not find an consumable with that ID!")
return -1
click.echo(str(c))
import click
from flask.cli import AppGroup
from variance.extensions import db
from variance.models.gym import GymModel
from variance.models.equipment import EquipmentModel
gym_cli = AppGroup("gym")
gym_mod_cli = AppGroup("mod")
gym_cli.add_command(gym_mod_cli)
@gym_cli.command("list")
def cli_gym_list():
g_list = GymModel.query.all()
if g_list is None:
click.echo("Gym list is empty!")
return -1
for g in g_list:
click.echo(str(g))
@gym_cli.command("view")
@click.argument("id")
def cli_gym_view(id):
g = GymModel.query.get(id)
if g is None:
click.echo("Could not find a Gym with that ID!")
return -1
click.echo(str(g))
click.echo("\t'%s'" % (g.description))
import click
from flask.cli import AppGroup
from variance.extensions import db
from variance.models.permissions import PermissionModel
permissions_cli = AppGroup("perm")
permissions_mod_cli = AppGroup("mod")
permissions_cli.add_command(permissions_mod_cli)
@permissions_cli.command("get_action")
@click.argument("action")
def cli_permission_get_by_action(action):
p = PermissionModel.query.filter_by(action=action)
if p is None:
click.echo("No permissions with that action type found!")
return -1
for i in p:
click.echo(str(i))
@permissions_cli.command("list")
def cli_permission_list():
p = PermissionModel.query.all()
for i in p:
click.echo(str(i))
@permissions_cli.command("del")
@click.argument("perm_id")
from flask.cli import AppGroup
from jobs.save_sitemap import save_sitemap
from jobs.html_stats import html_stats
from jobs.save_to_gbq import save_to_gbq
job = AppGroup('job')
job.add_command(save_sitemap)
job.add_command(html_stats)
job.add_command(save_to_gbq)
# -*- coding: utf-8 -*-
from flask.cli import AppGroup
from tasks.task1 import task1_run
# グループを作成
task = AppGroup('task')
# task関連のコマンドを追加していく
task.add_command(task1_run)
import click
from flask.cli import AppGroup
from variance.extensions import db
from variance.models.exercise import ExerciseModel
exercise_cli = AppGroup("exercise")
exercise_mod_cli = AppGroup("mod")
exercise_cli.add_command(exercise_mod_cli)
@exercise_cli.command("list")
def cli_exercise_list():
e_list = ExerciseModel.query.all()
if e_list is None:
click.echo("Exercise list is empty!")
return -1
for e in e_list:
click.echo(str(e))
@exercise_cli.command("view")
@click.argument("id")
def cli_exercise_view(id):
e = ExerciseModel.query.get(id)
if e is None:
click.echo("Could not find an Exercise with that ID!")
return -1
click.echo(str(e))
click.echo("\t'%s'" % (e.description))
for q in e.equipment:
from flask.cli import AppGroup
from app.commands.dev.add_hawk_user import add_hawk_user as add_hawk_user_command
from app.commands.dev.datafiles_to_db_by_source import (
datafiles_to_db_by_source as datafiles_command, )
from app.commands.dev.datafiles_to_s3_by_source import datafiles_to_s3_by_source
from app.commands.dev.db import db as db_command
from app.commands.dev.dump_schema import dump_schema as dump_schema_command
from app.commands.dev.s3 import s3 as s3_command
from app.commands.dev.spire import populate_spire_schema as populate_spire_schema_command
cmd_group = AppGroup('dev', help='Commands to build database')
cmd_group.add_command(add_hawk_user_command)
cmd_group.add_command(datafiles_command)
cmd_group.add_command(datafiles_to_s3_by_source)
cmd_group.add_command(db_command)
cmd_group.add_command(s3_command)
cmd_group.add_command(dump_schema_command)
cmd_group.add_command(populate_spire_schema_command)
import click
from flask.cli import AppGroup
from variance.extensions import db
from variance.models.muscle import MuscleModel, MuscleGroupModel
muscle_cli = AppGroup("muscle")
muscle_group_cli = AppGroup("group")
muscle_mod_cli = AppGroup("mod")
muscle_cli.add_command(muscle_mod_cli)
muscle_cli.add_command(muscle_group_cli)
@muscle_cli.command("list")
def cli_muscle_list():
m_list = MuscleModel.query.all()
if m_list is None:
click.echo("Muscle list is empty!")
return -1
for m in m_list:
click.echo(str(m))
@muscle_group_cli.command("list")
def cli_muscle_group_list():
mg_list = MuscleGroupModel.query.all()
if mg_list is None:
click.echo("MuscleGroup list is empty!")
return -1
for g in mg_list:
click.echo(str(g))
from flask import Flask
from flask.cli import AppGroup
app = Flask(__name__)
def create_app():
return app
from .batches.send_mail import sendmail_run
job = AppGroup('job')
job.add_command(sendmail_run)
from flask.cli import AppGroup
from app.jobs.db_first_insert import db_first_insert_run
# グループを作成
job = AppGroup('job')
# task関連のコマンドを追加していく
job.add_command(db_first_insert_run)
import click
from apscheduler.schedulers.background import BlockingScheduler
from data_engineering.common.application import get_or_create
from flask.cli import AppGroup
from app.uploader.utils import mark_old_processing_data_files_as_failed
@click.command('start')
def start_scheduler():
"""Start the job scheduler"""
app = get_or_create()
sched = BlockingScheduler(daemon=True)
sched.add_job(mark_old_processing_data_files_as_failed,
'interval',
minutes=60,
kwargs=dict(app=app))
sched.start()
cmd_group = AppGroup('scheduler', help='Commands to manage the task scheduler')
cmd_group.add_command(start_scheduler)
"""Perform database admin tasks including migrations using Alembic.
"""
import logging
import sys
from flask import current_app
from flask.cli import AppGroup
import click
from . import migrate, pg
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
cli = AppGroup(name='db', help='Database Administration')
cli.add_command(migrate.cli)
cli.add_command(pg.cli)
@cli.command()
def create_all():
"""Create database and objects."""
logger.info('creating all')
current_app.extensions['sqlalchemy'].db.create_all()
@cli.command()
@click.confirmation_option(help='Are you sure you want to drop the db?')
def drop_all():
"""Drop all database objects (drop_all & create_all)."""
if click.confirm('Are you sure you want to drop all data?'):
from flask.cli import AppGroup
from jobs.task_helloworld import task_helloworld
from jobs.task_regist_slack import task_regist_slack
from jobs.task_slacklogging import task_slacklogging
from jobs.task_updt_slackmembers import task_updt_slackmembers
from jobs.task_updt_slackchannels import task_updt_slackchannels
from jobs.task_updt_slackdailylog import task_updt_slackdailylog
from jobs.task_slacklogging import task_slacklogging
# jobグループを作成
job = AppGroup('job')
# task関連のコマンドを追加していく
job.add_command(task_helloworld)
job.add_command(task_regist_slack)
job.add_command(task_slacklogging)
job.add_command(task_updt_slackmembers)
job.add_command(task_updt_slackchannels)
job.add_command(task_updt_slackdailylog)
job.add_command(task_slacklogging)
import click
from flask.cli import AppGroup
from variance.extensions import db
from variance.models.nutrition import NutrientInfoModel
nutrient_cli = AppGroup("nutrient")
nutrient_mod_cli = AppGroup("mod")
nutrient_cli.add_command(nutrient_mod_cli)
@nutrient_cli.command("list")
def cli_nutrient_list():
n_list = NutrientInfoModel.query.all()
if n_list is None:
click.echo("NutrientInfo list is empty!")
return -1
for n in n_list:
click.echo(str(n))
@nutrient_cli.command("view")
@click.argument("id")
def cli_nutrient_view(id):
n = NutrientInfoModel.query.get(id)
if n is None:
click.echo("Could not find an nutrient with that ID!")
return -1
click.echo(str(n))
import click
from flask.cli import AppGroup
from variance.extensions import db
from variance.models.unit import UnitModel
unit_cli = AppGroup("unit")
unit_mod_cli = AppGroup("mod")
unit_cli.add_command(unit_mod_cli)
@unit_cli.command("list")
def cli_unit_list():
u_list = UnitModel.query.all()
if u_list is None:
click.echo("Unit list is empty!")
return -1
for u in u_list:
click.echo(str(u))
@unit_cli.command("view")
@click.argument("id")
def cli_unit_view(id):
u = UnitModel.query.get(id)
if u is None:
click.echo("Could not find an unit with that ID!")
return -1
click.echo(str(u))
