def main():
app = init_app()
manager = Manager(app)
manager.add_command('seed', Seed())
# manager.add_command('import', ImportVisitors())
manager.run()
return app
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 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
class ServiceManager:
def __init__(self, service):
# create and attach a command manager for the service
self.commandManager = Manager(service.app)
self.service = service
@self.commandManager.command
def syncdb():
""" Create the database entries. """
# import the db module
from nautilus.db import db
# create all of the tables
db.create_all()
# notify the user
print("Successfully created database entries.")
@self.commandManager.command
def runserver(host = '127.0.0.1', port = 8000, debug = False, secretKey = 'supersecret'):
""" Start the service. """
service.run(host = host, port = int(port), debug = debug, secretKey = secretKey)
def run(self):
""" run the command manager """
try:
self.commandManager.run()
except KeyboardInterrupt:
print()
print("Cleaning up service...")
self.service.stop()
except Exception as err:
print("Closing due to error: %s" % err)
self.service.stop()
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_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 test_run_existing_bind_later(self):
manager = Manager(self.app)
stdout, code = run('manage.py simple', lambda: manager.run({'simple': SimpleCommand()}))
assert code == 0
assert 'OK' in stdout
def run_cli(): # pragma: no cover
app = create_base_app()
register_blueprints(app)
cli = Manager(app)
cli.add_command("db", MigrateCommand)
cli.run()
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 test_command_with_default_prompt(self, capsys):
manager = Manager(self.app)
@manager.command
def hello():
print(prompt(name='hello', default='romeo'))
@Catcher
def hello(msg):
if re.search("hello", msg):
return '\n' # just hit enter
with hello:
code = run('manage.py hello', lambda: manager.run())
out, err = capsys.readouterr()
assert 'hello [romeo]: romeo' in out
@Catcher
def hello_juliette(msg):
if re.search("hello", msg):
return 'juliette'
with hello_juliette:
code = run('manage.py hello', lambda: manager.run())
out, err = capsys.readouterr()
assert 'hello [romeo]: juliette' 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 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 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 main():
manager = Manager(create_app)
@manager.command
def show_routes():
print current_app.url_map
@manager.command
def db_populate():
user_admin = User(name='Administrator', username='******', password='******', email='*****@*****.**')
db.session.add(user_admin)
for i in range(1, 100):
report = Report(user=user_admin, name='My Report {}'.format(i))
db.session.add(report)
db.session.commit()
@manager.command
def db_create_all():
db.create_all()
@manager.command
def db_drop_all():
db.drop_all()
manager.run()
def test_without_default_commands(self):
manager = Manager(self.app, with_default_commands=False)
manager.set_defaults()
assert 'runserver' not in manager._commands
assert 'shell' not in manager._commands
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_with_default_commands(self):
manager = Manager(self.app)
manager.set_defaults()
assert 'runserver' in manager._commands
assert 'shell' in manager._commands
def test_command_decorator_with_additional_options(self, capsys):
manager = Manager(self.app)
@manager.option('-n', '--name', dest='name', help='Your name')
def hello(name):
print('hello ' + name)
assert 'hello' in manager._commands
code = run('manage.py hello --name=joe', lambda: manager.run())
out, err = capsys.readouterr()
assert 'hello joe' in out
code = run('manage.py hello -h', lambda: manager.run())
out, err = capsys.readouterr()
assert 'Your name' in out
@manager.option('-n', '--name', dest='name', help='Your name')
@manager.option('-u', '--url', dest='url', help='Your URL')
def hello_again(name, url=None):
if url:
print('hello ' + name + ' from ' + url)
else:
print('hello ' + name)
assert 'hello_again' in manager._commands
code = run('manage.py hello_again --name=joe', lambda: manager.run())
out, err = capsys.readouterr()
assert 'hello joe' in out
code = run('manage.py hello_again --name=joe --url=reddit.com', lambda: manager.run())
out, err = capsys.readouterr()
assert 'hello joe from reddit.com' in out
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 test_command_decorator_with_boolean_options(self, capsys):
manager = Manager(self.app)
@manager.command
def verify(verified=False):
'Checks if verified'
print('VERIFIED ? ' + 'YES' if verified else 'NO')
assert 'verify' in manager._commands
code = run('manage.py verify --verified', lambda: manager.run())
out, err = capsys.readouterr()
assert 'YES' in out
code = run('manage.py verify -v', lambda: manager.run())
out, err = capsys.readouterr()
assert 'YES' in out
code = run('manage.py verify', lambda: manager.run())
out, err = capsys.readouterr()
assert 'NO' in out
code = run('manage.py verify -h', lambda: manager.run())
out, err = capsys.readouterr()
assert 'Checks if verified' in out
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 test_command_decorator_with_options(self, capsys):
manager = Manager(self.app)
@manager.command
def hello(name='fred'):
'Prints your name'
print('hello ' + name)
assert 'hello' in manager._commands
code = run('manage.py hello --name=joe', lambda: manager.run())
out, err = capsys.readouterr()
assert 'hello joe' in out
code = run('manage.py hello -n joe', lambda: manager.run())
out, err = capsys.readouterr()
assert 'hello joe' in out
code = run('manage.py hello -h', lambda: manager.run())
out, err = capsys.readouterr()
assert 'Prints your name' in out
code = run('manage.py hello --help', lambda: manager.run())
out, err = capsys.readouterr()
assert 'Prints your name' in out
def test_run_not_existing(self):
manager = Manager(self.app)
stdout, code = run('manage.py simple', lambda: manager.run())
assert code == 2
assert 'OK' not in stdout
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_command_decorator_with_additional_options(self):
manager = Manager(self.app)
@manager.option('-n', '--name', dest='name', help='Your name')
def hello(name):
print 'hello', name
assert 'hello' in manager._commands
stdout, code = run('manage.py hello --name=joe', lambda: manager.run())
assert 'hello joe' in stdout
stdout, code = run('manage.py hello -h', lambda: manager.run())
assert 'Your name' in stdout
@manager.option('-n', '--name', dest='name', help='Your name')
@manager.option('-u', '--url', dest='url', help='Your URL')
def hello_again(name, url=None):
if url:
print 'hello', name, 'from', url
else:
print 'hello', name
assert 'hello_again' in manager._commands
stdout, code = run('manage.py hello_again --name=joe', lambda: manager.run())
assert 'hello joe' in stdout
stdout, code = run('manage.py hello_again --name=joe --url=reddit.com', lambda: manager.run())
assert 'hello joe from reddit.com' in stdout
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 test_run_no_name(self):
manager = Manager(self.app)
sys.argv = ["manage.py"]
try:
manager.run()
except SystemExit, e:
assert e.code == 1
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
import os
from flask.ext.script import Manager, Shell, Server
from flask_migrate import Migrate, MigrateCommand
from app import app
from app.core.db import db
manager = Manager(app)
migrate = Migrate(app, db)
def _make_context():
return {'app': app}
# Adding Shell Command
# python manage.py [arg]
manager.add_command('db', MigrateCommand)
manager.add_command('run', Server(host='0.0.0.0', port=9000))
manager.add_command('shell', Shell(make_context=_make_context))
if __name__ == '__main__':
manager.run()
from flask.ext.script import Server, Manager, Shell
from example import app, db
manager = Manager(app)
manager.add_command('runserver', Server())
manager.add_command('shell', Shell(make_context=lambda: {
'app': app,
'db': db
}))
if __name__ == '__main__':
manager.run()
from app import app
from app import db
from app import models
from flask.ext.script import Manager
from flask.ext.script import Shell
from flask.ext.script import Server
manager=Manager(app)
def make_shell():
return dict(app=app,db=db,message=models.Message)
manager.add_command('shell',Shell(make_context=make_shell))
manager.add_command('runserver',Server(
use_debugger=True,
use_reloader=True,
host='localhost',
port=5000
))
if __name__=='__main__':
manager.run()
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)
# Turn on debugger by default and reloader
manager.add_command("runserver", Server())
if __name__ == "__main__":
manager.run()
#coding=UTF-8
from __future__ import absolute_import
from flask.ext.script import Manager, Server
from flask.ext.migrate import MigrateCommand
from cidadeiluminada import create_app
from cidadeiluminada.manage import manager as cidadeiluminada_manager
app = create_app()
manager = Manager(app)
manager.add_command('ci', cidadeiluminada_manager)
manager.add_command('db', MigrateCommand)
manager.add_command('runserver', Server())
@manager.command
def instance_path():
from flask import current_app
return current_app.instance_path
if __name__ == '__main__':
manager.run()
#!/usr/bin/env python
from flask.ext.script import Manager, Command
from flask.ext.migrate import MigrateCommand
from app import create_app
from tasks import run_celery
from tests.command import PytestCommand
manager = Manager(create_app)
manager.add_option('-c', '--config', dest='config_file', required=False)
manager.add_command('db', MigrateCommand)
manager.add_command('test', PytestCommand)
manager.add_command('runcelery', Command(run_celery))
if __name__ == '__main__':
manager.run()
import os
import glob
import subprocess
import urllib.parse
import multiprocessing
from flask import url_for
from flask.ext.script import Server
from flask.ext.script import Manager
from sqlalchemy import text as sqla_text
from webservices.rest import app, db
from webservices.config import SQL_CONFIG
from webservices.common.util import get_full_path
manager = Manager(app)
# The Flask app server should only be used for local testing, so we default to
# using debug mode and auto-reload. To disable debug mode locally, pass the
# --no-debug flag to `runserver`.
manager.add_command('runserver', Server(use_debugger=True, use_reloader=True))
def execute_sql_file(path):
# This helper is typically used within a multiprocessing pool; create a new database
# engine for each job.
db.engine.dispose()
print(('Running {}'.format(path)))
with open(path) as fp:
cmd = '\n'.join(
[line for line in fp.readlines() if not line.startswith('--')])
#!/usr/bin/env python
from app import create_app, db
from app.models import User, Role
from config import config
from flask.ext.script import Manager, Shell
from flask.ext.migrate import MigrateCommand
import commands
manager = Manager(create_app)
manager.add_option("-c",
"--config",
dest="config_name",
required=False,
default=config['development'])
@manager.command
def test():
"""Run the unit tests"""
import unittest
tests = unittest.TestLoader().discover('tests')
unittest.TextTestRunner(verbosity=2).run(tests)
def make_shell_context():
return dict(app=create_app('development'), db=db, User=User, Role=Role)
# return dict(app=app, db=db, User=User, Follow=Follow, Role=Role,
#Permission=Permission, Post=Post, Comment=Comment)
#!flask/bin/python
from app import db, create_app
from flask.ext.script import Manager
from app.commands import CreateStaticData
manager = Manager(create_app)
@manager.command
def create_db():
db.create_all()
@manager.command
def drop_db():
db.drop_all()
@manager.command
def recreate_db():
drop_db()
create_db()
CreateStaticData().run()
manager.add_command('create_static_data', CreateStaticData())
manager.add_option('-c', '--config', dest='config', required=False)
if __name__ == '__main__':
manager.run()
from flask.ext.script import Manager, Server
from pyweb import app
manager = Manager(app)
# Turn on debugger by default and reloader
manager.add_command("runserver", Server(
use_debugger = True,
use_reloader = True,
host = '0.0.0.0')
)
if __name__ == "__main__":
manager.run()
from flask import Flask, render_template, request, redirect, url_for, abort
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.migrate import Migrate, MigrateCommand
from flask.ext.script import Manager
import datetime
import cloudinary.uploader
app = Flask(__name__)
app.config.from_object('punchstarter.default_settings')
db = SQLAlchemy(app)
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
from punchstarter.models import *
@app.route('/')
def hello():
projects = db.session.query(Project).order_by(
Project.time_created.desc()).limit(10)
return render_template('index.html', projects=projects)
@app.route('/projects/create/', methods=['GET', 'POST'])
def create():
if request.method == "GET":
return render_template('create.html')
from flask.ext.script import Manager
from flask.ext.migrate import Migrate, MigrateCommand
from flask.ext.assets import ManageAssets
from livereload import Server
from gather import create_app
from gather.extensions import db
app = create_app()
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command("db", MigrateCommand)
manager.add_command("assets", ManageAssets())
@manager.command
def create_all():
db.create_all()
@manager.command
def clear_cache():
from gather.extensions import cache
with app.app_context():
cache.clear()
@manager.command
def livereload():
db.create_all()
Fabrice,Le Fessant,[email protected] Mathieu,Lecarme,[email protected] Jonathan,MERCIER,[email protected] Bruno,Michel,[email protected] Gael,Pasgrimaud,[email protected] Julien,Pauli,[email protected] Rodolphe,Quiédeville,[email protected] Philippe,Robin,[email protected] Frank,Rousseau,[email protected] Romuald,Rozan,[email protected] Michael,Scherer,[email protected] Pierre,Schweitzer,[email protected] Basile,Starynkevitch,[email protected] Christophe,Villeneuve,[email protected]""" manager = Manager(create_app) @manager.shell def make_shell_context(): """ Updates shell. (XXX: not sure what this does). """ return dict(app=app, db=db) @manager.command def dump_routes(): """ Dump all the routes declared by the application. """
# coding:utf-8
# !/usr/bin/env python
import os
from app import create_app, db
from app.models import User, Role
from flask.ext.script import Manager, Shell
from flask.ext.migrate import Migrate, MigrateCommand
# 先创建程序。如果已定义环境变量 LOTUS_CONFIG ，则读取配置名；否则默认配置。
app = create_app(os.getenv('LOTUS_CONFIG') or 'default')
# 初始化 Flask-Script、Flask-Migrate 和为 Python shell 定义的上下文
manager = Manager(app)
migrate = Migrate(app, db)
# fixme
def make_shell_context():
return dict(app=app, db=db, User=User, Role=Role)
manager.add_command('shell', Shell(make_context=make_shell_context()))
manager.add_command('db', MigrateCommand)
print manager.command
# 启动单元测试命令 fixme
@manager.command
def test():
'''run the unit tests '''
import os
from flask.ext.script import Manager, Server
from narcissus.app import create_app
from narcissus.exts import db
app_root = os.path.dirname(os.path.abspath(__name__))
application = create_app('narcissus', os.path.join(app_root, 'development.conf'))
server = Server()
manager = Manager(application)
manager.add_command('runserver', server)
@manager.option('-c', dest='config', help='Config file',
default='development.conf')
@manager.option('-d', dest='destroy', help='Destroy database', default=False)
def create_db(config, destroy):
config_file = os.path.join(app_root, config)
application.config.from_pyfile(config_file)
with application.test_request_context():
if destroy:
db.drop_all()
from narcissus.master.model import Tag
from narcissus.album.model import Album, Image, Thumb
db.create_all()
print 'Created Database!'
import subprocess
from flask.ext.script import Manager, Server
from . import app
from .freezer import freezer
manager = Manager(app, with_default_commands=False)
manager.add_command('run', Server(host="0.0.0.0"))
@manager.command
def freeze(serve=False):
"""Freezes the static version of the website."""
if serve:
freezer.run(debug=True)
else:
urls = freezer.freeze()
print 'Built %i files.' % len(urls)
@manager.command
def up(destination):
print '### Freezing'
freeze()
print '### Uploading to', destination
subprocess.call(['rsync', '-Pah', '--del', freezer.root + '/', destination])
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("show-urls", ShowUrls())
manager.add_command('db', MigrateCommand)
@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()
from flask.ext.script import Manager
from flask import Flask
import sqlite3
from flask import request, render_template, jsonify, make_response, send_file
import numpy as np
import json
import time
k = 2
app = Flask(__name__)
manager = Manager(app)
def get_db():
db = sqlite3.connect('autoscaler_monitor.db')
db.row_factory = sqlite3.Row
return db
def query_db(query, args=(), one=False):
db = get_db()
cur = db.execute(query, args)
db.commit()
rv = cur.fetchall()
db.close()
return (rv[0] if rv else None) if one else rv
def get_log_db():
db = sqlite3.connect('log.db')
db.row_factory = sqlite3.Row
from pmg import app
from pmg.models.soundcloud_track import SoundcloudTrack
from flask.ext.script import Server, Manager
from flask.ext.migrate import MigrateCommand
app.debug = True
manager = Manager(app)
manager.add_command('runserver', Server(port=5000, threaded=True))
manager.add_command('db', MigrateCommand)
@manager.command
def sync_soundcloud():
SoundcloudTrack.sync()
if __name__ == '__main__':
manager.run()
import os
import datetime
from simplecoin import create_manage_app, db, currencies, powerpools, redis_conn
from simplecoin.scheduler import SchedulerCommand
from simplecoin.models import (Transaction, UserSettings, Credit, ShareSlice,
DeviceSlice, Block, CreditExchange)
from urlparse import urlparse
from flask import current_app, _request_ctx_stack
from flask.ext.migrate import stamp
from flask.ext.script import Manager, Shell, Server
from flask.ext.migrate import MigrateCommand
manager = Manager(create_manage_app)
@manager.option('-e', '--emit', help='prints the SQL that is executed',
action="store_true")
def init_db(emit=False):
""" Resets entire database to empty state """
if emit:
import logging
logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)
res = raw_input("You shouldn't probably ever do this in production! Are you"
" really, really sure you want to reset the DB {}? [y/n] "
.format(db.engine))
if res != "y":
return
from flask.ext.script import Manager
from flask.ext.migrate import Migrate, MigrateCommand
from config import SQLALCHEMY_DATABASE_URI
from run import application
from app.basemodels import db
migrate = Migrate(application, db)
manager = Manager(application)
manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
manager.run()
# -*- coding:utf-8 -*-
from flask.ext.script import Manager, Server
from app import app
from app import models
manager = Manager(app)
@manager.command
def save_todo():
todo = models.Todo(content="My first todo")
todo.save()
manager.add_command("runserver",
Server(host='127.0.0.1', port=5000, use_debugger=True))
if __name__ == "__main__":
manager.run()
# -*- coding: UTF-8 -*-
"""
Meieraha 2: Flask-Script manager script
See: http://flask-script.readthedocs.org/
Copyright 2015, Konstantin Tretyakov
License: MIT
"""
import logging, os, pkg_resources
from flask.ext.script import Manager
from meieraha2.app import create_app
from meieraha2.model import db, Dataset, MeieRahaVisualization, ConfigParameter
app = create_app()
manager = Manager(app)
@manager.shell
def shell_context():
from meieraha2 import model
return dict(app=app, model=model, db=model.db)
@manager.command
def runserver(log_config=None):
'Launch a debug server.'
if log_config is not None:
logging.config.fileConfig(log_config)
else:
logging.basicConfig(level=logging.DEBUG)
import os
import sys
from flask import current_app
from flask.ext.script import Manager,prompt,prompt_pass,\
prompt_bool,prompt_choices
from flask.ext.script import Server
from werkzeug import generate_password_hash, check_password_hash
from motiky import configs
from motiky.configs import db
from motiky import create_app
from motiky.logic.models import CmsUser
app = create_app(configs.ProductionConfig)
manager = Manager(app)
@manager.command
def create_all():
if prompt_bool("Are you sure? You will init your database"):
db.create_all()
@manager.command
def drop_all():
if prompt_bool("Are you sure? You will lose all your data!"):
db.drop_all()
@manager.option('-u', '--username', dest='username', required=True)
import os
from flask.ext.script import Manager, Server
from flask.ext.script.commands import ShowUrls, Clean
from flask.ext.migrate import Migrate, MigrateCommand
from app import create_app
from app.models import db
# default to dev config because no one should use this in
# production anyway
env = os.environ.get('APP_ENV', 'dev')
app = create_app('app.settings.%sConfig' % env.capitalize())
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command("server", Server())
manager.add_command("show-urls", ShowUrls())
manager.add_command("clean", Clean())
manager.add_command("db", MigrateCommand)
@manager.command
def createdb():
""" Creates a database with all of the tables defined in
your SQLAlchemy models
"""
db.create_all()
class CreateDBCommand(Command):
'Create DB and tables'
def run(self, alembic_ini=None):
if flask.current_app.config['SQLALCHEMY_DATABASE_URI'].startswith(
'sqlite'):
# strip sqlite:///
datadir_name = os.path.dirname(
flask.current_app.config['SQLALCHEMY_DATABASE_URI']
[len('sqlite:///'):])
if not os.path.exists(datadir_name):
os.makedirs(datadir_name)
db.create_all()
class DropDBCommand(Command):
'Drop DB tables'
def run(self):
db.drop_all()
manager = Manager(app)
manager.add_command('create_db', CreateDBCommand())
manager.add_command('drop_db', DropDBCommand())
if __name__ == '__main__':
manager.run()
#local settings should be ignored by git
try:
from local_settings import LocalConfig
except ImportError:
LocalConfig = None
if os.environ.get("ENFERNO_ENV") == 'prod':
app = create_app(ProdConfig)
elif LocalConfig :
app = create_app(LocalConfig)
else:
app = create_app(DevConfig)
manager = Manager(app)
def _make_context():
"""Return context dict for a shell session so you can access
app default.
"""
return {'app': app}
manager.add_command('server', Server())
manager.add_command('shell', Shell(make_context=_make_context))
manager.add_command('create_user', CreateUserCommand())
manager.add_command('add_role', AddRoleCommand())
manager.add_command('remove_role', RemoveRoleCommand())
""" use 'python manage.py run' command to run up application in development environment"""
import os
from flask.ext.script import Manager
from photophile import app
from photophile.database import session, User, Category, Base
manager = Manager(app)
@manager.command
def run():
port = int(os.environ.get('PORT', 8080))
app.run(host='0.0.0.0', port=port)
if __name__ == "__main__":
manager.run()
# -*- coding: utf-8 -*-
import subprocess
from flask.ext.script import Manager, Server
from appl import create_app
from appl.configs.development import DevelopmentConfig
app = create_app(DevelopmentConfig)
manager = Manager(app)
# ** The Flask-Script will override app.config['DEBUG']
_USE_DEBUGGER = app.debug
# Run local server
manager.add_command(
"runserver", Server(host='localhost',
port=5000,
use_debugger=_USE_DEBUGGER))
@manager.command
def init():
p = subprocess.call(['alembic', 'init', 'alembic'])
@manager.option('-t', '--tag', dest='tag', default='upgrade')
def db_rev(tag):
p = subprocess.call(['alembic', 'revision', '--autogenerate', '-m', tag])
@manager.option('-r', '--revision', dest='rev', default='head')
from flask.ext.script import Server, Manager, prompt_bool
# from myapp import app
from apps import app
manager = Manager(app)
manager.add_command("runserver", Server('0.0.0.0', port=5001))
app.run(host='0.0.0.0', port=5001, debug=True)
if __name__ == "__main__":
manager.run()
