def main():
def action_runserver(hostname=('h', '0.0.0.0'), port=('p', 8080),
debug=('d', False), verbosity=('v', 0)):
'''Run the development server.
:param debug: run in debug mode
:param verbosity: increase level of logging for more verbose logging
'''
logging.basicConfig()
init_logging(verbosity)
serving.run_simple(hostname, port,
make_app({'reload_templates': debug,
'reload_resources': debug}),
use_reloader=debug,
use_debugger=debug,
use_evalex=debug)
def action_syncdb():
'''Ensure tables exist in the configured database.
'''
settings = init_settings()
models.Base.metadata.create_all(settings['academe.db_engine'])
script.run()
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 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 main():
from werkzeug import script
def action_runserver(
instance=("I", DEFAULT_INSTANCE_FOLDER),
hostname=("h", "0.0.0.0"),
port=("p", 4000),
reloader=True,
debugger=True,
evalex=True,
threaded=False,
processes=1,
):
"""Start a new development server."""
from werkzeug.serving import run_simple
from rezine import get_wsgi_app
app = get_wsgi_app(instance)
run_simple(hostname, port, app, reloader, debugger, evalex, threaded=threaded, processes=processes)
def action_newinstance(
instance=("I", DEFAULT_INSTANCE_FOLDER),
database_uri=("d", DEFAULT_DATABASE_URI),
admin_username=("u", DEFAULT_ADMIN_USERNAME),
admin_password=("p", DEFAULT_ADMIN_PASSWORD),
admin_email=("e", DEFAULT_ADMIN_EMAIL),
):
"""Create a new instance"""
create_instance(instance, database_uri, admin_username, admin_password, admin_email)
def action_shell(instance=("I", DEFAULT_INSTANCE_FOLDER)):
"""Start a new interactive python session."""
from rezine import setup_rezine
from code import interact
rezine_app = setup_rezine(instance)
namespace = {"rezine_app": rezine_app}
banner = """Interactive Rezine Shell
namespace:
"""
for k, v in namespace.items():
banner += " %s: %s\n" % (k, v.__doc__.split("\n")[0].strip())
banner += "\n Use dir() to inspect current namespace."
interact(banner, local=namespace)
script.run()
target="", base=False, rm=False, failed=("f", False), with_coverage=("c", False), cover_package=("p", "naya")
):
"""Run tests."""
if rm:
sh("rm .noseids .coverage")
if base:
command = ["nosetests"]
else:
command = ["nosetests -v --with-doctest"]
if failed:
command.append("--failed")
if with_coverage:
command.append("--with-coverage --cover-tests")
if cover_package:
command.append("--cover-package=%s" % cover_package)
command.append("--with-id")
if target:
command.append(target)
sh(" ".join(command))
action_shell = make_shell()
if __name__ == "__main__":
run()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Manage i18nurls
~~~~~~~~~~~~~~~
Manage the i18n url example application.
:copyright: 2007 by Armin Ronacher.
: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()
#!/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()
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,
),
"",
)
try:
store.flush()
except:
store.rollback()
else:
store.commit()
from werkzeug import script
import wsgiref.handlers
script.run(dict(
runserver = script.make_runserver(lambda: application,
use_reloader=True, threaded=True, hostname='localhost',
port=7777, 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,
create_auth_tables = create_auth_tables,
drop_auth_tables = drop_auth_tables,
dbshell = db_shell,
show_tables = show_tables,
show_create = show_create,
clear = clear,
clear_data = clear_data,
drop_user = drop_user,
create_super_user = create_super_user,
), '')
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())
store_manager.showTables()
def show_create():
for dbname, store_manager in application.db.items():
print dbname
store_manager.showCreate()
def db_shell():
if len(application.db) == 0:
sys.exit('database not found')
elif len(application.db) == 1:
application.db.popitem()[1].runDBShell()
else:
print 'There are %d databases, please choose one of them:'%len(application.db.items())
name = input(', '.join([dbname for dbname in application.db]))
if not name in application.db:
sys.exit('no such database')
application.db[name].store_manager.runDBShell()
script.run(dict(
cherrypy = run_cherrypy_server,
runscgi = run_scgi,
runfcgi = run_fcgi,
runcgi = lambda: wsgiref.handlers.CGIHandler().run(application),
shell = script.make_shell(lambda: {"app": application}),
runserver = script.make_runserver(lambda: application,
use_reloader=True, threaded=True, hostname='localhost',
port=7777,
),
), '', sys.argv[2:])
def run(self):
script.run(self._actions, '')
def main():
action_runserver = script.make_runserver(make_app, use_reloader=True)
script.run()
from os.path import abspath, dirname, join
base_path = abspath(join(dirname(__file__), '..'))
template_path = join(base_path, 'templates')
sys.path.append(join(base_path, '..'))
from werkzeug import script, Template
def startproject(name='www'):
os.mkdir(name)
os.mkdir(join(name, 'views'))
os.mkdir(join(name, 'static'))
os.mkdir(join(name, 'templates'))
files = [ ('manage.py', 'manage.py'),
(join(name, '__init__.py'), '__init__.py'),
(join(name, 'shortcuts.py'), 'shortcuts.py'),
(join(name, 'models.py'), 'models.py'),
(join(name, 'views', '__init__.py'), 'null'),
(join(name, 'views', 'common.py'), 'common.py'),
(join(name, 'views', 'main.py'), 'main.py'),
]
for filename, tmpl_name in files:
tmpl = Template.from_file(join(template_path, tmpl_name))
fp = open(filename, 'wb')
fp.write(tmpl.render(project_name=name).encode('utf-8'))
fp.close()
script.run(dict(
startproject = startproject,
), '', sys.argv[1:])
def run_script():
from werkzeug import script
sys.exit(script.run(globals()))
