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 test_call(self):
# Setup the webassets.script with a mock main() function,
# so we can check whether our call via Flask-Script actually
# goes through.
def dummy_main(argv, *a, **kw):
self.last_script_call = argv
return 0
from webassets import script
old_main = script.main
script.main = dummy_main
try:
mgmt = Manager(self.app)
mgmt.add_command('assets', ManageAssets(self.env))
try:
# -h is a great test as that is something Flask-Script might
# want to claim for itself.
sys.argv = ['./manage.py', 'assets', '-h']
mgmt.run()
except SystemExit:
# Always raised, regardless of success or failure of command
pass
assert self.last_script_call == ['-h']
finally:
script.main = old_main
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_existing_bind_later(self):
manager = Manager(self.app)
sys.argv = ["manage.py", "simple"]
try:
manager.run({'simple':SimpleCommand()})
except SystemExit, e:
assert e.code == 0
def test_run_not_existing(self):
manager = Manager(self.app)
sys.argv = ["manage.py", "simple"]
try:
manager.run()
except SystemExit, e:
assert e.code == 1
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
def test_command_with_custom_handle_method(self):
manager = Manager(self.app)
manager.add_command("handle", CommandWithCustomHandle())
sys.argv = ["manage.py", "handle", "pos1", "pos2", "--bar"]
try:
manager.run()
except SystemExit, e:
assert e.code == 0
def test_run_existing(self):
manager = Manager(self.app)
manager.add_command("simple", SimpleCommand())
sys.argv = ["manage.py", "simple"]
try:
manager.run()
except SystemExit, e:
assert e.code == 0
def test_run_good_options(self):
manager = Manager(self.app)
manager.add_command("simple", CommandWithOptions())
sys.argv = ["manage.py", "simple", "--name=Joe"]
try:
manager.run()
except SystemExit, e:
assert e.code == 0
def test_run_dynamic_options(self):
manager = Manager(self.app)
manager.add_command("simple", CommandWithDynamicOptions('Fred'))
sys.argv = ["manage.py", "simple"]
try:
manager.run()
except SystemExit, e:
assert e.code == 0
def test_command_decorator_with_options(self):
manager = Manager(self.app)
@manager.command
def hello(name='fred'):
"Prints your name"
print "hello", name
assert 'hello' in manager._commands
manager.handle("manage.py", "hello", ["--name=joe"])
assert 'hello joe' in sys.stdout.getvalue()
manager.handle("manage.py", "hello", ["-n joe"])
assert 'hello joe' in sys.stdout.getvalue()
try:
manager.handle("manage.py", "hello", ["-h"])
except SystemExit:
pass
assert 'Prints your name' in sys.stdout.getvalue()
try:
manager.handle("manage.py", "hello", ["--help"])
except SystemExit:
pass
assert 'Prints your name' in sys.stdout.getvalue()
def test_command_decorator_with_boolean_options(self):
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
manager.handle("manage.py", "verify", ["--verified"])
assert 'YES' in sys.stdout.getvalue()
manager.handle("manage.py", "verify", ["-v"])
assert 'YES' in sys.stdout.getvalue()
manager.handle("manage.py", "verify", [])
assert 'NO' in sys.stdout.getvalue()
try:
manager.handle("manage.py", "verify", ["-h"])
except SystemExit:
pass
assert 'Checks if verified' in sys.stdout.getvalue()
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
manager.handle("manage.py", "hello", ["--name=joe"])
assert 'hello joe' in sys.stdout.getvalue()
try:
manager.handle("manage.py", "hello", ["-h"])
except SystemExit:
pass
assert "Your name" in sys.stdout.getvalue()
@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
manager.handle("manage.py", "hello_again", ["--name=joe"])
assert 'hello joe' in sys.stdout.getvalue()
manager.handle("manage.py", "hello_again",
["--name=joe", "--url=reddit.com"])
assert 'hello joe from reddit.com' in sys.stdout.getvalue()
def create_script():
manager = Manager(create_app, with_default_commands=True)
manager.add_option('-d', '--database', dest='database', required=False)
manager.add_command('populate', PopulateDB())
@manager.shell
def _make_context():
return dict(app=_request_ctx_stack.top.app, db=db, WTF=WTF)
return manager
def test_run_bad_options(self):
manager = Manager(self.app)
manager.add_command("simple", CommandWithOptions())
sys.argv = ["manage.py", "simple", "--foo=bar"]
try:
sys_stderr_orig = sys.stderr
sys.stderr = StringIO.StringIO()
manager.run()
except SystemExit, e:
assert e.code == 2
def test_simple_command_decorator(self):
manager = Manager(self.app)
@manager.command
def hello():
print "hello"
assert 'hello' in manager._commands
manager.handle("manage.py", "hello")
assert 'hello' in sys.stdout.getvalue()
def test_call_auto_env(self):
"""Regression test: Passing the environment to the ManageAssets command
is optional, it can be auto-detected."""
mgmt = Manager(self.app)
mgmt.add_command('assets', ManageAssets())
try:
# Used to raise an error due to the env not being properly set.
sys.argv = ['./manage.py', 'assets', 'rebuild']
mgmt.run()
except SystemExit:
# Always raised, regardless of success or failure of command
pass
def test_simple_command_decorator_with_pos_arg(self):
manager = Manager(self.app)
@manager.command
def hello(name):
print "hello", name
assert 'hello' in manager._commands
manager.handle("manage.py", "hello", ["joe"])
assert 'hello joe' in sys.stdout.getvalue()
def test_simple_command_decorator_with_pos_arg_and_options(self):
manager = Manager(self.app)
@manager.command
def hello(name, url=None):
if url:
assert type(url) is unicode
print "hello", name, "from", url
else:
assert type(name) is unicode
print "hello", name
assert 'hello' in manager._commands
manager.handle("manage.py", "hello", ["joe"])
assert 'hello joe' in sys.stdout.getvalue()
manager.handle("manage.py", "hello", ["joe", '--url=reddit.com'])
assert 'hello joe from reddit.com' in sys.stdout.getvalue()
def test_parse_templates(self):
"""Test the --parse-templates option.
"""
# Create a file in the app's templates directory
self.app.template_folder = self.path('templates')
self.create_files({
'templates/template.html': """
{% assets "in", output="output" %}
{{ ASSET_URL }}
{% endassets %}
""",
'in': "foo"
})
# Run the build command with --parse-templates, which should pick
# up the bundle we defined in above template.
mgmt = Manager(self.app)
mgmt.add_command('assets', ManageAssets(log=stdout_log))
mgmt.handle('test', 'assets', ['--parse-templates', 'build'])
assert self.exists('output')
def test_call(self):
# Setup the webassets.script with a mock main() function,
# so we can check whether our call via Flask-Script actually
# goes through.
test_inst = self
class DummyArgparseImplementation(GenericArgparseImplementation):
def run_with_argv(self, argv):
test_inst.last_script_call = argv
return 0
mgmt = Manager(self.app)
mgmt.add_command('assets',
ManageAssets(self.env, impl=DummyArgparseImplementation))
try:
# -h is a great test as that is something Flask-Script might
# want to claim for itself.
sys.argv = ['./manage.py', 'assets', '-h']
mgmt.run()
except SystemExit:
# Always raised, regardless of success or failure of command
pass
assert self.last_script_call == ['-h']
def test_call_auto_env(self):
"""Regression test: Passing the environment to the ManageAssets command
is optional, it can be auto-detected."""
mgmt = Manager(self.app)
mgmt.add_command('assets', ManageAssets())
try:
# Used to raise an error due to the env not being properly set.
sys.argv = ['./manage.py', 'assets', 'build']
mgmt.run()
except SystemExit:
# Always raised, regardless of success or failure of command
pass
def test_parse_templates(self):
"""Test the --parse-templates option.
"""
# Create a file in the app's templates directory
self.app.template_folder = self.path('templates')
self.create_files({
'templates/template.html': """
{% assets "in", output="output" %}
{{ ASSET_URL }}
{% endassets %}
""",
'in': "foo"
})
# Run the build command with --parse-templates, which should pick
# up the bundle we defined in above template.
mgmt = Manager(self.app)
mgmt.add_command('assets', ManageAssets(log=stdout_log))
mgmt.handle('test', 'assets', ['--parse-templates', 'build'])
assert self.exists('output')
def test_call(self):
# Setup the webassets.script with a mock main() function,
# so we can check whether our call via Flask-Script actually
# goes through.
test_inst = self
class DummyArgparseImplementation(GenericArgparseImplementation):
def run_with_argv(self, argv):
test_inst.last_script_call = argv
return 0
mgmt = Manager(self.app)
mgmt.add_command(
'assets', ManageAssets(self.env, impl=DummyArgparseImplementation))
try:
# -h is a great test as that is something Flask-Script might
# want to claim for itself.
sys.argv = ['./manage.py', 'assets', '-h']
mgmt.run()
except SystemExit:
# Always raised, regardless of success or failure of command
pass
assert self.last_script_call == ['-h']
import os
from flaskext.script import (Server, Manager)
from myapp import createApp
app = createApp()
manager = Manager(app)
#
# Here the manager should only be concerned with things related to managing.
# Leave the act of loading setting to be done within the app itself.
#
# We do use an environment setting to indicate the server should start in
# debug mode.
#
# Also note that virtualenv is required here.
#
if "MYAPP_DEBUG" not in os.environ or os.environ["MYAPP_DEBUG"] == "FALSE":
print("Starting server in production mode.")
print("Use 'fab start_dev_server' to start the dev server.")
manager.add_command("runserver", Server(port=8080, use_reloader=False))
else:
manager.add_command("runserver", Server(port=8080, use_reloader=True))
if __name__ == "__main__":
if "VIRTUAL_ENV" not in os.environ:
print("""
Virtualenv has not been activated.
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()
#!/usr/bin/env python2
from flaskext.script import Shell, Server, Manager
from dagcuss import app
from dagcuss import dynagraph
from dagcuss import initialise
manager = Manager(app)
@manager.command
def rundynagraph():
"Runs the Dynagraph zmq powered DAG layout server."
dynagraph.server()
@manager.command
def initdb(addtestuser=False, testrepliesnum=0):
("Initialises the database with the essential data and optionally some "
"test data")
initialise.database(bool(addtestuser), int(testrepliesnum))
manager.add_command("runserver", Server())
manager.add_command("shell", Shell())
if __name__ == "__main__":
manager.run()
from flask import Flask
from flaskext.babel import Babel
from flaskext.script import Manager
from fbgroup import facebook_group_widget
from fbgroup.management.update import UpdateCommand
app = Flask(__name__)
app.register_blueprint(facebook_group_widget, url_prefix='/fbgroup')
app.config.from_pyfile('settings.cfg')
app.config.from_envvar('WIDGETS_SETTINGS')
# i18n
babel = Babel(app)
# command-line management
manager = Manager(app)
manager.add_command('update', UpdateCommand())
if __name__ == "__main__":
manager.run()
from flask_sqlalchemy import SQLAlchemy
from flaskext.babel import Babel
from flaskext.cache import Cache
from flaskext.mail import Mail
from flaskext.script import Manager
from flask_collect import Collect
from .app import create_app
babel = Babel()
cache = Cache()
db = SQLAlchemy()
main = Mail()
manager = Manager(create_app)
manager.add_option("-c", "--config", dest="config", required=False)
collect = Collect()
collect.init_script(manager)
def config_extensions(app):
" Init application with extensions. "
cache.init_app(app)
db.init_app(app)
main.init_app(app)
collect.init_app(app)
config_babel(app)
import subprocess
from flaskext.script import Manager, Server
from . import app
from .freezer import freezer
manager = Manager(app, with_default_commands=False)
# I prefer shorter names
manager.add_command('run', Server())
@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='hako:http/exyr.org/htdocs/'):
"""Freezes and uploads the website."""
push = subprocess.Popen(['git', 'push'],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
print '### Freezing'
freeze()
print '### Uploading to', destination
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""jmoiron.net script/commands"""
from flaskext.script import Manager
from glob import glob
from misc import migrate
from jmoiron.app import app, db
script = Manager(app)
@script.command
def loadsql(dumpfile=None):
"""Reload the SQL database."""
if dumpfile is None:
try:
dumpfile = glob("*.sql")[-1]
except:
print "Could not find a dumpfile (*.sql) in CWD."
return
migrate.loaddb(dumpfile)
@script.command
def flushdb():
"""Flush the database."""
db.drop_collection('blog_post')
db.drop_collection('stream_entry')
db.drop_collection('stream_plugin')
from functools import partial
from flaskext.script import Manager, Server, Shell
from werkzeug import create_environ
from coqd.runner import main as coqd_main
from cockerel.webapp import app
from cockerel.utilities import new_app
from cockerel.models import db, schema
from cockerel.auth import principals
def _make_context():
return dict(app=new_app(app), db=db, models=schema)
manager = Manager(partial(new_app, app))
manager.add_command("shell", Shell(make_context=_make_context))
manager.add_command("runserver", Server())
manager.add_option('--serialize', action="store_true",
default=False, help="Serialize output to JSON")
@manager.command
def initdb():
# A request_context is required to use these helper functions
with new_app(app).request_context(create_environ()):
db.drop_all()
db.create_all()
readaction = schema.Action("read")
insertaction = schema.Action("insert")
deleteaction = schema.Action("delete")
from bookmark import app
from flaskext.script import Manager, Command
from bookmark.init import reset_all
manager = Manager(app)
class SyncDB(Command):
def run(self):
reset_all('sample.json')
manager.add_command('syncdb', SyncDB())
manager.run()
manage
~~~~~~
Set of useful management commands
:copyright: (c) 2012 by Roman Semirook.
:license: BSD, see LICENSE for more details.
"""
import code
from flaskext.script import Manager, Shell, Command, Option
from kit.helpers import MainAppHelper, BlueprintPackageFactory
app = MainAppHelper.get_instance()
manager = Manager(app)
class iShell(Shell):
"""Works with iPython >= 0.12"""
def run(self, no_ipython):
context = self.get_context()
if not no_ipython:
try:
from IPython.frontend.terminal.embed import InteractiveShellEmbed
ipython_shell = InteractiveShellEmbed()
return ipython_shell(global_ns=dict(), local_ns=context)
except ImportError:
pass
torrent_file_path = os.path.join(current_app.instance_path,
info_hash + '.torrent')
if os.path.isfile(torrent_file_path):
os.path.remove(torrent_file_path)
return True
def _read_torrent_file(torrent_file_path):
with open(torrent_file_path, 'rb') as f:
info_dict = bdecode(f.read())['info']
info_hash = sha1(bencode(info_dict)).hexdigest()
return info_hash, info_dict
manager = Manager(create_app)
manager.add_option('-c',
'--config',
dest='config',
help='config file for flacker',
required='FLACKER_CONFIG' not in os.environ)
manager.add_command("shell", Shell(make_context=_make_context))
manager.add_command("runserver", Server())
@manager.option('-n', '--name', help='Torrent name')
@manager.option('-i', '--info-hash', help='Info hash of torrent')
@manager.option('-f', '--file', help='Torrent file', dest='torrent_file_path')
def add_torrent(name, info_hash, torrent_file_path):
if torrent_file_path:
torrent_file_path = os.path.join(os.getcwd(), torrent_file_path)
#!/usr/bin/env python
#-*-coding:utf-8-*-
import os, sys
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
import logging
logging.basicConfig(level=logging.INFO)
from flaskext.script import Manager, Shell
from scriptfan import app, db, oid, config_app, dispatch_handlers, dispatch_apps
manager = Manager(app, with_default_commands=False)
def _make_context():
return dict(app=app, db=db, oid=oid)
manager.add_command('shell', Shell(make_context=_make_context))
@manager.option('-c', '--config', dest='config', help='Configuration file name', default='scriptfan.cfg')
def runserver(config):
config_app(app, config)
dispatch_handlers(app)
dispatch_apps(app)
app.run(host='0.0.0.0')
@manager.option('-c', '--config', dest='config', help='Configuration file name', default='scriptfan.cfg')
def initdb(config='scriptfan.cfg'):
config_app(app, config)
try:
db.drop_all()
# -*- coding: utf-8 -*-
"""
myapp.manager
=============
This contains commands for the management script.
:copyright: (C) 2011, Matthew Frazier
:license: MIT/X11, see LICENSE for details
"""
from flask import current_app
from flaskext.script import Manager
from .application import create_app
manager = Manager(create_app)
manager.add_option('-c', '--config', dest='config', required=False)
import sys
from werkzeug.datastructures import MultiDict
from flask import request
from flaskext.script import Manager, prompt_pass, prompt_choices
from postfixmgmt import app, db, __version__
from postfixmgmt.auth import create_password
from postfixmgmt.models import Domain, Address, Admin
from postfixmgmt.forms import DomainAddForm, AdminAddForm
manager = Manager(app)
def validate_fields(fields):
for name, field in fields._fields.iteritems():
return validate_field(field)
def validate_field(field):
if field.validate(field.raw_data):
return True
return False
def print_field_errors(obj, fields):
print "Errors where found when adding '%s'" % obj
for name, field in fields._fields.iteritems():
for error in field.errors:
print "- %s" % error
sys.exit()
def list_domains():
print "Domains:"
for d in Domain.query.all():
import os
from flask import current_app
from flaskext.script import Manager
from frontend import create_app, models
from frontend.emailForwarder.emailReader import EmailForwardService, EmailKeyReader, PostulacionGetEmailByEmailKeyQuery, EmailRepository, ForwardEmailBuilder
from frontend.extensions import db
manager = Manager(create_app)
manager.add_option('-c', '--config', dest='config', required=False)
@manager.command
def run():
port = int(os.environ.get('PORT', 5000))
current_app.run(host='0.0.0.0', port=port)
@manager.command
def reset():
db.drop_all()
db.create_all()
from frontend.models import Macanudo
@manager.command
def runEmailForward():
forwardService = EmailForwardService(EmailRepository(),PostulacionGetEmailByEmailKeyQuery(), EmailKeyReader, ForwardEmailBuilder)
forwardService.forwardAll()
# coding=utf-8
from flaskext.script import Manager, Server, Shell, prompt_bool
from example import app
from example.extensions import db
# 脚本管理
script_manager = Manager(app)
script_manager.add_command('runserver', Server('0.0.0.0', port=5000))
def _make_context():
return { 'db':db }
script_manager.add_command("shell", Shell(make_context=_make_context))
@script_manager.command
def createall():
"Creates database tables"
db.create_all()
@script_manager.command
def dropall():
"Drops all database tables"
if prompt_bool("Are you sure ? You will lose all your data !"):
db.drop_all()
if __name__ == '__main__':
script_manager.run()
#!/usr/bin/env python
from flaskext.script import Manager
from screenchop import urls
from scripts.add_invite_code import generate_invite
from scripts.tag_freq import tag_frequencies
manager = Manager(urls.app)
@manager.command
def invite_code():
"Generates an invitation code"
generate_invite()
@manager.command
def tag_freq():
"Updates tag_freq collection with updated tag cloud"
tag_frequencies()
if __name__ == '__main__':
manager.run()
#!/usr/bin/env python
"""
Distrivia Test Runner
~~~~~~~~~~~~~~~~~~~~~~~
A cool test runner for the unit tests.
:copyright: (c) 2011 by Brian Gianforcaro, Steven Glazer, Sam Milton.
"""
from flaskext.script import Manager
from flaskext.zen import Test, ZenTest
from distrivia import app
manager = Manager(app)
manager.add_command( 'test', Test() )
manager.add_command( 'zen', ZenTest() )
if __name__ == '__main__':
manager.run()
#!/usr/bin/env python
#coding=utf-8
from flask import Flask, current_app
from flaskext.script import Command, Manager, Server, Shell, prompt_bool
from hunt import create_app
from hunt.extensions import db
manager = Manager(create_app('configure.cfg'))
manager.add_command('runserver', Server('127.0.0.1', port=9999))
def _make_context():
return dict(db=db)
manager.add_command('shell', Shell(make_context=_make_context))
@manager.command
def createall():
db.create_all()
@manager.command
def dropall():
if prompt_bool("Are you sure ? You will lose all your data !"):
db.drop_all()
#!/usr/bin/env python
# coding: utf-8
from jzsadmin import create_app
from jzsadmin.models import User, Entry
from jzsadmin.scripts.crawl_ganji import crawl_ganji
from flaskext.script import Server, Shell, Manager, Command, prompt_bool
manager = Manager(create_app('dev.cfg'))
manager.add_command("runserver", Server('0.0.0.0', port=8080))
@manager.option('-u', '--username', dest='name', type=str)
@manager.option('-p', '--password', dest='passwd', type=str)
@manager.option('-r', '--role', dest='role', default=100, type=int)
def adduser(name, passwd, role):
user = User(name=name, password=passwd, role=role)
user.save()
print 'Created'
@manager.option('-u', '--username', dest='name', type=str)
def deluser(name):
user = User.query.filter_by(name=name).first()
user.remove()
print 'Del.'
@manager.option('-c', '--city', dest='city', type=str)
import os
import datetime
from flaskext.script import Manager, Shell, Server, prompt_bool
from app.extensions import db
from app import create_app
from config import DevConfig, ProdConfig
from app.user import User, UserDetail, ADMIN, USER, ACTIVE
#env = os.environ.get('APP_ENV', 'prod') # {dev, prod}
#app = create_app(eval('%sConfig' % env.capitalize()))
#manager = Manager(app)
app = create_app()
manager = Manager(app)
#manager = Manager(create_app())
#app = create_app()
manager.add_command("run",
Server(host=app.config['HOST'], port=app.config['PORT']))
manager.add_command("shell", Shell())
@manager.command
def initdb():
"""Init/reset database."""
if not prompt_bool("Are you sure? You will lose all your data!"):
return
#!/usr/bin/env python
#coding=utf-8
import uuid
from flask import Flask, current_app
from flaskext.script import Server, Shell, Manager, Command, prompt_bool
from pypress import create_app
from pypress.extensions import db
from pypress.models.users import User, UserCode
manager = Manager(create_app('config.cfg'))
manager.add_command("runserver", Server('0.0.0.0',port=8080))
def _make_context():
return dict(db=db)
manager.add_command("shell", Shell(make_context=_make_context))
@manager.command
def createall():
"Creates database tables"
db.create_all()
@manager.command
def dropall():
"Drops all database tables"
if prompt_bool("Are you sure ? You will lose all your data !"):
db.drop_all()
#!/usr/bin/env python
#coding=utf-8
"""
file: manage.py
description: This file is used to handle the management of the site from shell, user
can add shell command here, like 'runserver' etc.
author: Titainium Deng
date: 2011-6-8
"""
from flaskext.script import Server, Manager
from dandelion import create_app
manager = Manager(create_app('dandelion.cfg'))
manager.add_command("runserver", Server('0.0.0.0',port=8080))
if __name__ == "__main__":
manager.run()
"""
import sys
import feedparser
from flask import current_app
from flaskext.script import Manager, prompt, prompt_pass, \
prompt_bool, prompt_choices
from flaskext.mail import Message
from newsmeme import create_app
from newsmeme.extensions import db, mail
from newsmeme.models import Post, User, Comment, Tag
manager = Manager(create_app)
@manager.option("-u", "--url", dest="url", help="Feed URL")
@manager.option("-n", "--username", dest="username", help="Save to user")
def importfeed(url, username):
"""
Bulk import news from a feed. For testing only !
"""
user = User.query.filter_by(username=username).first()
if not user:
print "User %s does not exist" % username
sys.exit(1)
d = feedparser.parse(url)
for entry in d['entries']:
from flaskext.script import Manager, Server, Shell
from pdxacm.webapp import app, db
from pdxacm.models.fixtures import base_fixtures
def _make_context():
return dict(app=app, db=db)
manager = Manager(app)
manager.add_command("shell", Shell(make_context=_make_context))
manager.add_command("runserver", Server())
@manager.command
def initdb():
db.drop_all()
db.create_all()
for fixture in base_fixtures.itervalues():
db.session.add(fixture)
db.session.commit()
if __name__ == "__main__":
manager.run()
import pprint
import memcache
import sys, os, signal
import subprocess
import time
from subprocess import call, Popen, PIPE
from flask import Flask, current_app as app
from flask import Config
from flaskext.script import Server, Shell, Manager, Command, prompt_bool
from memcached_stats import MemcachedStats
from boardhood import create_app
from boardhood.helpers.os import children_pid
manager = Manager(create_app('development'))
manager.add_command("runserver", Server('127.0.0.1',port=5000))
sql_files_91 = [
'/usr/share/postgresql/9.1/contrib/postgis-1.5/postgis.sql',
'/usr/share/postgresql/9.1/contrib/postgis-1.5/spatial_ref_sys.sql',
'/usr/share/postgresql/9.1/contrib/postgis_comments.sql',
'db/schema.sql',
'db/extras.sql',
'db/functions.sql',
'db/sample.sql'
]
sql_files_84 = [
'/usr/share/postgresql/8.4/contrib/postgis-1.5/postgis.sql',
'/usr/share/postgresql/8.4/contrib/postgis-1.5/spatial_ref_sys.sql',
#Set the path
import os, sys
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from flaskext.script import Manager, Server
from db_settings 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 flaskext.script import Manager
import bf3
manager = Manager(bf3.app)
@manager.command
def initdb():
"""Create the database tables"""
print 'Using database %s' % bf3.db.engine.url
bf3.db.create_all()
print 'Created tables'
@manager.command
def sync():
"""Download new messages from twitter and forums"""
bf3.sync()
print 'Done syncing'
if __name__ == '__main__':
manager.run()
import sys
import os
from flaskext.script import Server, Manager
#from flaskext.celery import install_commands as install_celery_commands
from pdfserver import app
manager = Manager(app)
#install_celery_commands(manager)
class Runserver(Server):
def handle(self, app_, *args, **kwargs):
if app_.config['DATABASE'].startswith('sqlite:///'):
file_path = app_.config['DATABASE'].replace('sqlite:///', '')
if not os.path.exists(file_path):
print >> sys.stderr, ("Database not found, "
"you should probably run "
"'python manage.py createdb' first!")
sys.exit(1)
if not os.path.exists(app_.config['UPLOAD_TO']):
print >> sys.stderr, ("Upload directory %r not found. "
"You need to create it first!" %
app_.config['UPLOAD_TO'])
sys.exit(1)
if not app_.config['SECRET_KEY']:
app_.config['SECRET_KEY'] = 'development key'
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from flaskext.script import Command, Manager, Shell
from rta import api
from web import app
manager = Manager(app)
class SyncDB(Command):
"""
Initializes the database tables.
"""
def run(self):
db = api.Model.db()
db.reset()
class FixedShell(Shell):
"""
Runs a Python shell inside Flask application context.
"""
def run(self, no_ipython):
context = self.get_context()
if not no_ipython:
try:
from IPython.frontend.terminal.embed import InteractiveShellEmbed
sh = InteractiveShellEmbed(banner1=self.banner)
sh(global_ns=dict(), local_ns=context)
from flaskext.script import Manager
from web import db, app
manager = Manager(app)
@manager.command
def createDbSchema():
db.create_all()
if __name__ == "__main__":
manager.run()
"""
:copyright: (c) 2011 Local Projects, all rights reserved
:license: Affero GNU GPL v3, see LEGAL/LICENSE for more details.
"""
import os
os.environ.setdefault('FLAILS_ENV', 'script')
import main
from flaskext.script import Manager
from flaskext.assets import ManageAssets
from script.users import MakeAdmin
manager = Manager(main.app)
manager.add_command("assets", ManageAssets())
manager.add_command("make_admin", MakeAdmin())
if __name__ == "__main__":
manager.run()
