def handle(self, app, *args, **kwargs):
os.environ['RUNNING_FROM_CLI'] = '1'
app.blohg.init_repo(kwargs.pop('revision_id'))
# find extension files
def _listfiles(directory, files):
if not os.path.exists(directory):
return
for f in os.listdir(directory):
fname = os.path.join(directory, f)
if os.path.isdir(fname):
_listfiles(fname, files)
else:
files.append(os.path.abspath(fname))
extra_files = []
_listfiles(os.path.join(app.config['REPO_PATH'],
app.config['EXTENSIONS_DIR']), extra_files)
if 'extra_files' in self.server_options \
and self.server_options['extra_files'] is not None:
self.server_options['extra_files'] = \
list(self.server_options['extra_files']) + extra_files
else:
self.server_options['extra_files'] = extra_files
_Server.handle(self, app, *args, **kwargs)
def handle(*args, **kwargs):
app.configure(
DEBUG=True,
SQLALCHEMY_ECHO=True,
USE_X_SENDFILE=False,
)
Server.handle(*args, **kwargs)
def __call__(self, *args, **kwargs):
from blackgoat.smtpserver import FakeSMTPServer
kwargs = kwargs.copy()
host = kwargs['host']
smtpport = kwargs.pop('smtpport')
smtp = FakeSMTPServer(logger=logging.getLogger('blackgoat.smtp'),
localaddr=(host, smtpport))
smtp.start()
Server.__call__(self, *args, **kwargs)
smtp.stop()
def get_options(self):
options = _Server.get_options(self)
options += (Option('-n', '--revision-default', action='store_const',
dest='revision_id', const=REVISION_DEFAULT,
default=REVISION_WORKING_DIR,
help='use files from the default branch, instead '
'of the working directory'),)
return options
from flask.ext.script import Server, Manager, Shell
from tagarela.app import create_app
from tagarela.extensions import db
manager = Manager(create_app)
manager.add_option("-s",
"--settings",
dest="settings_folder",
required=False,
default=os.path.join(
os.path.dirname(os.path.abspath(__file__)), 'settings'))
manager.add_command('run', Server(port=5003))
manager.add_command(
'shell', Shell(make_context=lambda: {
'app': manager.app,
'db': db,
}))
@manager.command
def initdb():
db.drop_all()
db.create_all()
if __name__ == '__main__':
manager.run()
"""
Base terminal command manager.
Define terminal commands here to run actions
"""
from flask.ext.script import Manager, Server
from flask.ext.sqlalchemy import SQLAlchemy
# from flask.ext.migrate import Migrate, MigrateCommand
from system.init import initialize_app
# from system.init.database import create_database
import subprocess
import os
app = initialize_app()
manager = Manager(app)
# implement later, just creates database, needs to have mysql server installed
# @manager.option('-db', '--database', help='database name')
# def create_db(database):
# create_database(app, database)
manager.add_command('runserver', Server(host='127.0.0.1'))
if __name__ == "__main__":
manager.run()
# -*- coding: utf-8 -*-
from stepbystep import app, db
from flask.ext.script import Manager, Server, Shell
from stepbystep.models import UserModel, RoleModel
manager = Manager(app)
def make_shell_context():
return dict(app=app, db=db, UserModel=UserModel, RoleModel=RoleModel)
manager.add_command("runserver",
Server(use_reloader=True, host="0.0.0.0", port=4000))
manager.add_command("shell", Shell(make_context=make_shell_context))
@manager.command
def deploy():
RoleModel.insert_roles()
admin = RoleModel.objects(name='admin').first()
user = UserModel.objects(username='******').first()
if user is None:
user = UserModel.create_user(username='******',
name='admin',
password='******')
user.roles.append(admin)
user.save()
# 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, Command, Option
from quickhunt import create_app
manager = Manager(create_app)
manager.add_option('-e', '--env', dest='env', required=False, default='debug')
# Turn on debugger by default and reloader
manager.add_command(
"runserver",
Server(use_reloader=True,
port=int(os.environ.get('PORT', 5000)),
host='0.0.0.0'))
if __name__ == "__main__":
manager.run()
from flask.ext.script import Manager, Server
from flask.ext.script.commands import ShowUrls, Clean
from flask.ext.markdown import Markdown
from appname import create_app
from appname.models import db, User
from flask.ext.misaka import Misaka
# default to dev config because no one should use this in
# production anyway
env = os.environ.get('APPNAME_ENV', 'dev')
app = create_app('appname.settings.%sConfig' % env.capitalize(), env=env)
Misaka(app)
manager = Manager(app)
manager.add_command("server", Server(host="0.0.0.0", port=80))
manager.add_command("show-urls", ShowUrls())
manager.add_command("clean", Clean())
@manager.shell
def make_shell_context():
""" Creates a python REPL with several default imports
in the context of the app
"""
return dict(app=app, db=db, User=User)
@manager.command
def createdb():
from flask.ext.script import Manager, Server
from treemaps.web import app
from treemaps.generators import freezer
server = Server(host='0.0.0.0', port=5000)
manager = Manager(app)
manager.add_command("runserver", server)
@manager.command
def freeze():
""" Freeze the entire site to static HTML. """
app.config['DEBUG'] = False
app.config['ASSETS_DEBUG'] = False
freezer.freeze()
if __name__ == '__main__':
manager.run()
def get_options(self):
return Server.get_options(self) + \
(Option('--smtpport', dest='smtpport',
type=int, default=self.smtpport),
)
import sys, os
from main import app
from flask.ext.script import Manager, Server
from scripts.db_commands import ResetDB, PopulateDB, DisplayDB, ExportCourse
from scripts.external_commands import UpdateDatasets, UpdateBlockPy
'''from OpenSSL import SSL
context = SSL.Context(SSL.SSLv23_METHOD)
context.use_privatekey_file('certs/foobar.key')
context.use_certificate_file('certs/foobar.crt')'''
context = (r"certs\server.crt", r"certs\server.key")
manager = Manager(app)
# Server commands context
manager.add_command("secure", Server(ssl_context=context))
# Database Commands
manager.add_command("reset_db", ResetDB())
manager.add_command("populate_db", PopulateDB())
manager.add_command("display_db", DisplayDB())
manager.add_command("export_course", ExportCourse())
manager.add_command("update_datasets", UpdateDatasets())
manager.add_command("update_blockpy", UpdateBlockPy())
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"), # Need for Cloud9
port=int(os.getenv("PORT", 5000))) # Need for Cloud9
)
if __name__ == "__main__":
manager.run()
import os
from app import create_app, db
from app.models import User, Role
from flask.ext.script import Manager, Shell, Server
from flask.ext.migrate import Migrate, MigrateCommand
app = create_app(os.getenv('FLASK_CONFIG') or 'default')
manager = Manager(app)
migrate = Migrate(app, db)
def make_shell_context():
return dict(app=app, db=db, User=User, Role=Role)
manager.add_command("shell", Shell(make_context=make_shell_context))
manager.add_command('db', MigrateCommand)
manager.add_command("runserver", Server(host='0.0.0.0'))
@manager.command
def test():
"""Run the unit tests."""
import unittest
tests = unittest.TestLoader().discover('tests')
unittest.TextTestRunner(verbosity=2).run(tests)
if __name__ == '__main__':
manager.run()
def handle(self, *args, **kwargs):
Server.handle(self, *args, **kwargs)
#! /usr/bin/env python
import os
from flask.ext.script import Server, Manager
from py_back import create_app
app = create_app(os.getenv('PY_BACK_CONFIG', 'default'))
manager = Manager(app)
manager.add_command("runserver",
Server(host='0.0.0.0', port=os.getenv('PORT', 5000)))
@manager.shell
def make_shell_context():
return dict(app=app)
if __name__ == '__main__':
manager.run()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from flask.ext.failsafe import failsafe
from flask.ext.script import Manager, Server
@failsafe
def create_app():
from diilikone import Application
return Application()
manager = Manager(create_app)
manager.add_command('runserver', Server(host='localhost'))
if __name__ == '__main__':
manager.run()
#!/usr/bin/env python
from flask.ext.script import Manager, Server
from flask.ext.script.commands import ShowUrls, Clean
from urlshort import urlshort
from urlshort.models import db
app = urlshort.create_app()
manager = Manager(app)
manager.add_command("server", Server(host="0.0.0.0"))
manager.add_command("show-urls", ShowUrls())
manager.add_command("clean", Clean())
@manager.shell
def make_shell_context():
""" Creates a python REPL with several default imports
in the context of the app
"""
return dict(app=app, db=db, User=User)
@manager.command
def createdb():
""" Creates a database with all of the tables defined in
your SQLAlchemy models
"""
def handle(*args, **kwargs):
app.configure(DEBUG=True)
Server.handle(*args, **kwargs)
output = []
for rule in app.url_map.iter_rules():
options = {}
for arg in rule.arguments:
options[arg] = "[{0}]".format(arg)
methods = ','.join(rule.methods)
url = url_for(rule.endpoint, **options)
line = urllib.unquote("{:50s} {:20s} {}".format(
rule.endpoint, methods, url))
output.append(line)
class Test(Command):
option_list = (
Option('--path', '-n', dest='test_path', default=".", required=False),
)
def run(self, test_path="."):
import unittest
tests = unittest.TestLoader().discover(test_path)
ret = unittest.TextTestRunner(verbosity=2).run(tests).wasSuccessful()
sys.exit(not ret)
if __name__ == "__main__":
manager.add_command('test', Test())
manager.add_command('runserver', Server('0.0.0.0', port=5000))
manager.run()
# 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 flask import render_template, request, redirect, url_for
from my_code import app
manager = Manager(app)
#@app.route('/admin')
#def admin_page():
# return render_template('admin/admin.html')
@app.route('/admin/create-case')
def create_case():
return render_template('admin/create-case.html')
@app.route('/admin/case_name')
def view_case():
return "view case"
# 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()
print_users=print_users,
drop_table=drop_table,
show_tables=show_tables,
print_tables=print_tables,
show_all=show_all,
gen_subdivisions=gen_subdivisions,
get_subdivisions=get_subdivisions,
print_subdivisions=print_subdivisions,
app_roles=app_roles,
get_app_roles=get_app_roles,
isIterable=isIterable,
)
manager.add_command("shell", Shell(make_context=make_shell_context))
manager.add_command("start", Server(host='0.0.0.0', port=5000))
@manager.command
def test(coverage=False):
"""Run the unit tests."""
pass
@manager.command
def profile(length=25, profile_dir=None):
"""Start the application under the code profiler."""
#from werkzeug.contrib.profiler import ProfilerMiddleware
#app.wsgi_app = ProfilerMiddleware(app.wsgi_app, restrictions=[length], profile_dir=profile_dir)
#app.run()
pass
from flask.ext.script import Manager, Server
from flask.ext.migrate import MigrateCommand
from flaskdash.app import create_app
app = create_app()
manager = Manager(app)
manager.add_command("runserver", Server("localhost", port=8080))
manager.add_command('db', MigrateCommand)
if __name__ == "__main__":
manager.run()
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import os
from app import create_app
from flask.ext.script import Manager, Server
from flask_socketio import SocketIO, emit
app = create_app(os.getenv('FLASK_CONFIG') or 'default')
app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension')
# socketio = SocketIO(app)
manager = Manager(app)
manager.add_command("runserver", Server(port=8080))
# @socketio.on('connect', namespace='/test')
# def test_connect():
# print('test_connect')
# emit('my response', {'data': 'Connected'})
if __name__ == '__main__':
print('main')
manager.run()
# socketio.run(app)
# -*- coding: utf-8 -*-
"""
manager.py
~~~~~~~~~~~
flask manager script
:copyright: (c) 2013.
:license: BSD, see LICENSE for more details.
"""
from flask.ext.script import Server, Manager, prompt_bool
from myapp import app
from model import db
manager = Manager(app)
manager.add_command("runserver", Server('0.0.0.0', port=5000))
@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
import os
import pymysql
from app import create_app, db
from app.models import User, Role, Tendinfo
from flask_script import Manager, Shell
from flask.ext.script import Server
from flask_migrate import Migrate, MigrateCommand
pymysql.install_as_MySQLdb()
app = create_app(os.getenv('FLASK_CONFIG') or 'default')
manager = Manager(app)
migrate = Migrate(app, db)
manager.add_command("runserver", Server(host="0.0.0.0", port=5000))
def make_shell_context():
return dict(app=app, db=db, User=User, Role=Role, Tendinfo=Tendinfo)
manager.add_command("shell", Shell(make_context=make_shell_context))
manager.add_command('db', MigrateCommand)
@manager.command
def test():
"""Run the unit tests."""
import unittest
tests = unittest.TestLoader().discover('tests')
unittest.TextTestRunner(verbosity=2).run(tests)
#!/usr/bin/env python
import os
from semcomp import create_app, db
from flask.ext.script import Manager, Shell, Server
app = create_app(os.getenv('FLASK_CONFIG') or 'default')
app.use_reloader = True
app.debug = True
manager = Manager(app)
def make_shell_context():
return dict(app=app, db=db, User=User)
manager.add_command("shell", Shell(make_context=make_shell_context))
manager.add_command("runserver", Server(port=5000, host='0.0.0.0'))
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=9002))
if __name__ == '__main__':
manager.run()
from flask.ext.script import Manager, Server
from flask.ext.script.commands import ShowUrls, Clean
from flask_migrate import Migrate, MigrateCommand
from local_knowledge import create_app
from local_knowledge.models import db, User
# default to dev config because no one should use this in
# production anyway
env = os.environ.get('LOCAL_KNOWLEDGE_ENV', 'dev')
app = create_app('local_knowledge.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.shell
def make_shell_context():
""" Creates a python REPL with several default imports
in the context of the app
"""
return dict(app=app, db=db, User=User)
@manager.command
def update_outposts():
'''Update Conquerable stations amd Outposts from Eve API'''
api = EveTools()
api_stations = api.client.eve.ConquerableStationList()
stations = {}
for station in api_stations.outposts:
stations[str(station.stationID)] = station.stationName + \
' (%s)' % station.corporationName
r = redis.StrictRedis(host=app.config['REDIS'])
r.set('eve.stations', json.dumps(stations))
@manager.command
def clean_activities():
with app.app_context():
until = datetime.datetime.utcnow() - datetime.timedelta(days=30)
mongo.db.activities.remove({'created_at': {'$lt': until}})
app.logger.info('Activities cleaned !')
manager.add_command(
"runserver",
Server(host='0.0.0.0', port=os.getenv('PORT', 5000), debug=True))
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 tumblelog 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()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import unicode_literals, print_function
from flask.ext.script import Manager, Server, Shell
from test_pay_site import create_app
manager = Manager(create_app)
manager.add_option('-e', '--env', dest='env', default='dev', required=False)
def make_shell_context():
import test_pay_site
from test_pay_site import config
return dict(website=test_pay_site, app=manager.app, config=config)
manager.add_command("shell", Shell(make_context=make_shell_context))
server = Server(host="0.0.0.0", port=8090)
manager.add_command("runserver", server)
if __name__ == '__main__':
manager.run()
#!/usr/bin/env python
import os, sys
from os import path
from flask.ext.script import Manager, Server, Shell
#from smartcarte import app
if __name__ == '__main__':
#sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from ecarte import app
manager = Manager(app)
manager.add_command("runserver", Server(
threaded = True,
use_debugger = True,
use_reloader = True,
port=8080,
host = '0.0.0.0'))
manager.add_command("shell", Shell(use_ipython=True))
manager.run()
#!/usr/bin/env python
import sys
sys.path.insert(0, '.')
from cypher_cossack import create_app
from flask.ext.script import Manager, Shell, Server
app = create_app()
manager = Manager(app)
manager.add_command("shell", Shell(make_context=lambda: dict(app=app)))
manager.add_command("runserver", Server(port=app.config['PORT']))
manager.add_command("publicserver",
Server(port=app.config['PORT'], host="0.0.0.0"))
if __name__ == "__main__":
manager.run()
'$last_name': user.last_name,
'$email': user.email
})
user_registered.connect(mixpanel_register_new_user, app)
# @app.context_processor
# def navbar_context_processor():
# categories = db.session.query(Category).all()
# return dict(categories=categories)
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))))
@app.route("/")
def index():
projects = db.session.query(Project).order_by(
Project.time_created.desc()).limit(15)
return render_template("index.html", projects=projects)
@app.route("/projects/create/", methods=["GET", "POST"])
@login_required
def create():
if request.method == "GET":
return render_template("create.html")
from flask.ext.script import Manager, Server
from app import create_app
from app.models import User, Post
from werkzeug.security import generate_password_hash
app = create_app()
manager = Manager(app)
manager.add_command("runserver",
Server(host='0.0.0.0', port=5000, use_debugger=True))
@manager.option('-u', '--name', dest='name', default='admin')
@manager.option('-p', '--password', dest='password', default='123456')
def create_admin(name, password):
admin = User(name=name, password=generate_password_hash(password))
admin.save()
@manager.command
def add_post():
user = User.objects(name="admin").first()
post = Post(title="Hello",
content="Hello Wolrd",
author=user,
tags=['python', 'flask'])
post.save()
if __name__ == '__main__':
manager.run()
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())
manager.add_command('deactivate_user', DeactivateUserCommand())
manager.add_command('activate_user', ActivateUserCommand())
manager.add_command('reset_user', ResetUserCommand())
manager.add_command('install', InstallCommand())
if __name__ == '__main__':
manager.run()
def get_options(self):
return (Option('site'),) + BaseServer.get_options(self)
