filename[:-3] for filename in config_files))
elif not app.APP.config.from_pyfile(
os.path.join(EISITIRIO_DIR, 'config', config_files[0])):
print 'Could not load config file {0}'.format(
os.path.join(EISITIRIO_DIR, 'config', config_files[0]))
else:
return app.APP
sys.exit(-1)
script.Server.help = 'Run the development server'
MIGRATE = migrate.Migrate(app.APP, db.DB)
MANAGER = script.Manager(get_app, with_default_commands=False)
MANAGER.add_option('config',
default=None,
help="Configuration file to load before running commands")
# MANAGER.add_command('bpython', run_bpython.BpythonCommand)
MANAGER.add_command('cron', cron.CronCommand)
MANAGER.add_command('fix_graduand_postage',
fix_graduand_postage.FixGraduandPostageCommand)
MANAGER.add_command('db', migrate.MigrateCommand)
MANAGER.add_command('prefill', prefill.PrefillCommand)
MANAGER.add_command('run', script.Server)
MANAGER.add_command('update_battels', update_battels.UpdateBattelsCommand)
MANAGER.add_command('send_qr_tickets', create_qr_codes.CreateQRCodes)
MANAGER.add_command('send_list_of_tickets_to_webmaster',
#!/usr/bin/env python2.7
import buzzwebpanel
from buzzwebpanel import db
import buzzwebpanel.models
import flask_script
import flask_migrate
manager = flask_script.Manager(buzzwebpanel.app)
# Database migrations
migrate = flask_migrate.Migrate(buzzwebpanel.app, buzzwebpanel.db)
manager.add_command('db', flask_migrate.MigrateCommand)
if __name__ == '__main__':
manager.run()
# Loading commands
crons = os.path.join(os.path.dirname(__file__), "crons")
for file in os.listdir(crons):
if not os.path.isfile(os.path.join(crons, file)):
continue
if file == '__init__.py':
continue
if file[-3:] != '.py':
continue
filename = file[:-3]
objectname = ''.join([x.capitalize() for x in filename.split('_')])
command = import_string('crons.{0}.{1}'.format(filename, objectname))
command_name = getattr(command, "name", None)
if command_name is None:
command_name = filename
manager.add_command(command_name, command())
if __name__ == "__main__":
manager = flask_script.Manager(app_factory)
manager.add_command('db', MigrateCommand)
load_commands(manager)
manager.run()
# Copyright (C) Electronic Arts Inc. All rights reserved.
import flask_script
import muffin.factories
import muffin.manage.seed as mg
application = muffin.factories.create_app('muffin.cfg')
manager = flask_script.Manager(application)
manager.add_command('seed', mg.SeedDatabase)
if __name__ == "__main__":
manager.run()
from puffin import app
from puffin import core
from puffin.core import db
from puffin.core import queue
from puffin.core import mail
from puffin.core import security
from puffin.core import docker
from puffin.core import applications
from puffin.core import machine
from puffin.core import compose
from puffin.core import network
from puffin.core import backup as backup_module
manager = flask_script.Manager(app, with_default_commands=False)
@manager.command
@manager.option("-r", "--reload", action="store_true",
help="Reload the server if any file changes")
def server(reload=False):
"Run the server"
if reload:
reload_module.reload_me("server")
else:
waitress.serve(app, host=app.config["HOST"], port=app.config["PORT"],
threads=app.config["THREADS"])
def make_shell_context():
import io import logging import typing import flask import flask_script import latex from sqlalchemy.orm.session import Session import web.db import web.storage logger = logging.getLogger(__name__) PubSubCommand = flask_script.Manager(help='Run latex files compilation') # TODO: implement later # import pathlib # import tempfile # import zipfile # # def build_pfd_from_zip(self, entrypoint: str, stream: io.RawIOBase): # with zipfile.ZipFile(stream) as myzip: # myzip.testzip() # with tempfile.TemporaryDirectory() as tempdir: # myzip.extractall(tempdir) # entry_path = pathlib.Path(tempdir) / entrypoint # return latex.build_pdf( # entry_path.open(), texinputs=[str(entry_path.parent)])
#!/usr/bin/env python2.7
import get5
from get5 import db
import get5.models
import flask_script
import flask_migrate
manager = flask_script.Manager(get5.app)
# Database migrations
migrate = flask_migrate.Migrate(get5.app, get5.db)
manager.add_command('db', flask_migrate.MigrateCommand)
if __name__ == '__main__':
manager.run()
# -*- coding:utf-8 -*-
import flask_script as script
import commands
from main import app_factory
try:
import config
except:
print "WARNING: missing config, using defaults file"
import config_defaults as config
manager = script.Manager(app_factory)
@manager.command
def list_routes():
import urllib
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)
"""
migrate.py: Handle database migrations
__author__ = "Fernando P. Lopes"
__email__ = "*****@*****.**"
"""
import flask_script as fs
import flask_migrate as fm
from app import app
from app import db
from app.models import *
migrate = fm.Migrate(app, db)
manager = fs.Manager(app)
manager.add_command('db', fm.MigrateCommand)
if __name__ == '__main__':
manager.run()
import re
import json
import pprint
import time
import datetime
from flask import current_app
from flask import render_template_string
import flask_script
from flask_script.commands import ShowUrls
from web.application import create_app
from share.kit import kit
from share.utils import alloc_autoid, get_appinfo_by_appkey, create_appinfo
manager = flask_script.Manager(create_app)
manager.add_option('-c', '--config', dest='config', required=False)
class GServer(flask_script.Command):
"""
Runs the Flask gevent server
:param host: server host
:param port: server port
"""
help = description = 'Runs the Flask gevent server'
def __init__(self, host='127.0.0.1', port=5000):
super(GServer, self).__init__()
"""Main program for Microsoft Graph Connect sample.
To run the app, execute the command "python manage.py runserver" and then
open a browser and go to http://localhost:5000/
"""
import flask_script
import connectsample
import drive_service
#MANAGER = flask_script.Manager(connectsample.app)
MANAGER = flask_script.Manager(drive_service.app)
MANAGER.add_command('runserver', flask_script.Server(host='localhost'))
MANAGER.run()
from fa_test.app import db
import flask_script
import data as users_data
manager = flask_script.Manager("User/Role Operations")
@manager.command
def initialize_data():
""" Populate with initial user/role data. """
users_data.setup_initial_data(db.session)
import os
import sys
import flask_script as script
from sirius.models import hardware
from sirius.models import user as user_model
from sirius.models.db import db
from sirius.coding import bitshuffle
from sirius.coding import claiming
def sub_opts(app, **kwargs):
pass
fake_manager = script.Manager(sub_opts, usage="Fake printer interactions.")
@fake_manager.command
def printer():
device_address = os.urandom(8).hex()
xor = bitshuffle.hardware_xor_from_device_address(device_address)
secret = os.urandom(5).hex()
cc = claiming.encode(xor, int(secret, 16))
printer = hardware.Printer(
device_address=device_address,
hardware_xor=xor,
)
db.session.add(printer)
db.session.commit()
import flask_script
import re
manager = flask_script.Manager(usage="Setup NodeDefender Configuration")
@manager.command
def all():
NodeDefender.manage.setup.general.general()
NodeDefender.manage.setup.database.database()
NodeDefender.manage.setup.redis.redis()
NodeDefender.manage.setup.mail.mail()
NodeDefender.manage.setup.logging.logging()
NodeDefender.manage.setup.celery.celery()
print_topic("Configuration Successfully Updated!")
return True
def get_chunks(message):
return [ message[i:i+38] for i in range(0, len(message), 38)]
def print_message(message):
print("#")
if len(message) > 38:
for chunk in get_chunks(message):
print("#" + chunk.center(38))
else:
print("#" + message.center(38))
print("#")
return True
def print_topic(topic):
print("****************************************")
import datetime as dt
import flask
import flask_script as script
from flask_migrate import Migrate, MigrateCommand, stamp
from alembic.migration import MigrationContext
from alembic.script import ScriptDirectory
import six
from .. import create_app, db, migrate, models, auth, killmail
from .datetime import utc
if six.PY3:
unicode = str
manager = script.Manager(create_app)
class AbsolutePathAction(argparse.Action):
"""Custom argparse.Action that transforms path strings into absolute paths.
"""
def __call__(self, parser, namespace, values, option_string=None):
current_absolute = os.path.abspath(os.getcwd())
if isinstance(values, str):
new_values = os.path.join(current_absolute, values)
else:
new_values = []
for value in values:
real_path = os.path.join(current_absolute, values)
new_values.append(real_path)
setattr(namespace, self.dest, new_values)
"""Main program for Microsoft Graph Connect sample.
To run the app, execute the command "python manage.py runserver" and then
open a browser and go to http://localhost:5000/
"""
import flask_script
import connectsample
MANAGER = flask_script.Manager(connectsample.app)
MANAGER.add_command('runserver', flask_script.Server(host='localhost'))
MANAGER.run()
#!/usr/bin/env python
import flask_migrate
import flask_script
from seabus.web.socketio import socketio
from seabus.common.database import db
from seabus.web.web import create_app as create_web_app
from seabus.nmea_listen.listener import listen
web_app = create_web_app('Dev')
web_manager = flask_script.Manager(web_app)
flask_migrate.Migrate(web_app, db)
web_manager.add_command('db', flask_migrate.MigrateCommand)
@web_manager.command
def webdev():
socketio.run(
web_app,
host='0.0.0.0',
port=5000,
debug=True,
use_reloader=True,
)
@web_manager.command
def webprod():
web_app.config.from_object('seabus.web.config.Prod')
socketio.run(
import tripadvisor
import flask_script as script
from flask_migrate import Migrate, MigrateCommand
from prometheus_flask_exporter.multiprocess import UWsgiPrometheusMetrics
from tripadvisor.models import User, Follow, TripAdvisor, Comment,\
Love, Child_cmt, Click, Comment_like
app = tripadvisor.create_application()
migrate = Migrate(app, tripadvisor.db)
manager = script.Manager(app)
manager.add_command('runserver', script.Server(host='0.0.0.0', port=8000))
manager.add_command('shell',
script.Shell(make_context=lambda: {'current_app': app}))
try:
metrics = UWsgiPrometheusMetrics(app=app,
default_labels={'project': 'hotel'})
metrics.start_http_server(9200)
except ModuleNotFoundError:
pass
def make_shell_context():
return dict(app=app,
db=tripadvisor.db,
User=User,
Follow=Follow,
Food=Food,
Survey=Survey,
TripAdvisor=TripAdvisor)
# practice.
request_id = str(uuid.uuid4())
instrumentation = {'client-request-id' : request_id,
'return-client-request-id' : 'true'}
headers.update(instrumentation)
# Create the email that is to be sent via the Graph API
email = {'Message': {'Subject': 'Welcome to the Microsoft Graph Connect sample for Python',
'Body': {'ContentType': 'HTML',
'Content': render_template('email.html', name=name)},
'ToRecipients': [{'EmailAddress': {'Address': email_address}}]
},
'SaveToSentItems': 'true'}
response = requests.post(url=send_mail_url,
headers=headers,
data=json.dumps(email),
verify=False,
params=None)
if response.ok:
return 'SUCCESS'
else:
return '{0}: {1}'.format(response.status_code, response.text)
MANAGER = flask_script.Manager(app)
MANAGER.add_command('runserver',flask_script.Server(host='localhost'))
MANAGER.run()
os.path.join(app.root_path, "dumbrss.db")))
if os.getenv("DRSS_CONFIG") is None:
os.environ["DRSS_CONFIG"] = os.path.join(app.root_path, "config.py")
app.config.from_envvar("DRSS_CONFIG", silent=True)
if app.config["SECRET_KEY"] is None:
f = open(os.environ["DRSS_CONFIG"], "a")
app.config["SECRET_KEY"] = os.urandom(32)
f.write("SECRET_KEY = " + str(app.config["SECRET_KEY"]) + "\n")
f.close()
# Deprecated
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
db = flask_sqlalchemy.SQLAlchemy(app)
manager = flask_script.Manager(app)
# Set the timezone to UTC for consistent time stamps
os.environ["TZ"] = "UTC"
time.tzset()
class Entry(db.Model):
id = db.Column(db.Integer, primary_key=True)
feed_id = db.Column(db.Integer, db.ForeignKey("feed.id"))
feed = db.relationship("Feed",
backref=db.backref("entries", lazy="dynamic"))
link = db.Column(db.Text)
title = db.Column(db.Text)
summary = db.Column(db.Text)
author = db.Column(db.Text)
import flask_script
from wg_forge_backend_test import create_application
from wg_forge_backend_test.extensions import database
from wg_forge_backend_test.cats import models
from wg_forge_backend_test.commands import DatabaseFiller
from wg_forge_backend_test.conf import Config
manager = flask_script.Manager(create_application)
manager.add_command("runserver", flask_script.Server())
manager.add_command("shell", flask_script.Shell())
manager.add_command("fill_database", DatabaseFiller())
@manager.shell
def make_shell_context():
return dict(app=create_application(),
config=Config,
db=database,
models=models)
def main():
manager.run()
if __name__ == '__main__':
main()
