def launch() -> None: # pragma: no cover
"""Launch the RAPyDo-based HTTP API server"""
mywait()
if initializing():
print_and_exit(
"Please wait few more seconds: initialization is still in progress"
)
current_app = Env.get("FLASK_APP", "").strip()
if not current_app:
os.environ["FLASK_APP"] = f"{current_package}.__main__"
args = [
"run",
"--host",
BIND_INTERFACE,
"--port",
Env.get("FLASK_PORT", "8080"),
"--reload",
"--no-debugger",
"--eager-loading",
"--with-threads",
]
# Call to untyped function "FlaskGroup" in typed context
fg_cli = FlaskGroup() # type: ignore
# Call to untyped function "main" in typed context
fg_cli.main(prog_name="restapi", args=args) # type: ignore
log.warning("Server shutdown")
def main(args):
current_app = os.environ.get('FLASK_APP')
if current_app is None or current_app.strip() == '':
os.environ['FLASK_APP'] = '{}.__main__'.format(current_package)
fg_cli = FlaskGroup()
options = {'prog_name': 'restapi', 'args': args}
# cannot catch for CTRL+c
fg_cli.main(**options)
def main(args): # pragma: no cover
current_app = os.getenv("FLASK_APP")
if current_app is None or current_app.strip() == "":
os.environ["FLASK_APP"] = f"{current_package}.__main__"
fg_cli = FlaskGroup()
options = {"prog_name": "restapi", "args": args}
# cannot catch for CTRL+c
fg_cli.main(**options)
def handler(event, context):
""" Lambda event handler, invokes the WSGI wrapper and handles command invocation
"""
if "_serverless-wsgi" in event:
import shlex
import subprocess
from werkzeug._compat import StringIO, to_native
native_stdout = sys.stdout
native_stderr = sys.stderr
output_buffer = StringIO()
try:
sys.stdout = output_buffer
sys.stderr = output_buffer
meta = event["_serverless-wsgi"]
if meta.get("command") == "exec":
# Evaluate Python code
exec(meta.get("data", ""))
elif meta.get("command") == "command":
# Run shell commands
result = subprocess.check_output(
meta.get("data", ""), shell=True, stderr=subprocess.STDOUT
)
output_buffer.write(to_native(result))
elif meta.get("command") == "manage":
# Run Django management commands
from django.core import management
management.call_command(*shlex.split(meta.get("data", "")))
elif meta.get("command") == "flask":
# Run Flask CLI commands
from flask.cli import FlaskGroup
flask_group = FlaskGroup(create_app=_create_app)
flask_group.main(
shlex.split(meta.get("data", "")), standalone_mode=False
)
else:
raise Exception("Unknown command: {}".format(meta.get("command")))
except subprocess.CalledProcessError as e:
return [e.returncode, e.output.decode("utf-8")]
except: # noqa
return [1, traceback.format_exc()]
finally:
sys.stdout = native_stdout
sys.stderr = native_stderr
return [0, output_buffer.getvalue()]
else:
return serverless_wsgi.handle_request(wsgi_app, event, context)
def main(args, another_app=None):
if another_app is not None:
os.environ[APP] = '%s.py' % another_app
else:
current_app = os.environ.get(APP)
if current_app is None or current_app.strip() == '':
os.environ[APP] = '%s.__main__' % current_package
cli = FlaskGroup()
options = {
'prog_name': 'restapi',
'args': args,
}
# cannot catch for CTRL+c
cli.main(**options)
class FardelManager:
def __init__(self, fardel: Fardel):
self.fardel = fardel
Migrate(fardel.app, db)
# self.register_commands()
self.cli = FlaskGroup(
help="A general utility script for Fardel applications.",
create_app=self.get_flask_app,
)
def get_flask_app(self, *args, **kwargs):
return self.fardel.app
def register_commands(self):
self.fardel.app.cli.command(create_admin)
def run(self):
self.cli.main()
s.start()
@cli.command()
def list_routers():
table = [["URL", "METHOD", "ENDPOINT"]]
s_max = [25, 25, 25]
for rule in app.url_map.iter_rules():
name = rule.rule
if len(name) > s_max[0]:
s_max[0] = len(name)
method = ",".join(rule.methods)
if len(method) > s_max[1]:
s_max[1] = len(method)
endpoint = rule.endpoint
if len(method) > s_max[2]:
s_max[2] = len(endpoint)
table.append([name, method, endpoint])
s_max = [i + 2 for i in s_max]
for t in table:
print("|{0}|{1}|{2}|".format(*["-" * s_max[i] for i in range(3)]))
print("|{0}|{1}|{2}|".format(
*[t[i] + " " * (s_max[i] - len(t[i])) for i in range(3)]))
if __name__ == '__main__':
if len(sys.argv) == 1:
app.run()
else:
cli.main()
import click
from flask.cli import FlaskGroup
oy_group = FlaskGroup(name="oy",
add_default_commands=False,
add_version_option=False,
load_dotenv=True)
from . import database
from . import user
if __name__ == "__main__":
oy_group.main()
exec(code, dict(__file__=activate_this))
app = create_app(os.path.join(AppConfig.BASE_DIR, "config.yml"))
fg = FlaskGroup(app)
@app.shell_context_processor
def make_shell_context():
model_dict = dict(app=app, db=db, cache=cache, tasks=tasks)
return model_dict
@fg.command('recreate_db', help='Recreates a local database, You probably should not use this on production.')
def recreate_db():
db.drop_all()
db.create_all()
db.session.commit()
@fg.command("run", help="run server")
def runserver():
# Aliyun.sync_events()
# tasks.run("cron", "sync_aliyun_events")
# tasks.run.cron("* * * * *", "aliyun sync_events", mn="cron", fn="sync_aliyun_events")
app.run(host=app.config["HOST"], port=app.config["PORT"], use_reloader=True)
if __name__ == '__main__':
sys.exit(fg.main())
)
@cli.command()
def frontend(with_appcontext=False):
subprocess.call(
['node', 'server.js'],
)
@cli.command()
@click.argument('username')
def create_user(username):
"""Creates user from passed params."""
password = click.prompt('Password', hide_input=True)
if not password:
create_user(username)
user = User(username=username)
user.set_password(password)
db.session.add(user)
db.session.commit()
@cli.command()
def run():
app.run(host='0.0.0.0', port=8080, debug=True)
if __name__ == "__main__":
cli.main()