def main(create_app_func=None):
if not create_app_func:
from widukind_web.wsgi import create_app
create_app_func = create_app
class ServerWithGevent(Server):
help = description = 'Runs the Flask development server with Gevent WSGI Server'
def __call__(self, app, host, port, use_debugger, use_reloader,
threaded, processes, passthrough_errors):
if use_debugger:
app = DebuggedApplication(app, evalex=True)
server = WSGIServer((host, port), app)
try:
print('Listening on http://%s:%s' % (host, port))
server.serve_forever()
except KeyboardInterrupt:
pass
env_config = config_from_env('WIDUKIND_SETTINGS', 'widukind_web.settings.Prod')
manager = Manager(create_app_func,
with_default_commands=False)
#TODO: option de config app pour désactiver run counter
manager.add_option('-c', '--config',
dest="config",
default=env_config)
manager.add_command("shell", Shell())
if HAS_GEVENT:
manager.add_command("server", ServerWithGevent(
host = '0.0.0.0',
port=8081)
)
else:
manager.add_command("server", Server(
host = '0.0.0.0',
port=8081)
)
manager.add_command("config", ShowConfigCommand())
manager.add_command("urls", ShowUrlsCommand())
manager.add_command("assets", ManageAssets())
manager.run()
def create_scripts(app):
manager = Manager(app)
manager.add_command("assets", ManageAssets(app.assets_env))
manager.add_command("build", SiteGenerator(app))
manager.add_command("new", SkeletonGenerator(app))
manager.add_command("lang", LanguageGenerator(app))
@manager.command
def serve():
import SimpleHTTPServer
import SocketServer
from os import chdir
import webbrowser
PORT = 8000
Handler = SimpleHTTPServer.SimpleHTTPRequestHandler
httpd = SocketServer.TCPServer(("", PORT), Handler)
print "Freezes static file server now serving on port ", PORT
chdir('builds')
webbrowser.open_new_tab('http://localhost:%s' % PORT)
httpd.serve_forever()
return manager
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 setup_abilian_commands(manager):
"""Register abilian commands on ``manager``.
:param manager: ``flask_script.Manager`` instance to add commands onto
Usage exemple::
from flask_script import Manager
from abilian.commands import setup_abilian_commands
my_manager = Manager(app)
setup_abilian_commands(my_manager)
"""
abilian_manager = globals()["manager"]
manager._options.extend(abilian_manager._options)
for name, command in abilian_manager._commands.items():
manager.add_command(name, command)
manager.add_command("assets", ManageAssets()) # flask-assets
manager.add_command("config", config_manager)
manager.add_command("migrate", MigrateCommand)
return manager
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']
from flask_script import Manager
# Import and use this manager
command_manager = Manager()
# If flask assets is installed - load assets command
try:
from flask_assets import ManageAssets
command_manager.add_command('assets', ManageAssets())
except ImportError:
pass
# If flask migrate is installed - load migrate command
try:
from flask_migrate import MigrateCommand
command_manager.add_command('db', MigrateCommand)
except ImportError:
pass
from .routes import RoutesCommand
command_manager.add_command('routes', RoutesCommand())
from .secret_key import SecretKeyCommand
command_manager.add_command('secret_key', SecretKeyCommand())
from .vendor import VendorManager
command_manager.add_command('vendor', VendorManager)
def _build_assets():
print ('building assets')
ManageAssets(assets, '--parse-templates build')
def _clear_asset_cache():
print ('clearing asset cache')
ManageAssets(assets, 'clean')
password=encrypt_password('password')
)
user_datastore.add_role_to_user(user, admin)
@manager.command
def routes():
""" Prints out all the routes to shell
"""
import urllib.request, urllib.parse, urllib.error
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.parse.unquote("{:50s} {:20s} {}".format(rule.endpoint, methods, url))
output.append(line)
for line in sorted(output):
print (line)
def shell_context():
return dict(app=app)
#runs the app
if __name__ == '__main__':
manager.add_command('shell', Shell(make_context=shell_context))
manager.add_command('assets', ManageAssets(assets_env=assets))
manager.run()
removed
"""
if target == 'index':
cache.delete(index_cache_key())
else:
cache.delete(feed_cache_key(target))
@cache_manager.command
def clear():
"""clear the cache"""
cache.clear()
asset_manager = ManageAssets(assets_env)
asset_manager.help = 'run commands for assets'
def _shell_context():
return dict(current_app=current_app, g=g, db=db, cache=cache,
Series=Series, Chapter=Chapter)
shell_command = Shell(make_context=_shell_context)
shell_command.help = 'run a Python shell inside the Flask app context'
server_command = Server()
server_command.help = 'run the Flask development server i.e. app.run()'
from webapp import create_app
from webapp.models import db, User, Role, Item, Category
load_environment()
# default to dev config
env = getenv('WEBAPP_ENV', 'dev')
app = create_app(f'webapp.config.{env.capitalize()}Config')
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.add_command("assets", ManageAssets(env))
@manager.shell
def make_shell_context():
return dict(
app=app,
db=db,
User=User,
Category=Category,
Item=Item
)
@manager.command
def setup_db():
def main(create_app_func=None):
if not create_app_func:
from shortener_url.wsgi import create_app
create_app_func = create_app
class ServerWithGevent(Server):
help = description = 'Runs the Flask development server with Gevent WSGI Server'
def __call__(self, app, host, port, use_debugger, use_reloader,
threaded, processes, passthrough_errors, **kwargs):
#print("kwargs : ", kwargs)
#{'ssl_key': None, 'ssl_crt': None}
if use_debugger:
app = DebuggedApplication(app, evalex=True)
server = WSGIServer((host, port), app)
try:
print('Listening on http://%s:%s' % (host, port))
server.serve_forever()
except KeyboardInterrupt:
pass
env_config = config_from_env('SHORTURL_SETTINGS', 'shortener_url.settings.Prod')
manager = Manager(create_app_func,
with_default_commands=False)
#TODO: option de config app pour désactiver run counter
manager.add_option('-c', '--config',
dest="config",
default=env_config)
manager.add_command("shell", Shell())
if HAS_GEVENT:
manager.add_command("server", ServerWithGevent(
host = '0.0.0.0',
port=8081)
)
manager.add_command("debug-server", Server(
host = '0.0.0.0',
port=8081)
)
else:
manager.add_command("server", Server(
host = '0.0.0.0',
port=8081)
)
manager.add_command("config", ShowConfigCommand())
manager.add_command("urls", ShowUrlsCommand())
manager.add_command("assets", ManageAssets())
from flask_security import script
manager.add_command('auth-create-user', script.CreateUserCommand())
manager.add_command('auth-create-role', script.CreateRoleCommand())
manager.add_command('auth-add-role', script.AddRoleCommand())
manager.add_command('auth-remove-role', script.RemoveRoleCommand())
manager.add_command('auth-activate-user', script.ActivateUserCommand())
manager.add_command('auth-deactivate-user', script.DeactivateUserCommand())
manager.run()
#!/usr/bin/env python
import sys
import unittest
from flask_assets import ManageAssets
from flask_script import Manager, Shell
from expressvpn_web import app
manager = Manager(app)
logger = app.logger
@manager.command
def test():
tests = unittest.TestLoader().discover('tests', pattern='*.py')
results = unittest.TextTestRunner(verbosity=1).run(tests)
if not results.wasSuccessful():
sys.exit(1)
manager.add_command("shell", Shell(use_ipython=True, use_bpython=False))
# work-around bug in flask-assets
app.jinja_env.assets_environment.environment = app.jinja_env.assets_environment
manager.add_command("assets", ManageAssets(app.jinja_env.assets_environment))
manager.run()
from main import app # DO FIRST: https://github.com/gevent/gevent/issues/446
from flask_assets import ManageAssets
from flask_script import Manager
import gevent
from assets import env
from front.home import *
import settings
manager = Manager(app)
manage_assets = ManageAssets()
manager.add_command(
"assets", manage_assets) # To build assets, just do: ./run.sh assets build
@manager.command
def clean():
env.clean()
@manager.command
def build():
manage_assets.run(['build'])
# some imports for backdoor (nc localhost 2823) and shell (./run.sh shell)
LOCALS = locals()
def get_locals():
import logging
import sys
import os
import os.path
import colorlog
from flask_assets import ManageAssets
sys.path.append(os.path.dirname(__file__))
from spacewiki.app import create_app
APP = create_app()
MANAGER = Manager(APP)
MANAGER.add_command('db', model.MANAGER)
MANAGER.add_command("shell", Shell())
MANAGER.add_command('assets', ManageAssets())
@MANAGER.option('-s',
'--syncdb',
dest='syncdb',
help='Run syncdb on boot',
default=False,
action='store_true')
def runserver(syncdb):
if (syncdb):
model.syncdb()
from gevent.wsgi import WSGIServer
serv = WSGIServer(('', int(os.environ.get('PORT', 5000))),
APP,
log=logging.getLogger("http"))
def configure(self, manager):
assets.directory = STATIC_PATH
assets.url = STATIC_URL
manager.add_command("assets", ManageAssets(assets))
prefix = None if UI_PREFIX == '/' else UI_PREFIX
app.register_blueprint(blueprint, url_prefix=prefix)
@manager.command
def change_user_password(username=None, new_password=None):
if None in [username, new_password]:
print('Username and new_password are required')
exit(0)
user = User.by_username(username)
if user is None:
print('User %s not found' % username)
exit(0)
try:
user.update_password(new_password)
except ValueError as ex:
print(ex)
exit(0)
db.session.commit()
print('Password changed')
manager.add_command("assets", ManageAssets(assets))
manager.add_command("runserver", Server(threaded=True))
if __name__ == '__main__':
manager.run()
removed
"""
if target == 'index':
cache.delete(index_cache_key())
else:
cache.delete(feed_cache_key(target))
@cache_manager.command
def clear():
"""clear the cache"""
cache.clear()
asset_manager = ManageAssets(assets_env)
asset_manager.help = 'run commands for assets'
def _shell_context():
return dict(current_app=current_app,
g=g,
db=db,
cache=cache,
Series=Series,
Chapter=Chapter)
shell_command = Shell(make_context=_shell_context)
shell_command.help = 'run a Python shell inside the Flask app context'