def test_run_with_default_command(self):
manager = Manager(self.app)
manager.add_command('simple', SimpleCommand())
try:
manager.run(default_command='simple')
except SystemExit, e:
assert e.code == 0
def main():
from gevent import monkey
monkey.patch_all()
import logging
from functools import partial
from flask.ext.script import Manager
from .web import create
from .commands import GeventServer, SocketIOServer
logging.basicConfig(level=logging.DEBUG)
logging.captureWarnings(True)
class Config(object):
DEBUG = True
SITE_TITLE = 'Mediasearch'
SECRET_KEY = 'secret'
configured_create = partial(
create,
config=Config(),
)
manager = Manager(configured_create)
manager.add_command('rungeventserver', GeventServer())
manager.add_command('runsocketioserver', SocketIOServer())
manager.run()
def test_run_with_default_command(self):
manager = Manager(self.app)
manager.add_command('simple', SimpleCommand())
stdout, code = run('manage.py', lambda: manager.run(default_command='simple'))
assert code == 0
assert 'OK' in stdout
def create_app(config):
app = Flask(__name__)
app.config.from_object(config)
from remedyblueprint import remedy, url_for_other_page
app.register_blueprint(remedy)
from admin import admin
admin.init_app(app)
from auth.user_auth import auth, login_manager
app.register_blueprint(auth)
login_manager.init_app(app)
# searching configurations
app.jinja_env.trim_blocks = True
# Register the paging helper method with Jinja2
app.jinja_env.globals['url_for_other_page'] = url_for_other_page
app.jinja_env.globals['logged_in'] = lambda : not current_user.is_anonymous()
db.init_app(app)
Migrate(app, db, directory=app.config['MIGRATIONS_DIR'])
manager = Manager(app)
manager.add_command('db', MigrateCommand)
# turning API off for now
# from api_manager import init_api_manager
# api_manager = init_api_manager(app, db)
# map(lambda m: api_manager.create_api(m), models)
return app, manager
def run():
iatidq.db.create_all()
iatidq.dqimporttests.hardcodedTests()
manager = Manager(iatidataquality.app)
server = Server(host='0.0.0.0')
manager.add_command("runserver", server)
manager.run()
def run_cli(): # pragma: no cover
app = create_base_app()
register_blueprints(app)
cli = Manager(app)
cli.add_command("db", MigrateCommand)
cli.run()
def main():
manager = Manager(create_app)
manager.add_option('-c', '--config', dest='config', required=False)
manager.add_command('routes', ShowUrls())
manager.add_command('send_talk_emails',
SendTalkEmails())
manager.add_command('send_speaker_emails',
SendSpeakerEmails())
manager.add_command('send_invitation_to_previous_speakers',
SendInvitationToPreviousSpeakers())
manager.add_command('rungunicorn', RunGunicorn())
@manager.command
def import_xml(filename):
pythonfosdem.tools.import_xml(filename)
@manager.command
def db_create():
db.create_all()
@manager.command
def db_drop():
db.drop_all()
@manager.command
def db_reset():
pythonfosdem.tools.reset_db()
manager.run()
def create_app():
from colorama import init
init()
from config import add_configs
app = add_configs(Flask(__name__))
from sqlalchemy_utils.functions import database_exists, create_database
if not database_exists(app.config.get('SQLALCHEMY_DATABASE_URI')):
create_database(app.config.get('SQLALCHEMY_DATABASE_URI'), encoding='utf8')
with app.app_context():
from models import db
db.init_app(app)
app.db = db
from models.oauth2 import oauth2_provider
oauth2_provider.init_app(app)
# import models
Migrate(app, db, directory='bin/migrations/')
mgr = Manager(app)
mgr.add_command('db', MigrateCommand)
return mgr
def create_app(config_name):
app = Flask(__name__)
app.debug = True
app.config.from_object(config[config_name])
config[config_name].init_app(app)
login_manager.init_app(app)
pagedown.init_app(app)
db = SQLAlchemy(app)
bootstrap = Bootstrap(app)
moment = Moment(app)
manager = Manager(app)
mail = Mail(app)
migrate = Migrate(app, db)
manager.add_command('db', MigrateCommand)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from .api_1_0 import api as api_1_0_blueprint
app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0')
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
return app
def test_get_usage(self):
manager = Manager(self.app)
manager.add_command('simple', SimpleCommand())
usage = manager.create_parser('manage.py').format_help()
assert 'simple command' in usage
def test_add_named_command(self):
manager = Manager(self.app)
manager.add_command(NamedCommand())
assert 'named' in manager._commands
assert isinstance(manager._commands['named'], NamedCommand)
def test_submanager_usage_and_help_and_description(self, capsys):
sub_manager = Manager(usage='sub_manager [--foo]',
help='shorter desc for submanager',
description='longer desc for submanager')
sub_manager.add_command('simple', SimpleCommand())
manager = Manager(self.app)
manager.add_command('sub_manager', sub_manager)
code = run('manage.py -h', lambda: manager.run())
out, err = capsys.readouterr()
assert code == 0
assert 'sub_manager [--foo]' not in out
assert 'shorter desc for submanager' in out
assert 'longer desc for submanager' not in out
code = run('manage.py sub_manager', lambda: manager.run())
out, err = capsys.readouterr()
assert code == 2
assert 'too few arguments' in err
code = run('manage.py sub_manager -h', lambda: manager.run())
out, err = capsys.readouterr()
assert code == 0
assert 'sub_manager [--foo]' in out
assert 'shorter desc for submanager' not in out
assert 'longer desc for submanager' in out
assert 'simple command' in out
code = run('manage.py sub_manager simple -h', lambda: manager.run())
out, err = capsys.readouterr()
assert code == 0
assert 'sub_manager [--foo] simple [-h]' in out
assert 'simple command' in out
def test_run_existing_command(self, capsys):
manager = Manager(self.app)
manager.add_command('simple', SimpleCommand())
code = run('manage.py simple', lambda: manager.run())
out, err = capsys.readouterr()
assert 'OK' in out
def create_app():
app = Flask(__name__)
auto = Autodoc(app)
cal = Calendar()
event = Event()
from open_event.views.views import app as routes
app.register_blueprint(routes)
migrate = Migrate(app, db)
db.init_app(app)
manager = Manager(app)
manager.add_command("db", MigrateCommand)
cors = CORS(app)
app.secret_key = "super secret key"
app.config.from_object("config.ProductionConfig")
app.config["UPLOADS_FOLDER"] = os.path.realpath(".") + "/static/"
app.config["FILE_SYSTEM_STORAGE_FILE_VIEW"] = "static"
app.config["STATIC_URL"] = "/static/"
app.config["STATIC_ROOT"] = "staticfiles"
app.config["STATICFILES_DIRS"] = (os.path.join(BASE_DIR, "static"),)
app.logger.addHandler(logging.StreamHandler(sys.stdout))
app.logger.setLevel(logging.ERROR)
admin_view = AdminView("Open Event")
admin_view.init(app)
admin_view.init_login(app)
return app, manager, db
def create_app():
auto = Autodoc(app)
cal = Calendar()
event = Event()
from open_event.views.views import app as routes
app.register_blueprint(routes)
migrate = Migrate(app, db)
db.init_app(app)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
cors = CORS(app)
app.secret_key = 'super secret key'
app.config.from_object('config.ProductionConfig')
# app.config.from_object('config.LocalSQLITEConfig')
app.config['UPLOADS_FOLDER'] = os.path.realpath('.') + '/static/'
app.config['FILE_SYSTEM_STORAGE_FILE_VIEW'] = 'static'
app.config['STATIC_URL'] = '/static/'
app.config['STATIC_ROOT'] = 'staticfiles'
app.config['STATICFILES_DIRS'] = (os.path.join(BASE_DIR, 'static'),)
app.logger.addHandler(logging.StreamHandler(sys.stdout))
app.logger.setLevel(logging.INFO)
# logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)
admin_view = AdminView("Open Event")
admin_view.init(app)
admin_view.init_login(app)
return app, manager, db
def migrate():
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
manager.run()
def test_run_catch_all(self):
manager = Manager(self.app)
manager.add_command('catch', CommandWithCatchAll())
stdout, code = run('manage.py catch pos1 --foo pos2 --bar', lambda: manager.run())
assert code == 0
assert "['pos1', 'pos2', '--bar']" in stdout
def create_manager(app):
manager = Manager(app)
manager.add_command('db', db_manager)
manager.add_command('user', user_manager)
manager.add_command('work', work_manager)
return manager
def test_global_option_value(self):
def create_app(config_name='Empty'):
print config_name
return self.app
manager = Manager(create_app)
manager.add_option('-c', '--config', dest='config_name', required=False, default='Development')
manager.add_command('simple', SimpleCommand())
assert isinstance(manager._commands['simple'], SimpleCommand)
stdout, code = run('manage.py simple', lambda: manager.run())
assert code == 0
assert 'Empty' not in stdout # config_name is overwritten by default option value
assert 'Development' in stdout
assert 'OK' in stdout
stdout, code = run('manage.py -c Before simple', lambda: manager.run())
assert code == 0
assert 'Before' in stdout
assert 'OK' in stdout
stdout, code = run('manage.py simple -c After', lambda: manager.run())
assert code == 0
assert 'After' in stdout
assert 'OK' in stdout
stdout, code = run('manage.py -c DoNotShow simple -c NewValue', lambda: manager.run())
assert code == 0
assert 'DoNotShow' not in stdout # first parameter is ignored
assert 'NewValue' in stdout # second on is printed
assert 'OK' in stdout
def main():
app = init_app()
manager = Manager(app)
manager.add_command('seed', Seed())
# manager.add_command('import', ImportVisitors())
manager.run()
return app
def test_get_usage_with_specified_usage(self):
manager = Manager(self.app, usage="hello")
manager.add_command("simple", SimpleCommand())
usage = manager.get_usage()
assert "simple simple command" in usage
assert "hello" in usage
def test_run_dynamic_options(self):
manager = Manager(self.app)
manager.add_command('simple', CommandWithDynamicOptions('Fred'))
stdout, code = run('manage.py simple', lambda: manager.run())
assert code == 0
assert 'Fred' in stdout
def test_run_with_default_command(self, capsys):
manager = Manager(self.app)
manager.add_command('simple', SimpleCommand())
code = run('manage.py', lambda: manager.run(default_command='simple'))
out, err = capsys.readouterr()
assert code == 0
assert 'OK' in out
def test_run_existing(self):
manager = Manager(self.app)
manager.add_command('simple', SimpleCommand())
stdout, code = run('manage.py simple', lambda: manager.run())
assert 0 == code
assert 'OK' in stdout
def test_run_good_options(self):
manager = Manager(self.app)
manager.add_command('simple', CommandWithOptions())
stdout, code = run('manage.py simple --name=Joe', lambda: manager.run())
assert code == 0
assert 'Joe' in stdout
def test_add_explicit_named_command(self):
manager = Manager(self.app)
manager.add_command(ExplicitNamedCommand())
name = ExplicitNamedCommand.name
assert name in manager._commands
assert isinstance(manager._commands[name], ExplicitNamedCommand)
def test_get_usage_with_specified_usage(self):
manager = Manager(self.app, usage='hello')
manager.add_command('simple', SimpleCommand())
usage = manager.create_parser('manage.py').format_help()
assert 'simple command' in usage
assert 'hello' in usage
def create_manager(app):
manager = Manager(app)
manager.add_command('db', db_manager)
manager.add_command('user', user_manager)
manager.add_command('import_greece', import_greece)
manager.add_command('role', role_manager)
manager.add_command('factsheet', factsheet_manager)
return manager
def test_run_catch_all(self, capsys):
manager = Manager(self.app)
manager.add_command('catch', CommandWithCatchAll())
code = run('manage.py catch pos1 --foo pos2 --bar', lambda: manager.run())
out, err = capsys.readouterr()
assert code == 0
assert "['pos1', 'pos2', '--bar']" in out
def test_run_catch_all(self):
manager = Manager(self.app)
manager.add_command("catch", CommandWithCatchAll())
sys.argv = ["manage.py", "catch", "pos1", "--foo", "pos2", "--bar"]
try:
manager.run()
except SystemExit, e:
assert e.code == 0
from FlaskBlog import create_app
from FlaskBlog import models
# Get the ENV from os_environ
env = os.environ.get('BLOG_ENV', 'dev')
# Create thr app instance via Factory Method
app = create_app('FlaskBlog.config.%sConfig' % env.capitalize())
# Init manager object via app object
manager = Manager(app)
# Init migrate object via app and db object
migrate = Migrate(app, models.db)
# Create some new commands
manager.add_command("server", Server(host='127.0.0.1', port=8089))
manager.add_command("db", MigrateCommand)
@manager.shell
def make_shell_context():
"""Create a python CLI.
return: Default import object
type: `Dict`
"""
return dict(app=app,
db=models.db,
User=models.User,
Post=models.Post,
Comment=models.Comment,
import os, signal, sys
import subprocess as sp
import werkzeug.serving
from werkzeug import import_string
from flask.ext.script import Manager
from flask.ext.assets import ManageAssets
import main
app = main.app
manager = Manager(app)
manager.add_command("assets", ManageAssets())
from config import db
@manager.command
def run_tornado(port=5000):
"""
Runs application under tornado.
"""
import script.serve_app_tornado as runner
signal.signal(signal.SIGINT, interrupt_handler)
_runner(runner, port)
@manager.command
def run_gevent(port=5000):
"""
Runs gevent server.
"""
import os, sys
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from flask.ext.script import Manager, Server
from flask.ext.migrate import MigrateCommand
from flask_blog import app
manager = Manager(app)
manager.add_command('db', MigrateCommand)
manager.add_command(
"runserver",
Server(use_debugger=True,
use_reloader=True,
host=os.getenv('IP', '0.0.0.0'),
port=int(os.getenv('PORT', 5000))))
if __name__ == '__main__':
manager.run()
gunicorn crail.wsgi
"""
import sys
import yaml
from .app import make_app
from .models import Card, City, Contract, Good, World, db
from flask.ext.assets import ManageAssets
from flask.ext.migrate import MigrateCommand
from flask.ext.script import Manager
from flask.ext.script.commands import InvalidCommand
from sqlalchemy.orm.exc import NoResultFound
#: Flask-Script CLI instance.
manager = Manager(make_app) # pylint: disable=invalid-name
manager.add_command('assets', ManageAssets)
manager.add_command('db', MigrateCommand)
@manager.option('filename')
def game(filename):
"""Import a YAML file of game data."""
with open(filename, 'r') as game_file:
contents = yaml.safe_load(game_file)
world_name = contents['name']
try:
world = World.query.filter_by(name=world_name).one()
except NoResultFound:
world = World(name=world_name)
db.session.add(world)
import os, sys
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from flask.ext.script import Manager, Server
from app import app
manager = Manager(app)
manager.add_command(
"runserver", Server(use_debugger=True, use_reloader=True, host='0.0.0.0'))
if __name__ == '__main__':
manager.run()
data_source = models.DataSource.create(name=name,
type=settings.CONNECTION_ADAPTER,
options=settings.CONNECTION_STRING)
print "Imported data source from settings (id={}).".format(data_source.id)
@data_sources_manager.command
def list():
"""List currently configured data sources"""
for ds in models.DataSource.select():
print "Name: {}\nType: {}\nOptions: {}".format(ds.name, ds.type, ds.options)
@data_sources_manager.command
def new(name, type, options):
"""Create new data source"""
# TODO: validate it's a valid type and in the future, validate the options.
print "Creating {} data source ({}) with options:\n{}".format(type, name, options)
data_source = models.DataSource.create(name=name,
type=type,
options=options)
print "Id: {}".format(data_source.id)
manager.add_command("database", database_manager)
manager.add_command("users", users_manager)
manager.add_command("import", import_manager)
manager.add_command("ds", data_sources_manager)
if __name__ == '__main__':
manager.run()
#!/usr/bin/env python
import os
from flask.ext.script import Manager, Server
from gcis import create_app
from gcis.models import db, User
# default to dev config because no one should use this in
# production anyway
env = os.environ.get('GCIS_ENV', 'dev')
app = create_app('gcis.settings.%sConfig' % env.capitalize(), env=env)
manager = Manager(app)
manager.add_command("server", Server())
@manager.shell
def make_shell_context():
""" Creates a python REPL with several default imports
in the context of the app
"""
return dict(app=app, db=db, User=User)
@manager.command
def createdb():
""" Creates a database with all of the tables defined in
your Alchemy models
"""
import os
from flask.ext.script import Manager, Server
from flask.ext.script.commands import ShowUrls
from flask.ext.migrate import Migrate, MigrateCommand
from webapp import create_app
from webapp.models import db, User, Post, Tag, Comment
# default to dev config
env = os.environ.get('WEBAPP_ENV', 'dev')
app = create_app('webapp.config.%sConfig' % env.capitalize())
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command("server", Server())
manager.add_command('db', MigrateCommand)
manager.add_command('show-urls', ShowUrls())
@manager.shell
def make_shell_context():
return dict(app=app, db=db, User=User, Post=Post, Tag=Tag, Comment=Comment)
if __name__ == "__main__":
manager.run()
def create_manager(app):
manager = Manager(app)
manager.add_command('send_mails', SendMails())
return manager
from app import create_app, db
from app.models import User, Role, Post, Category, Comment
from flask.ext.script import Manager, Shell
from flask.ext.migrate import Migrate, MigrateCommand
app = create_app(os.getenv('FLASK_CONFIG') or 'default')
manager = Manager(app)
migrate = Migrate(app, db)
def make_shell_context():
return dict(app = app, db = db, User = User, Role = Role, Post = Post, Category = Category, \
Comment = Comment)
manager.add_command("shell", Shell(make_context=make_shell_context))
manager.add_command('db', MigrateCommand)
@manager.command
def test(coverage=False):
"""Run the unit tests"""
if coverage and not os.environ.get('FLASK_COVERAGE'):
import sys
os.environ['FLASK_COVERAGE'] = '1'
os.execvp(sys.executable, [sys.executable] + sys.argv)
import unittest
tests = unittest.TestLoader().discover('tests')
unittest.TextTestRunner(verbosity=2).run(tests)
if COV:
COV.stop()
from security_monkey.common.route53 import Route53Service
from gunicorn.app.base import Application
from flask.ext.migrate import Migrate, MigrateCommand
from security_monkey.scheduler import run_change_reporter as sm_run_change_reporter
from security_monkey.scheduler import find_changes as sm_find_changes
from security_monkey.scheduler import audit_changes as sm_audit_changes
from security_monkey.backup import backup_config_to_json as sm_backup_config_to_json
from security_monkey.common.utils import find_modules
from security_monkey.datastore import Account
from security_monkey.watcher import watcher_registry
manager = Manager(app)
migrate = Migrate(app, db)
manager.add_command('db', MigrateCommand)
find_modules('watchers')
find_modules('auditors')
@manager.command
def drop_db():
""" Drops the database. """
db.drop_all()
@manager.option('-a',
'--accounts',
dest='accounts',
type=unicode,
basedir = os.path.abspath(os.path.dirname(__file__)) # 获取当前路径，用于后面指定数据库文件路径
app = Flask(__name__)
app.config['SECRET_KEY'] = 'hard to guess string' # 设置秘钥，防止表单受到CSRF攻击
# 程序使用数据库的URL必须保存到Flask配置对象的SQLALCHEMY_DATABASE_URI键
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(
basedir, 'data.sqlite') # 配置数据库URL到SQLALCHEMY_DATABASE_URI键中
app.config[
'SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True # 配置SQLALCHEMY_COMMIT_ON_TEARDWON键，每次请求结束之后都会自动提交数据库中的变动
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True # 狗书里没写，这个要自己加...
manager = Manager(app)
bootstrap = Bootstrap(app)
moment = Moment(app)
db = SQLAlchemy(app)
migrate = Migrate(app, db) #初始化应用程序和数据库
manager.add_command(
'db', MigrateCommand) #将MigrateCommand类附加到Flask-Script的manager对象上
app.config['MAIL_SERVER'] = 'smtp.163.com'
app.config['MAIL_PORT'] = 25
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = '******' # os.environ.get(xx)
app.config['MAIL_PASSWORD'] = '******' # 这里使用的是163的授权码 不是登录实际密码
# 这里的MAIL_USERNAME 为你的gmail邮箱
# 这里的MAIL_PASSWORD 为你的gmail密码，这是你的实际密码，
# 就是你登录gmail邮箱时用的密码，这和国内邮箱是有区别的
app.config['MAIL_DEBUG'] = True
app.config['FLASKY_MAIL_SUBJECT_PREFIX'] = '163.com'
app.config['FLASKY_MAIL_SENDER'] = '*****@*****.**'
app.config['FLASKY_ADMIN'] = '*****@*****.**'
mail = Mail(app)
#!venv/bin/python
from flask.ext.script import Manager
from flask.ext.migrate import Migrate, MigrateCommand
from bloks import app, db
from bloks.cmd import AddCommand
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
manager.add_command('add', AddCommand)
if __name__ == '__main__':
manager.run()
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
app = Flask(__name__)
app.config.from_object('config')
csrf = CsrfProtect(app)
db = SQLAlchemy(app)
celery = make_celery(app)
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
Mobility(app)
redis = StrictRedis(host=app.config.get('REDIS_HOST'),
port=app.config.get('REDIS_PORT'),
password=app.config.get('REDIS_PASSWORD'))
analytics.write_key = '2afEcXvTS827n9aLqcisLOjJH1XF83uB'
from app import models
from app import views
from commands import CeleryTasksCommand
#启动脚本
#!/usr/bin/env python
from app import create_app,db
from app.auth.models import User
from flask.ext.script import Manager,Shell
from flask.ext.migrate import Migrate,MigrateCommand
from flask_socketio import SocketIO,emit
app =create_app('default')
manager = Manager(app)
# socketio = SocketIO(app)
#def make_shell_context():
# return dict(app=app,db=db)
#manager.add_command("shell", Shell(make_context=make_shell_context()))
# Shell()启动一个Python shell。可以传进去一个make_context参数，这个参数必须是一个字典。
# 相当于引入很多包
# @socketio.on('connect')
# def test_conn():
# emit('my response',{'data':'have connected'})
#
# @socketio.on('message')
# def rece_mes(msg):
# print(msg)
migrate = Migrate(app,db)
manager.add_command('db',MigrateCommand) #add_commnd自定义SHELL指令,对应到相应的function
if __name__=='__main__':
# app.run()
# socketio.run(app)
manager.run()
#!/usr/bin/env python
import os
from flask.ext.script import Manager, Server
from flask.ext.script.commands import ShowUrls, Clean
from appname import create_app
from appname.models import db, User
# default to dev config because no one should use this in
# production anyway
env = os.environ.get('APPNAME_ENV', 'dev')
application = create_app('appname.settings.%sConfig' % env.capitalize(),
env=env)
manager = Manager(application)
manager.add_command("server", Server())
manager.add_command("show-urls", ShowUrls())
manager.add_command("clean", Clean())
@manager.shell
def make_shell_context():
""" Creates a python REPL with several default imports
in the context of the app
"""
return dict(app=app, db=db, User=User)
@manager.command
def createdb():
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask.ext.script import Manager, Server
from flask.ext.migrate import MigrateCommand
from config import config
from app import commands, create_app
if __name__ == "__main__":
server = Server(host="0.0.0.0", port=80)
app = create_app(config['default'])
manager = Manager(app)
manager.add_command("runserver", server)
manager.add_command("drop_db", commands.DropDB())
manager.add_command("create_db", commands.CreateDB())
manager.add_command('db', MigrateCommand)
manager.add_command('init_data', commands.InitData())
manager.run(default_command='runserver')
def test_run_existing_command(self):
manager = Manager(self.app)
manager.add_command("simple", SimpleCommand())
manager.handle("manage.py", "simple")
assert 'OK' in sys.stdout.getvalue()
def test_add_command(self):
manager = Manager(self.app)
manager.add_command("simple", SimpleCommand())
assert isinstance(manager._commands['simple'], SimpleCommand)
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from flask.ext.script import Manager, Server, Command
from coverage import coverage
manager = Manager(app.app)
class RunServer(Command):
def run(self):
app.init()
app.app.run(use_debugger=True, use_reloader=True, host='0.0.0.0')
manager.add_command('runserver', RunServer)
class RunTests(Command):
def run(self):
cov = coverage(branch=True, include=['app/*'])
cov.start()
app.init(MONGODB_SETTINGS={'DB': 'testing'},
TESTING=True,
CSRF_ENABLED=False)
test_loader = unittest.defaultTestLoader
test_runner = unittest.TextTestRunner()
test_suite = test_loader.discover('./tests')
def run():
manager = Manager(app)
manager.add_command('freeze', Freeze())
manager.run()
#!/usr/bin/env python
#coding=utf-8
import os
if os.path.exists('.env'):
print('Importing environment from .env...')
for line in open('.env'):
var = line.strip().split('=')
if len(var) == 2:
os.environ[var[0]] = var[1]
from app import create_app
from flask.ext.script import Manager, Shell
# ͨ¹ýÅäÖô´½¨ app
app = create_app(os.getenv('FLASK_CONFIG') or 'default')
manager = Manager(app)
def make_shell_context():
return dict(app=app)
manager.add_command("shell", Shell(make_context=make_shell_context))
@manager.command
def deploy():
"""Run deployment tasks."""
pass
if __name__ == '__main__':
manager.run()
def test_get_usage(self):
manager = Manager(self.app)
manager.add_command("simple", SimpleCommand())
assert "simple simple command" in manager.get_usage()
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
# Create thr app instance via Factory Method
app = create_app(config.__name__ + '.Config')
# Init manager object via app object
manager = Manager(app)
# Init migrate object via app and db object
migrate = Migrate(app, models.db)
# Create the new application manage commands as below
# Start the flask web server
manager.add_command("server", Server(host=CONF.host, port=CONF.server_port))
# Manage database migrate
manager.add_command("db", MigrateCommand)
# Show all mapper of route url
manager.add_command("show-urls", ShowUrls())
# Clean alll the file of .pyc and .pyo
manager.add_command("clean", Clean())
# Pack the static file
manager.add_command('assets', ManageAssets(assets_env))
@manager.shell
def make_shell_context():
"""Create a python CLI.
return: Default import object
# -*- coding: utf-8 -*-
import binascii
import os
from application import create_app
from application.models.base import db
from flask.ext.migrate import Migrate, MigrateCommand
from flask.ext.script import Manager, Server
from tools.command import BabelCommand
from tools.command import LookupCommand
PORT = 5000
app = create_app()
manager = Manager(app)
manager.add_command("runserver", Server(host="0.0.0.0", port=PORT))
# db migrate commands
# Run python manage.py db upgrade to upgrade database
# Run python manage.py db --help to get help
migrate = Migrate(app, db)
manager.add_command('db', MigrateCommand)
manager.add_command('lookup', LookupCommand)
manager.add_command('babel', BabelCommand)
# Flask-Script provide shell and runserver command by default.
# utilities
@manager.command
def dropdb():
#!/usr/bin/env python
import os
from flask.ext.script import Manager, Server
from flask.ext.script.commands import ShowUrls, Clean
from base import create_app
from base.extensions import db
# default to dev config because no one should use this in
# production anyway
env = os.environ.get('NEXT_FRONTEND_ENV', 'dev')
app = create_app('base.settings.%sConfig' % env.capitalize(), env=env)
manager = Manager(app)
manager.add_command("server", Server(host="0.0.0.0", port=8002))
manager.add_command("show-urls", ShowUrls())
manager.add_command("clean", Clean())
@manager.shell
def make_shell_context():
""" Creates a python REPL with several default imports
in the context of the app
"""
return dict(app=app, db=db, User=User)
if __name__ == "__main__":
manager.run()
# Import tornado for our tornado server.
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
# Import signal used to stop tornado with ctrl-c.
import signal
# Define a callback to stop the server.
def stop_tornado(signum, frame):
# Stop the loop.
IOLoop.instance().stop()
signal.signal(signal.SIGINT, stop_tornado)
# Create the HTTP server and WSGI Container.
http_server = HTTPServer(WSGIContainer(app))
# Listen on the port specified in the config.
http_server.listen(port)
# Start the loop.
IOLoop.instance().start()
# Add command for db migrations.
manager.add_command('db', MigrateCommand)
# Add the default runserver command for the application server
# we have specified.
manager.add_command('runserver', server)
# If it wasn't imported, but run directly.
if __name__ == "__main__":
# Run the script manager.
manager.run()
#!flask/bin/python
from flask.ext.script import Manager, Server
from app import app, db, models
import os
app.debug=True
manager = Manager(app)
@manager.command
def create_all():
db.create_all()
@manager.command
def create_user(nickname, email, password):
with app.app_context():
u = models.User()
u.nickname = nickname
u.password = password
u.email = email
db.session.add(u)
db.session.commit()
manager.add_command('runserver', Server(host='0.0.0.0', port=os.environ.get('PORT', 5000)))
if __name__ == '__main__':
manager.run()
from app import app, db
from flask.ext.script import Manager
from flask.ext.migrate import Migrate, MigrateCommand
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
manager.run()
import getpass
import hashlib
from flask.ext.script import Manager, Server
from nmapui import app
from nmapui.models import Users
manager = Manager(app)
manager.add_command(
"runserver",
Server(use_debugger=True, use_reloader=True, host='127.0.0.1', port=8080))
@manager.command
#@manager.option('-u', '--username', help='your username')
#@manager.option('-e', '--email', help='your email address')
def adduser(username, email):
rval = False
__p1 = getpass.getpass()
__p2 = getpass.getpass("Confirm password:"******"Error: password do not match"
if __name__ == "__main__":
manager.run()
