SetupCommand, MessagePlaybackCommand, EventMigrationCommand)
app = create_app()
def _mk_ctx():
return dict(app=app,
db=db,
models=models,
services=services,
userdatastore=MongoEngineUserDatastore(db, models.User,
models.Role))
manager = Manager(app)
manager.add_command('run', Server(host='::'))
manager.add_command('shell', Shell(make_context=_mk_ctx))
manager.add_command('create_user', CreateUserCommand())
manager.add_command('delete_user', DeleteUserCommand())
manager.add_command('list_users', ListUsersCommand())
manager.add_command('add_userrole', AddUserRoleCommand())
manager.add_command('remove_userrole', RemoveUserRoleCommand())
manager.add_command('list_userroles', ListUserRolesCommand())
manager.add_command('list_roles', ListRolesCommand())
manager.add_command('add_role', AddRoleCommand())
manager.add_command('add_rolepermission', AddPermissionToRole())
manager.add_command('remove_rolepermission', RemovePermissionFromRole())
manager.add_command('list_rolepermissions', ListPermissionsOfRole())
manager.add_command('create_deployment', CreateDeploymentCommand())
from modules.apishop.models import ApishopOffer, ApishopCategory, ApishopConfig
from utils.filesys import delete_file_by_path, check_file_exists
for model in (Offer, Vendor, Category, Dispatcher, ApishopConfig,
ApishopOffer, ApishopCategory):
model.objects.delete()
import shutil
if check_file_exists('media', relative=True):
path = os.path.join(app.config['BASE_DIR'], 'media')
shutil.rmtree(path)
if check_file_exists('data', relative=True):
path = os.path.join(app.config['BASE_DIR'], 'data')
shutil.rmtree(path)
print 'Database cleared'
manager = Manager(app)
manager.add_command('server', Server(use_reloader=True, use_debugger=True))
manager.add_command('setup', Setup())
manager.add_command('cleardb', ClearDB())
collect = Collect()
collect.init_app(app)
collect.init_script(manager)
if __name__ == '__main__':
manager.run()
3) python manage.py db upgrade to apply detected changes in schema
4) python manage.py test to run unit tests
5) python manage.py shell to launch python shell with key modules imported
"""
from catalog import create_app
from flask.ext.script import Server, Manager, Shell
from flask.ext.migrate import Migrate, MigrateCommand
from catalog.model import User, Role, Item, Category
from catalog import model
from catalog import db
import os
# Configuration can be provided dynamically an environment variable
app = create_app(os.getenv('FLASK_CONFIG') or None)
manager = Manager(app)
server = Server(host='0.0.0.0', port=5000)
manager.add_command("runserver", server)
# Initializes Flask-Migrate extension to automatically handle
# modifications in schema
migrate = Migrate(app, db)
manager.add_command('db', MigrateCommand)
# Default imports available after launching the shell
def _make_context():
return dict(app=app, model=model, db=db, User=User, Role=Role,
Item=Item, Category=Category)
# Add command for detecting and running unit tests
@manager.command
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])
# Set the path
import os, sys
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from flask.ext.script import Manager, Server
from blog import app
manager = Manager(app)
#Tuen 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 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()
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)
@manager.option('-p', '--password', dest='password', required=True)
@manager.option('-e', '--email', dest='email', required=True)
def createuser(username=None, password=None, email=None):
password = generate_password_hash(password)
cmsuser = CmsUser(username=username, password=password, email=email)
db.session.add(cmsuser)
db.session.commit()
print 'cms user was created'
manager.add_command('runserver', Server())
if __name__ == '__main__':
manager.run()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from flask.ext.script import Manager, Server
from app import app
manager = Manager(app)
manager.add_command("runserver",
Server(host="127.0.0.1", port=5000, use_debugger=True))
if __name__ == '__main__':
manager.run()
from flask.ext.script import Manager, Server
from app import app
import config
from db_setup import dbs_exist, delete_dbs, create_dbs, populate_movie_db, populate_rating_db, create_moviedb_indexes, create_authdb_indexes, create_latest_recommendations_index, create_test_user
port = app.config['PORT']
server = Server(host="0.0.0.0", port=port)
manager = Manager(app)
manager.add_command("runserver", server)
@manager.command
def db_all():
"Delete and recreate Cloudant databases"
db_delete()
db_setup()
db_populate()
create_test_user()
@manager.command
def db_delete():
"Delete Cloudant databases"
delete_dbs()
@manager.command
def db_setup():
"Create Cloudant databases"
create_dbs()
#!/usr/bin/env python
#coding=utf-8
#date:2017/8/1
__author__ = 'fengfisher'
from flask.ext.script import Manager, Server
from app import app
manager = Manager(app)
manager.add_command("runserver",
Server(host='0.0.0.0', port=5000, use_debugger=True))
if __name__ == '__main__':
manager.run()
"""
idocument.manage
~~~~~~~~~~~~~~~~~~~~
This script provides some easy to use commands for
creating the database with or without some sample content.
You can also run the development server with it.
Just type `python manage.py` to see the full list of commands.
:copyright: (c) 2014 by the FlaskBB Team.
:license: BSD, see LICENSE for more details.
"""
import sys
from flask import current_app
from werkzeug.utils import import_string
from flask.ext.script import (Manager, Shell, Server, prompt, prompt_pass,
prompt_bool)
from application import app
manager = Manager(app)
# Run local server
manager.add_command("runserver", Server("0.0.0.0", port=8080))
if __name__ == "__main__":
manager.run()
SERVER = '//'.join(URL.split('//')[1:])
if ':' in SERVER:
PORT = int(SERVER.split(':')[-1])
elif 'PORT' in os.environ:
PORT = int(os.environ['PORT'])
manager = Manager(app)
if app.config['TYPE'] == 'localhost':
def json_serial(obj):
if isinstance(obj, datetime.timedelta):
return str(obj)
print "Config is : "
print json.dumps(app.config, default=json_serial, indent=2, sort_keys=True)
manager.add_command(
"runserver",
Server(use_debugger=True, use_reloader=True, host='0.0.0.0',
port=PORT))
else:
manager.add_command(
"runserver",
Server(use_debugger=False,
use_reloader=False,
host='0.0.0.0',
port=PORT))
if __name__ == "__main__":
manager.run()
if os.environ.get('FLASK_COVERAGE'):
import coverage
COV = coverage.coverage(branch=True, include='app/*')
COV.start()
app = create_app(os.getenv('FLASK_CONFIG') or 'default')
manager = Manager(app)
migrate = Migrate(app, db)
def make_shell_context():
return dict(app=app, models=models, db=db)
manager.add_command("runserver", Server(host="0.0.0.0", port=config[os.getenv('FLASK_CONFIG') or 'default'].PORT))
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)
Environment(app)
app.config.from_object('settings')
app.config.from_pyfile('settings_local.py', silent=True)
app.json_encoder = AppJSONEncoder
app.secret_key = app.config.get('SECRET_KEY')
cidadeiluminada.init_app(app)
return app
app = create_app()
migrate = Migrate(app, db)
_port = app.config['SERVER_PORT']
manager = Manager(app)
manager.add_command('db', MigrateCommand)
manager.add_command('runserver', Server(port=_port))
@app.route('/')
def index():
return redirect(url_for('protocolos.index'))
@app.context_processor
def menu_items():
return {
'menu_items': [(u'Protocolos', 'protocolos.index'),
(u'(ALPHA) Novo protocolo', 'protocolos.novo_pagina'),
(u'Gerenciar usuários', 'auth.gerenciar')]
}
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()
import os, sys
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from flask.ext.script import Manager, Server
from application import create_app
app = create_app()
manager = Manager(app)
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()
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
import sys
# If we're runing the server we need to monkey patch on app initializion
if 'runserver' in sys.argv:
os.environ['PSYCOGREEN'] = 'true'
from flask.ext.script import Manager, Shell, Server
from mailflow.front import app, models, db
from mailflow.commands import InitDB, Deliver, GeventServer
manager = Manager(app)
manager.add_command('runserver', GeventServer())
manager.add_command('runblocking', Server())
manager.add_command(
'shell', Shell(make_context=lambda: dict(app=app, db=db, models=models)))
manager.add_command('initdb', InitDB())
manager.add_command('deliver', Deliver())
if __name__ == "__main__":
manager.run()
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!'
from warnings import warn
from flask.ext.migrate import MigrateCommand
from flask.ext.script import Manager, Server, prompt_pass
from home import create_app, db
from home.collect.loop import collect as rfxcom_collect
from home.dash.models import User
from home.webcam.loop import collect as webcam_collect
app = create_app()
manager = Manager(app, with_default_commands=False)
manager.add_command('db', MigrateCommand)
manager.add_command("dashboard", Server(host='0.0.0.0', use_debugger=False,
use_reloader=False))
@manager.option('--device', help='Serial device.')
def rfxcom(device):
"""Start the event loop to collect data from the serial device."""
# If the device isn't passed in, look for it in the config.
if device is None:
device = app.config.get('DEVICE')
# If the device is *still* none, error.
if device is None:
print("The serial device needs to be passed in as --device or "
"set in the config as DEVICE.")
return
# -*- 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()
manager = Manager(create_app)
@manager.command
def test():
"""Run tests"""
nose.run(argv=["-w ."])
@manager.command
def dumpconfig():
"""Dumps config"""
pprint.pprint(current_app.config)
manager.add_option("-c", "--config",
dest="config",
help="config file",
required=False)
manager.add_option("-d", "--debug",
dest="debug",
help="run in debug mode",
default=False)
manager.add_command("runservernoreload", Server(use_reloader=False))
manager.add_command("urls", ShowUrls())
manager.add_command("clean", Clean())
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()
import os
from flask.ext.script import Manager, Server
from flask.ext.migrate import Migrate, MigrateCommand
from app import app, db
app.config.from_object(os.environ['APP_SETTINGS'])
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
manager.add_command(
"runserver",
Server(host=os.getenv('IP', '0.0.0.0'),
port=int(os.getenv('PORT', 5000))
# port = 5000
))
if __name__ == '__main__':
manager.run()
#!/usr/bin/env python
import os
from app import create_app, celery
from flask.ext.script import Server, Manager
application = create_app(os.getenv('FLASK_CONFIG') or 'default')
manager = Manager(application)
manager.add_command("runserver", Server(port=9001))
if __name__ == '__main__':
manager.run()
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')
def db_upgrade(rev):
import os
import sys
import logging
from flask.ext.script import Manager, Server
from triager import app
from triager.schedulers import RetrainScheduler
manager = Manager(app)
manager.add_command('runserver', Server(host='0.0.0.0'))
manager.add_command('runscheduler', RetrainScheduler())
# Setup logging
log_file = 'app.log'
if 'runscheduler' in sys.argv:
log_file = 'scheduler.log'
logging.basicConfig(
format=app.config['LOG_FORMAT'], level=app.config['LOG_LEVEL'],
filename=os.path.join(app.config['LOG_DIR'], log_file)
)
if __name__ == '__main__':
manager.run()
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()
from fpage.app import create_app
from fpage.user.models import User
from fpage.settings import DevConfig, ProdConfig
from fpage.database import db
if os.environ.get("FPAGE_ENV") == 'prod':
app = create_app(ProdConfig)
else:
app = create_app(DevConfig)
manager = Manager(app)
TEST_CMD = "nosetests"
def _make_context():
'''Return context dict for a shell session so you can access
app, db, and the User model by default.
'''
return {'app': app, 'db': db, 'User': User}
@manager.command
def test():
'''Run the tests.'''
status = subprocess.call(TEST_CMD, shell=True)
sys.exit(status)
manager.add_command("server", Server())
manager.add_command("shell", Shell(make_context=_make_context))
manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
manager.run()
# e.g. running in Heroku
print 'No default env file'
if config is not None:
env.update(load_config(config))
os.environ.update(env)
return mim_create_app()
manager = Manager(create_app)
manager.add_option(
'-c',
'--config',
dest='config',
required=False,
help='Foreman-style env file that will be loaded into app\'s ENV')
manager.add_command('debug', Server(use_debugger=True))
manager.add_command('clean', Clean())
manager.add_command('database', database.manager)
@manager.command
def config():
"""Pretty prints the app's config"""
pprint.pprint(dict(current_app.config))
@manager.command
def imgur_auth():
"""Run the initial Imgur auth flow"""
client_id = current_app.config['IMGUR_CLIENT_ID']
client_secret = current_app.config['IMGUR_CLIENT_SECRET']
