from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand
from app import app # we import the app object from the app module
from app import db
migrate = Migrate(app, db)
manager = Manager(
app
) # keeps track of all the commands and handles how they are called from the command line
manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
manager.run(
) # prepares your Manager instance to receive input from the command line.
#!/usr/bin/env python
# start script#######
import os
from app import create_app
from flask_script import Manager, Shell
app = create_app(os.getenv('FLASK_ENV') or 'default')
manage = Manager(app)
def make_shell_context():
return dict(app=app)
manage.add_command("shell", Shell(make_context=make_shell_context))
if __name__ == "__main__":
manage.run()
import os
from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand
from app import APP, DB
from user_db import *
from location_db import *
APP.config.from_object(os.environ['APP_SETTINGS'])
migrate = Migrate(APP, DB)
manager = Manager(APP)
manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
manager.run()
from flask_script import Manager
db_manager = Manager()
@db_manager.command
def init():
print('初始化成功')
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager
from app import create_app
application = create_app()
manager = Manager(application.app)
migrate = Migrate(application.app, application.db)
manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
manager.run()
# vim: set fileencoding=utf-8 :
from __future__ import absolute_import, print_function, unicode_literals
from flask_script import Manager, Server, Shell
import stethoscope.login.factory
manager = Manager(stethoscope.login.factory.create_app)
def main():
manager.add_command("runserver", Server())
manager.add_command("shell", Shell())
manager.run()
if __name__ == "__main__":
main()
# Copyright 2014 SolidBuilds.com. All rights reserved
#
# Authors: Ling Thio <*****@*****.**>
from datetime import datetime
from flask import Flask
from flask_mail import Mail
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager
from flask_sqlalchemy import SQLAlchemy
from flask_user import UserManager, SQLAlchemyAdapter
from flask_wtf.csrf import CSRFProtect, ValidationError
app = Flask(__name__) # The WSGI compliant web application object
db = SQLAlchemy() # Setup Flask-SQLAlchemy
manager = Manager(app) # Setup Flask-Script
csrf = CSRFProtect(app) # Setup CSRF Protection
csrf.init_app(app)
@app.errorhandler(ValidationError)
def handle_csrf_error(e):
return render_template('csrf_error.html', reason=e.description), 400
# Initialize Flask Application
def init_app(app, extra_config_settings={}):
# Read common settings from 'app/settings.py'
app.config.from_object('app.settings')
# Read environment-specific settings from 'app/local_settings.py'
try:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
from flask_script import Manager, Shell
from webapp import app, db, config_app, register_blueprints
from webapp.services import data_service as dts
reload(sys)
sys.setdefaultencoding('utf8')
manager = Manager(app, with_default_commands=False)
def _make_context():
return dict(app=app, db=db)
manager.add_command('shell', Shell(make_context=_make_context))
@manager.command
def test():
"""Run the unit tests."""
import unittest
tests = unittest.TestLoader().discover('tests')
unittest.TextTestRunner(verbosity=2).run(tests)
from flask_script import Manager
from lemur.constants import SUCCESS_METRIC_STATUS
from lemur.dns_providers.service import get_all_dns_providers, set_domains
from lemur.extensions import metrics
from lemur.plugins.base import plugins
manager = Manager(
usage=
"Iterates through all DNS providers and sets DNS zones in the database.")
@manager.command
def get_all_zones():
"""
Retrieves all DNS providers from the database. Refreshes the zones associated with each DNS provider
"""
print("[+] Starting dns provider zone lookup and configuration.")
dns_providers = get_all_dns_providers()
acme_plugin = plugins.get("acme-issuer")
for dns_provider in dns_providers:
try:
zones = acme_plugin.get_all_zones(dns_provider)
set_domains(dns_provider, zones)
except Exception as e:
print("[+] Error with DNS Provider {}: {}".format(
dns_provider.name, e))
set_domains(dns_provider, [])
status = SUCCESS_METRIC_STATUS
#!/usr/bin/env python3
import os
from app import create_app, db
from app.models import User, Role, Post
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager, Shell
app = create_app(os.getenv('BLOGZ_CONFIG') or 'default')
manager = Manager(app) #为flask框架提供命令行支持
migrate = Migrate(app, db)
def make_shell_context(): #导入实例和模型
return dict(app=app, db=db, User=User, Role=Role, Post=Post)
manager.add_command(
"shell", Shell(make_context=make_shell_context)) #挂接回调函数用于建立shell的上下文
manager.add_command('db', MigrateCommand) #用于支持命令行db操作
if __name__ == '__main__':
manager.run()
from app import flask_app
from flask_script import Manager, Shell
from flask_migrate import Migrate, upgrade, MigrateCommand
from app.models.auth import User, Role, Project
from app.models.envinfo import Database, App
from app.models.welllink import Baseline, Blstatus
from app.models.machine import Agreement, Machine, Credence, MachineGroub
from app import db
from flask import current_app
import click
manager = Manager(flask_app)
migrate = Migrate(flask_app, db)
def make_shell_context():
return dict(app=flask_app,
db=db,
User=User,
Project=Project,
Baseline=Baseline,
Database=Database,
Blstatus=Blstatus,
Role=Role)
manager.add_command("shell", Shell(make_context=make_shell_context))
manager.add_command('db', MigrateCommand)
@flask_app.cli.command()
def catch_errors(f):
@wraps(f)
def wrapped(*args, **kwargs):
try:
f(*args, **kwargs)
except (CommandError, RuntimeError) as exc:
log.error('Error: ' + str(exc))
sys.exit(1)
return wrapped
if Manager is not None:
MigrateCommand = Manager(usage='Perform database migrations')
else:
class FakeCommand(object):
def option(self, *args, **kwargs):
def decorator(f):
return f
return decorator
MigrateCommand = FakeCommand()
@MigrateCommand.option('-d',
'--directory',
dest='directory',
from flask_script import Manager, Server
from app import create_app
from extensions.sql_alchemy import sqldb
import dbmodels.data_center.location as loc
manager = Manager(lambda config_filename, config_options: create_app(config_filename, config_options))
manager.add_option('-cf', '--configuration-file', dest='config_filename', default=None)
manager.add_option('-co', '--configuration-options', dest='config_options', default=None)
server = Server(port=5000, use_debugger=True, use_reloader=True)
manager.add_command("runserver", server)
@manager.command
def create_db():
sqldb.create_all()
@manager.command
def clear_db():
sqldb.drop_all()
@manager.command
def init_db():
sqldb.drop_all()
sqldb.create_all()
@manager.command
"""Manage the database and some other items required to run the API
"""
import logging
from flask import url_for
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager # class for handling a set of commands
# models included so that migrate can build the database migrations
from auth_api import models # pylint: disable=unused-import
from auth_api import create_app
from auth_api.models import db
APP = create_app()
MIGRATE = Migrate(APP, db)
MANAGER = Manager(APP)
MANAGER.add_command('db', MigrateCommand)
@MANAGER.command
def list_routes():
output = []
for rule in APP.url_map.iter_rules():
options = {}
for arg in rule.arguments:
options[arg] = "[{0}]".format(arg)
methods = ','.join(rule.methods)
url = url_for(rule.endpoint, **options)
db = SQLAlchemy(web)
# Flask-Cache
cache = Cache(web, config={'CACHE_TYPE': 'simple'})
#
# # just use the migration script's app context when you import the models
# # http://stackoverflow.com/questions/33905706/flask-migrate-seemed-to-delete-all-my-database-data
# with web.app_context():
# from models import *
description = "Cobra v{0} ( https://github.com/wufeifei/cobra ) is a static code analysis system that automates the detecting vulnerabilities and security issue.".format(
VERSION)
manager = Manager(web, description=description)
host = config.Config('cobra', 'host').value
port = config.Config('cobra', 'port').value
port = int(port)
# CLI
from app.cli import report, repair, install, scan, statistic, pull
manager.add_command('start', Server(host=host, port=port, threaded=True))
manager.add_command('scan', scan.Scan())
manager.add_command('statistic', statistic.Statistic())
manager.add_command('install', install.Install())
manager.add_command('repair', repair.Repair())
manager.add_command('report', report.Report())
manager.add_command('pull', pull.Pull())
revisions = [
_parse_revision(os.path.join(migrations, filename))
for filename in os.listdir(migrations) if filename.endswith('.py')
]
max_revision = max(revisions)
db_version = int(version.version_num)
assert db_version == max_revision, "old database schema found: revision %d. please run '%s db upgrade' to upgrade to revision %d" % (
db_version, __file__, max_revision)
def command_app_context():
app.config.update(SQLALCHEMY_ECHO=False)
return app.app_context()
manager = Manager(init)
manager.add_option('-c',
'--config',
dest='configfile',
default='openmoves.cfg',
required=False)
manager.add_command("runserver", Server(use_debugger=True))
manager.add_command('db', MigrateCommand)
manager.add_command('add-user', AddUser(command_app_context, app_bcrypt))
manager.add_command('import-move', ImportMove(command_app_context))
manager.add_command('delete-move', DeleteMove(command_app_context))
manager.add_command('list-moves', ListMoves(command_app_context))
from flask_script import Manager
import os
from . import app
from scrapers import scrapers
cli = Manager(app)
@cli.command
def run_scrapers():
"""Run scrapers"""
scrapers()
@cli.command
def web():
"""Run the web server"""
port = int(os.environ.get('PORT', 5000))
debug = False if os.environ.get('FLASK_PROD') else True
app.run(host='0.0.0.0', debug=debug, port=port)
def main(create_app_func=None):
if not create_app_func:
from shortener_url.wsgi import create_app
create_app_func = create_app
class ServerWithGevent(Server):
help = description = 'Runs the Flask development server with Gevent WSGI Server'
def __call__(self, app, host, port, use_debugger, use_reloader,
threaded, processes, passthrough_errors, **kwargs):
#print("kwargs : ", kwargs)
#{'ssl_key': None, 'ssl_crt': None}
if use_debugger:
app = DebuggedApplication(app, evalex=True)
server = WSGIServer((host, port), app)
try:
print('Listening on http://%s:%s' % (host, port))
server.serve_forever()
except KeyboardInterrupt:
pass
env_config = config_from_env('SHORTURL_SETTINGS', 'shortener_url.settings.Prod')
manager = Manager(create_app_func,
with_default_commands=False)
#TODO: option de config app pour désactiver run counter
manager.add_option('-c', '--config',
dest="config",
default=env_config)
manager.add_command("shell", Shell())
if HAS_GEVENT:
manager.add_command("server", ServerWithGevent(
host = '0.0.0.0',
port=8081)
)
manager.add_command("debug-server", Server(
host = '0.0.0.0',
port=8081)
)
else:
manager.add_command("server", Server(
host = '0.0.0.0',
port=8081)
)
manager.add_command("config", ShowConfigCommand())
manager.add_command("urls", ShowUrlsCommand())
manager.add_command("assets", ManageAssets())
from flask_security import script
manager.add_command('auth-create-user', script.CreateUserCommand())
manager.add_command('auth-create-role', script.CreateRoleCommand())
manager.add_command('auth-add-role', script.AddRoleCommand())
manager.add_command('auth-remove-role', script.RemoveRoleCommand())
manager.add_command('auth-activate-user', script.ActivateUserCommand())
manager.add_command('auth-deactivate-user', script.DeactivateUserCommand())
manager.run()
def manage():
from whitebearbake import migrate
manager = Manager(app)
manager.add_command('db', MigrateCommand)
manager.run()
from flask_script import Manager, Server
from flask_migrate import Migrate, MigrateCommand
from webapp import app
from webapp.models import db, Users, Post, Tag, Comment
manager = Manager(app, db)
manager.add_command("server", Server())
manager.add_command('db', MigrateCommand)
@manager.shell
def make_shell_context():
return dict(app=app,
db=db,
User=Users,
Post=Post,
Tag=Tag,
Comment=Comment)
if __name__ == "__main__":
app.run(host='0.0.0.0', debug=True)
# db.create_all()
se.init_app(aj)
aj.config[
'SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:[email protected]:3306/aj1'
aj.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# 初始化数据库连接
db.init_app(app=aj)
# 初始化flask-login
login_manage.init_app(aj)
# form表单csrf
aj.config['CSRF_ENABLED'] = True
aj.config['SECRET_KEY'] = 'you-will-never-guess'
manage = Manager(app=aj)
# 使用flask_migrate,需绑定app db
migrate = Migrate(aj, db)
manage.add_command('db', MigrateCommand)
# @aj.before_request
# def is_login():
# print('12123312')
@aj.route('/', methods=['GET'])
def index():
return render_template('index.html')
from DB_Model.database_tester import database_tester
db_tester = database_tester()
db_tester.generate_fake_data()
db_tester = database_tester()
db_tester.generate_fake_data()
db_helper.dump_all_data()
migrate = Migrate(init_app, init_db)
manager = Manager(init_app)
manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
config = MyConfig()
debug_msg("**********************************************")
debug_msg(" tester main ver: " +
str(config.getConfig("version")))
debug_msg("**********************************************")
'''
from testing.day_controller_tester import day_controller_tester
day_controller_testing = day_controller_tester()
day_controller_testing.testing_get_date_object_from_string()
day_controller_testing.testing_get_date_object_from_id()
#!/usr/bin/env python
import sys
from flask_script import Manager
from flask_script.commands import InvalidCommand
from flask_migrate import MigrateCommand
from product_identifier.commands import (
GunicornServerCommand,
ListCommand,
)
from product_identifier.webapp import create_webapp
manager = Manager(create_webapp)
manager.add_option('-c', '--config', dest='config', required=False)
manager.add_command('runserver_gunicorn', GunicornServerCommand())
manager.add_command('db', MigrateCommand)
manager.add_command('list', ListCommand)
if __name__ == '__main__':
try:
manager.run()
except InvalidCommand, e:
print >> sys.stderr, e
sys.exit(1)
from flask import Flask
from flask_script import Manager
import config
server = Flask(__name__)
server.debug = config.DEBUG
manager = Manager(server)
if __name__ == "__main__":
manager.run()
from flask import Flask
from flask_script import Manager
DBManager = Manager()
@DBManager.command
def init():
print("DB inited")
@DBManager.command
def migrate():
print("DB migrated")
:copyright: (c) 2018 by Netflix Inc., see AUTHORS for more
:license: Apache, see LICENSE for more details.
.. moduleauthor:: Kevin Glisson <*****@*****.**>
"""
from flask_script import Manager
from sentry_sdk import capture_exception
from lemur.certificates.service import get_expiring_deployed_certificates
from lemur.constants import SUCCESS_METRIC_STATUS, FAILURE_METRIC_STATUS
from lemur.extensions import metrics
from lemur.notifications.messaging import send_expiration_notifications, \
send_expiring_deployed_certificate_notifications
from lemur.notifications.messaging import send_authority_expiration_notifications
from lemur.notifications.messaging import send_security_expiration_summary
manager = Manager(usage="Handles notification related tasks.")
@manager.option(
"-e",
"--exclude",
dest="exclude",
action="append",
default=[],
help="Common name matching of certificates that should be excluded from notification",
)
@manager.option(
"-d",
"--disabled-notification-plugins",
dest="disabled_notification_plugins",
action="append",
#!/usr/bin/env python # manage.py supports the application factory pattern from flask_script import Manager from flack import create_app, db manager = Manager(create_app) @manager.command def create_db(drop_first=False): """Creates the database.""" if drop_first: db.drop_all() db.create_all() if __name__ == '__main__': manager.run()
import os
import unittest
from app import blueprint
from flask_script import Manager
from app.main import create_app
app = create_app(os.getenv('BOILERPLATE_ENV') or 'dev')
app.register_blueprint(blueprint)
app.app_context().push()
api = Manager(app)
@api.command
def run():
app.run()
@api.command
def test():
"""Runs the unit tests."""
tests = unittest.TestLoader().discover('app/test', pattern='test*.py')
result = unittest.TextTestRunner(verbosity=2).run(tests)
if result.wasSuccessful():
return 0
return 1
#!/usr/bin/env python
import os
from flask_script import Manager, Shell
# from flask_migrate import Migrate, MigrateCommand
from app import create_app, db
print os.getenv('FLASKCONFIG')
app = create_app(os.getenv('FLASKCONFIG') or 'default')
manager = Manager(app)
# migrate = Migrate(app, db)
def make_shell_context():
return dict(app=app, db=db)
manager.add_command('shell', Shell(make_context=make_shell_context))
# manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
manager.run()
import os
from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand
from student_directory import student_app
from student_directory import db
student_app.config.from_object(os.environ.get('app_env'))
manager = Manager(student_app)
migrate = Migrate(student_app, db)
manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
manager.run()
