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_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()