def enter(context, install_dependencies=True, upgrade_db=True):
"""
Enter into IPython notebook shell with an initialized app.
"""
if install_dependencies:
context.invoke_execute(context, 'app.dependencies.install')
if upgrade_db:
context.invoke_execute(context, 'app.db.upgrade')
import pprint
import logging
from werkzeug import script
import flask
import app
flask_app = app.create_app()
def shell_context():
context = dict(pprint=pprint.pprint)
context.update(vars(flask))
context.update(vars(app))
return context
with flask_app.app_context():
script.make_shell(shell_context, use_ipython=True)()
def main(argv=None):
if not argv:
argv = sys.argv[1:]
options = parse_args(argv)
app = init_app(options.config)
if options.shell:
script.make_shell(make_shell, use_ipython=True)
else:
app.run(host=options.host, port=int(options.port))
return 0
def run_werkzeug(app, host='127.0.0.1', port=8000, thread=0, proc=1):
from werkzeug import script
action_runserver = None
if thread > 0:
action_runserver = script.make_runserver(lambda: app, hostname=host, port=port, threaded=thread)
else:
action_runserver = script.make_runserver(lambda: app, hostname=host, port=port, processes=proc)
log.info("Server running on port %s:%d" % (host, port))
action_shell = script.make_shell(lambda: {})
script.run(args=['runserver'])
def __init__(self, application):
self.application = application
self._actions = {
'cherrypy' : run_cherrypy_server(application),
'runcgi' : runcgi(application),
'shell' : script.make_shell(lambda: {"app": application}),
'runserver' : script.make_runserver(lambda: application,
use_reloader=True, threaded=True, hostname='localhost',
port=7777, use_debugger=True),
}
def action_template_shell(ipython=True):
"""Start an interactive debugging shell.
Two extras are in the shell namespace: 'loader', a template
loader, and 'config', a blatter config.
"""
config = load_config()
env = dict(config=config,
loader=template_loader_for(config))
from werkzeug import script
shell = script.make_shell(init_func=lambda: env)
return shell(ipython=ipython)
from werkzeug import script
env = jinja2.Environment(extensions=['jinja2.ext.i18n', 'jinja2.ext.do',
'jinja2.ext.loopcontrols',
'jinja2.ext.with_',
'jinja2.ext.autoescape'],
autoescape=True)
def shell_init_func():
def _compile(x):
print(env.compile(x, raw=True))
result = {
'e': env,
'c': _compile,
't': env.from_string,
'p': env.parse
}
for key in jinja2.__all__:
result[key] = getattr(jinja2, key)
return result
def action_compile():
print(env.compile(sys.stdin.read(), raw=True))
action_shell = script.make_shell(shell_init_func)
if __name__ == '__main__':
script.run()
"""
import os
from werkzeug import script
def make_app():
"""Helper function that creates a plnt app."""
from plnt import Plnt
database_uri = os.environ.get('PLNT_DATABASE_URI')
app = Plnt(database_uri or 'sqlite:////tmp/plnt.db')
app.bind_to_context()
return app
action_runserver = script.make_runserver(make_app, use_reloader=True)
action_shell = script.make_shell(lambda: {'app': make_app()})
def action_initdb():
"""Initialize the database"""
from plnt.database import Blog, session
make_app().init_database()
# and now fill in some python blogs everybody should read (shamelessly
# added my own blog too)
blogs = [
Blog('Armin Ronacher', 'http://lucumr.pocoo.org/',
'http://lucumr.pocoo.org/cogitations/feed/'),
Blog('Georg Brandl', 'http://pyside.blogspot.com/',
'http://pyside.blogspot.com/feeds/posts/default'),
Blog('Ian Bicking', 'http://blog.ianbicking.org/',
'http://blog.ianbicking.org/feed/'),
#!/usr/bin/env python from werkzeug import script from werkzeug.contrib import profiler import tracker.main import tracker.tests import sys def make_app(): return tracker.main.application action_runserver = script.make_runserver(make_app, use_reloader=True) action_shell = script.make_shell(use_ipython=True) action_profile = profiler.make_action(make_app) def action_syncviews(): """ Synchronize views to CouchDB. """ from webui import couchdb_views from couchdb.design import ViewDefinition import webui.db try: ViewDefinition.sync_many(webui.db.database, couchdb_views.view_definitions) except AttributeError: print 'Error: CouchDB must not be running' sys.exit(1) if __name__ == '__main__': script.run()
def shell():
script.make_shell(lambda: {'app': app}, use_ipython=True)()
from mozugs.app import BugTrackerApp
static = {"/static": os.path.join(root, "static")}
config_dir = os.path.join(root, "config")
config_files = [os.path.join(config_dir, fn) for fn in os.listdir(config_dir) if fn.endswith(".ini")]
def _create_app():
app = BugTrackerApp(root, [os.path.join(config_dir, "test.ini"), os.path.join(config_dir, "local.ini")])
models.ModelBase.metadata.create_all(app.engine)
return app
def _init_shell():
return {"app": _create_app()}
action_run = script.make_runserver(
_create_app, port=1111, use_reloader=True, extra_files=config_files, static_files=static
)
action_shell = script.make_shell(_init_shell)
def action_gensalt():
print(security.gen_salt(8))
if __name__ == "__main__":
script.run(globals())
from lodgeit import local
from lodgeit.application import make_app
from lodgeit.database import session
dburi = 'sqlite:////tmp/lodgeit.db'
SECRET_KEY = 'no secret key'
def run_app(app, path='/'):
env = create_environ(path, SECRET_KEY)
return run_wsgi_app(app, env)
action_runserver = script.make_runserver(lambda: make_app(dburi, SECRET_KEY),
use_reloader=True)
action_shell = script.make_shell(
lambda: {
'app': make_app(dburi, SECRET_KEY, False, True),
'local': local,
'session': session,
'run_app': run_app
}, ('\nWelcome to the interactive shell environment of LodgeIt!\n'
'\n'
'You can use the following predefined objects: app, local, session.\n'
'To run the application (creates a request) use *run_app*.'))
if __name__ == '__main__':
script.run()
templates = path.realpath(path.expanduser(templates))
if path.exists(templates):
template_paths.append(templates)
else:
print ' * ERROR: The specified template path wasn\'t found.'
sys.exit(1)
else:
if path.exists(path.join(path.dirname(__file__), 'templates')):
template_paths.append(path.abspath(path.join(path.dirname(__file__), 'templates')))
if path.exists('/usr/share/buteo/templates'):
template_paths.append('/usr/share/buteo/templates')
if template_paths == []:
print ' * ERROR: No template files have been found. Specify a template path with the -t option.'
sys.exit(1)
else:
print ' * Using %s as template path.' % template_paths
from buteo import Buteo
from werkzeug.serving import run_simple
app = Buteo(cfg_file, plugin_path, template_paths)
run_simple(hostname, port, app, reloader, debugger, evalex,
extra_files, 1, threaded, processes, static_files)
return action
action_runserver = _runserver()
action_shell = script.make_shell(lambda: {'app': _runserver()})
if __name__ == '__main__':
script.run()
sys.path.insert(0, path.normpath(path.join(
path.dirname(path.realpath(__file__)), path.pardir)))
from config import config
parser = argparse.ArgumentParser()
parser.add_argument('command', type=str, nargs=1,
help='Command to run')
parser.add_argument('--config', required=False, default='default',
help='Config name')
args = parser.parse_args()
config.use(args.config)
if 'shell' in args.command:
from werkzeug import script
def make_shell():
return {
'config': config,
}
script.make_shell(make_shell, use_ipython=True)()
elif 'shovel' in args.command:
from web.server.application import create_app
app = create_app()
app.run()
from werkzeug import script
def __make_app():
from gluttonee import app
return app
def __make_shell():
app = __make_app()
ctx = app.test_request_context()
ctx.push()
app.preprocess_request()
import flask
return locals()
def __map_app():
app = __make_app()
print "Routing Map: \n"+str(app.url_map)
action_map = __map_app
action_serve = script.make_runserver(__make_app, use_reloader=True,
use_debugger=True)
action_console = script.make_shell(__make_shell)
script.run()
dburi = 'sqlite:////tmp/lodgeit.db'
SECRET_KEY = 'no secret key'
def run_app(app, path='/'):
env = create_environ(path, SECRET_KEY)
return run_wsgi_app(app, env)
action_runserver = script.make_runserver(
lambda: make_app(dburi, SECRET_KEY, debug=True),
use_reloader=True)
action_shell = script.make_shell(
lambda: {
'app': make_app(dburi, SECRET_KEY, False, True),
'local': local,
'db': db,
'run_app': run_app
},
('\nWelcome to the interactive shell environment of LodgeIt!\n'
'\n'
'You can use the following predefined objects: app, local, db.\n'
'To run the application (creates a request) use *run_app*.')
)
if __name__ == '__main__':
script.run()
WSGIServer(application, "/", bindAddress=(hostname, port), debug=True).run()
def show_tables():
models.tsdb.showTables()
def show_create():
models.tsdb.showCreate()
def db_shell():
models.tsdb.runDBShell()
from werkzeug import script
import wsgiref.handlers
script.run(
dict(
runserver=script.make_runserver(
lambda: application, hostname="0.0.0.0", use_reloader=True, threaded=True, port=8888, use_debugger=True
),
shell=script.make_shell(lambda: {"app": application}),
runcgi=lambda: wsgiref.handlers.CGIHandler().run(application),
cherrypy=run_cherrypy_server,
runfcgi=run_fcgi,
runscgi=run_scgi,
dbshell=db_shell,
show_tables=show_tables,
show_create=show_create,
),
"",
)
from nms import ctx
from nms.application import run, init_ctx
from werkzeug import script
def shell_env():
ctx = init_ctx()
from nms.database import db
return {
'ctx': init_ctx(),
'db': db,
'nms': nms
}
action_shell = script.make_shell(shell_env,
('\nWelcome to the interactive shell environment of NMS!\n'
'\n'
'You can use the following predefined objects: app, ctx, nms, db.\n'))
def run_app():
try:
run()
except KeyboardInterrupt:
pass
sys.exit(0)
print "Thanks for using!"
action_run = lambda: run_app()
if __name__ == '__main__':
#!/usr/local/virtualenv/huesound/bin/python
#!/usr/bin/env python
import sys
sys.path.append("../huesound")
from werkzeug import script
from huesound import config
def make_app():
from huesound.application import HueSoundServer
return HueSoundServer(config.PG_CONNECT)
def make_shell():
from huesound import utils
application = make_app()
return locals()
action_runserver = script.make_runserver(make_app, use_reloader=True)
action_shell = script.make_shell(make_shell)
script.run()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Manage i18nurls
~~~~~~~~~~~~~~~
Manage the i18n url example application.
:copyright: (c) 2009 by the Werkzeug Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
import os
from i18nurls import make_app
from werkzeug import script
action_runserver = script.make_runserver(make_app)
action_shell = script.make_shell(lambda: {})
if __name__ == '__main__':
script.run()
"""
Creates shell using IPython
"""
from werkzeug import script
from pybossa import model
from pybossa.core import create_app, db
def make_shell():
return dict(app=create_app(), model=model, db_session=db.session)
if __name__ == "__main__":
script.make_shell(make_shell, use_ipython=True)()
from werkzeug import script
from tongbupan import app
from models import metadata, session
import models as m
import lib.functions as f
import lib.fileserver as fs
import lib.statistics as s
import lib.events as e
import views.admin as admin
import views.feeds as updatefeeds
from models.tables import *
from scripts import *
from lib.contacts import csvfile
ctx = app.test_request_context()
def make_shell():
return dict(globals())
def ctx_push():
ctx.push()
def ctx_pop():
ctx.pop()
if __name__ == "__main__":
script.make_shell(make_shell, use_ipython=False)()
app = Wurstgulasch(database_uri=Configuration().database_uri)
app.__call__ = SharedDataMiddleware(
app.__call__, {
'/assets': './assets',
'/static': './static'
}
)
#app.__call__ = CacheMiddleware(app.__call__)
app.__call__ = SessionMiddleware(app.__call__, type='dbm', data_dir='./sessions')
return app
def shell_init(conf_file_location='wurstgulasch.cfg'):
Configuration().load_from_file(conf_file_location)
import model
return {
'wurstgulasch': Wurstgulasch(database_uri=Configuration().database_uri),
'model': model
}
if __name__ == "__main__":
from werkzeug.serving import run_simple
from werkzeug import script
action_runserver = script.make_runserver(create_app, use_debugger=True, use_reloader=True)
action_initdb = lambda: create_app().init_database()
action_shell = script.make_shell(shell_init)
script.run()
def __call__(self, options, args):
from werkzeug.script import make_shell
make_shell(lambda: {'app': self.application})()
from werkzeug import script
from exmrss import application, db
def make_app():
return application
def make_shell_locals():
from sqlalchemy.orm import create_session
app = make_app()
return {"db_engine": app.db_engine, "sess": create_session(app.db_engine),
"app": app, "metadata": db.metadata}
action_runserver = script.make_runserver(make_app, use_reloader=True)
action_shell = script.make_shell(make_shell_locals)
if __name__ == "__main__":
script.run()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Manage web.py like application
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
A small example application that is built after the web.py tutorial. We
even use regular expression based dispatching. The original code can be
found on the `webpy.org webpage`__ in the tutorial section.
__ http://webpy.org/tutorial2.en
:copyright: (c) 2009 by the Werkzeug Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
import os
import sys
sys.path.append(os.path.join(os.path.dirname(__file__), "webpylike"))
from example import app
from werkzeug import script
action_runserver = script.make_runserver(lambda: app)
action_shell = script.make_shell(lambda: {})
if __name__ == "__main__":
script.run()
#!/usr/bin/env python
import os
import tempfile
from werkzeug import script
def make_app():
from shorty.application import Shorty
filename = os.path.join(tempfile.gettempdir(), "shorty.db")
return Shorty('sqlite:///{0}'.format(filename))
def make_shell():
from shorty import models, utils
application = make_app()
return locals()
action_runserver = script.make_runserver(make_app, use_reloader=True)
action_shell = script.make_shell(make_shell)
action_initdb = lambda: make_app().init_database()
script.run()
def shell():
script.make_shell(lambda: {'app': app}, use_ipython=True)()
