def init_manager(application, port, extra_directories=()):

    manager = Manager(application)

    extra_files = list(get_extra_files(extra_directories))

    application.logger.info("Watching {} extra files".format(len(extra_files)))

    manager.add_command(
        "runserver",
        Server(port=port, extra_files=extra_files)
    )

    @manager.command
    def runprodserver():
        from waitress import serve
        serve(application, port=port)

    @manager.command
    def list_routes():
        """List URLs of all application routes."""
        for rule in sorted(manager.app.url_map.iter_rules(), key=lambda r: r.rule):
            print("{:10} {}".format(", ".join(rule.methods - set(['OPTIONS', 'HEAD'])), rule.rule))

    return manager
Пример #2
0
def init_manage(config_name):
    app = create_app(config_name or 'default')
    manager = Manager(app)
    migrate = Migrate(app, db)

    def make_shell_context():
        return dict(app=app, db=db, User=User, Role=Role)
    manager.add_command('shell', Shell(make_context=make_shell_context))
    manager.add_command('db', MigrateCommand)

    return manager
Пример #3
0
def create_app(config_name):
    app = Flask(__name__)
    app.config.from_object(config[config_name])
    Bootstrap(app)
    db = SQLAlchemy(app)
    migrate = Migrate(app, db)
    manager = Manager(app)
    manager.add_command('db', MigrateCommand)
    login_manager = LoginManager()
    login_manager.init_app(app)
    login_manager.login_view = 'login'
    return app, db, migrate, manager, login_manager
Пример #4
0
def main():
    app = create_app()
    Migrate(app, db)

    manager = Manager(app)
    manager.add_command('db', MigrateCommand)
    manager.add_command('generate_password_hash', GeneratePasswordHash)
    manager.add_command('generate-config', ConfigTemplate)
    manager.run()
Пример #5
0
    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
Пример #6
0
    def test_pagination(self):
        self.app.config['SERVER_NAME'] = 'www.example.com'
        self.app.config['SITEMAP_INCLUDE_RULES_WITHOUT_PARAMS'] = True
        self.app.config['SITEMAP_MAX_URL_COUNT'] = 10
        sitemap = Sitemap(app=self.app)
        now = datetime.now().isoformat()

        @self.app.route('/')
        def index():
            pass

        @self.app.route('/first')
        def first():
            pass

        @self.app.route('/second')
        def second():
            pass

        @self.app.route('/<username>')
        def user(username):
            pass

        @sitemap.register_generator
        def user():
            for number in range(20):
                yield 'user', {'username': '******'.format(number)}

        directory = mkdtemp()
        manager = Manager(self.app)
        manager.add_command('sitemap', script.Sitemap())

        try:
            manager.handle('manage.py', ['sitemap', '-o', directory])

            with self.app.test_client() as c:
                data = c.get('/sitemap.xml').data
                data1 = c.get('/sitemap1.xml').data

                assert b('sitemapindex') in data
                assert len(data1) > 0

                with open(os.path.join(directory, 'sitemap.xml'), 'r') as f:
                    assert b(f.read()) == data

                with open(os.path.join(directory, 'sitemap1.xml'), 'r') as f:
                    assert b(f.read()) == data1
        finally:
            shutil.rmtree(directory)
Пример #7
0
class EmailSendingTests(ViewTestCase):
    BASE_APP_CONFIG = ViewTestCase.BASE_APP_CONFIG.copy()

    BASE_APP_CONFIG.update(
        MAIL_USERNAME='******',
        NOI_DEPLOY='noi.org',
        SECURITY_EMAIL_SENDER='*****@*****.**',
        MAIL_SUPPRESS_SEND=True,
    )

    def setUp(self):
        super(EmailSendingTests, self).setUp()
        self.manager = Manager(self.app)
        self.manager.add_command('noi1', noi1.Noi1Command)
        self.mail = self.app.extensions.get('mail')

        noi1.set_users_from_json([SAMPLE_USER])
        self.user = noi1.add_user_to_db(SAMPLE_USER, password='******')
        db.session.commit()

        assert self.user.noi1_migration_info.email_sent_at is None

    def run_command(self, *args):
        self.manager.handle('', ['noi1'] + list(args))

    def test_send_all_migration_instructions_works(self):
        with self.mail.record_messages() as outbox:
            self.run_command('send_all_migration_instructions')
            self.assertEqual(len(outbox), 1)

        with self.mail.record_messages() as outbox:
            self.run_command('send_all_migration_instructions')
            self.assertEqual(len(outbox), 0)

    def test_send_migration_instructions_works(self):
        with self.mail.record_messages() as outbox:
            self.run_command('send_migration_instructions',
                             '*****@*****.**')
            self.assertEqual(len(outbox), 1)
            msg = outbox[0]
            self.assertEqual(msg.sender, '*****@*****.**')
            self.assertEqual(msg.recipients, ['*****@*****.**'])
            assert 'https://noi.org' in msg.body

            delta = (datetime.datetime.now() -
                     self.user.noi1_migration_info.email_sent_at)

            assert delta.total_seconds() < 60
Пример #8
0
    def setUp(self):
        super(EmailSendingTests, self).setUp()
        self.manager = Manager(self.app)
        self.manager.add_command('noi1', noi1.Noi1Command)
        self.mail = self.app.extensions.get('mail')

        noi1.set_users_from_json([SAMPLE_USER])
        self.user = noi1.add_user_to_db(SAMPLE_USER, password='******')
        db.session.commit()

        assert self.user.noi1_migration_info.email_sent_at is None
Пример #9
0
    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')
Пример #10
0
    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']
Пример #11
0
def create_app(configuration_file):
    """
    Create the app.

    :param configuration_file: Path of the configuration file to use for deployment settings
    :return: New application to use
    """
    # Setup the Flask app instance and configuration
    app = Flask(__name__)
    app.config.from_object(settings)  # Setup default settings
    app.config.from_pyfile(configuration_file, silent=True)  # Override with user settings -- and silence failures

    # Setup a little bit of console logging
    if app.config['DEBUG']:
        app.logger.setLevel(DEBUG)
    else:
        app.logger.setLevel(INFO)
        app.logger.addHandler(StreamHandler())

    manager = Manager(app)

    # Initialize the Socket.io Stream and bind it to the app instance (Only one stream per app at this time)
    async_mode = 'threading' if app.config['DEBUG'] else 'gevent'
    create_stream(app, resource='/api/v1/stream', async_mode=async_mode)

    # Add all Flask-Script manager commands
    manager.add_command('runserver', RunCommand)
    manager.add_command('clean', Clean)
    manager.add_command('urls', ShowUrls)

    # Create simple to use function on the app for starting commands
    # noinspection PyUnusedLocal
    def _cli(self):
        manager.run()
    # noinspection PyUnresolvedReferences
    app.cli = _cli.__get__(app, app.__class__)

    # Load all blueprints
    app.register_blueprint(api_blueprint, url_prefix='/api/v1')
    app.register_blueprint(ui_blueprint, url_prefix='')

    return app
Пример #12
0
Файл: cli.py Проект: drivet/yawt
def create_manager(app=None):
    """Create the command line manager"""
    app_supplied = True
    if not app:
        app = create_app()
        app_supplied = False
    manager = Manager(app)

    server = Server(use_debugger=True, use_reloader=True)
    server.description = 'runs the yawt local server.'
    manager.add_command('runserver', server)
    manager.add_command('newsite', NewSite())
    manager.add_command('walk', Walk())

    if app_supplied:
        _handle_cli_init(manager)
    else:
        with app.test_request_context():
            _handle_cli_init(manager)

    return manager
Пример #13
0
from abc import ABC

from flask_script import (Command, Manager)

from core import create_app
from core.config import BaseConfig

app = create_app(BaseConfig)

manager = Manager(app)


class MyServer(Command, ABC):
    def __call__(self, *args, **kwargs):
        app.run('0.0.0.0', 8080, threaded=True, use_reloader=True)


manager.add_command('run', MyServer())

if __name__ == '__main__':
    manager.run()
Пример #14
0
photos = UploadSet('photos', IMAGES)  # Flask-Uploads
app.config['UPLOADED_PHOTOS_DEST'] = join(photos_folder_rel_path,
                                          photos_folder)  # Flask-Uploads
app.config.from_object(Config)  # imports app configuration from config.py
configure_uploads(app, photos)
######## FLASK-UPLOADS ###############

db = SQLAlchemy(app)  # create database connection object
migrate = Migrate(app,
                  db)  # creates a migration object for the app db migrations]\
# mail = Mail(app)

# TO MANAGE THE MIGRATIONS WITH FLASK-SCRIPT WITH PYTHON EXTERNAL SCRIPTS > goes together to migrations for migraing db
# server = Server(host = '192.168.1.17', port = 8000, debug = True)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
manager.add_command('runserver', Server(host=None, port=None))

#############################
# Begin Import Models
#############################
from fantaso.bp_shop.models import Product, Order, ProductImage
# from fantaso.bp_shop.models import Product, Order
# from fantaso.models import Farm, Field, DailyFieldInput, Crop
# from fantaso.models import Agrimodule, Agrisensor, Measurement, Agripump, Pump
#############################
# End Import Models
#############################

#############################
Пример #15
0
from flask_script import Command, Manager, Shell

from jasmine_app import create_app
from migrate import run

app = create_app()
manager = Manager(app)

manager.add_command("shell", Shell())
manager.add_command("migrate", Command(run))

if __name__ == "__main__":
    manager.run()
Пример #16
0
from thoth.common import SafeJSONEncoder
from thoth.common import init_logging
from thoth.storages import SolverResultsStore
import thoth_user_api

from .configuration import Configuration

# Expose for uWSGI.
app = connexion.App(__name__)
application = app.app
init_logging()
_LOGGER = logging.getLogger('thoth.user_api')

app.add_api(Configuration.SWAGGER_YAML_PATH)
application.json_encoder = SafeJSONEncoder
manager = Manager(application)
# Needed for session.
application.secret_key = Configuration.APP_SECRET_KEY


@app.route('/')
def base_url():
    """Redirect to UI by default."""
    return redirect('api/v1/ui')


@app.route('/api/v1')
def api_v1():
    """Provide a listing of all available endpoints."""
    paths = []
Пример #17
0
from flask_script import Manager

from flask_bcolz.app import create_app

manager = Manager(create_app())

if __name__ == "__main__":
    manager.run()
Пример #18
0
# coding=utf-8

from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager

from websock.DB import socketio, DB
from websock import create_app

if __name__ == '__main__':
    app = create_app()
    # app.app_context().push()
    migrate = Migrate(app, DB)
    manager = Manager(app)
    manager.add_command('db', MigrateCommand)
    manager.add_command('runserver',
                        socketio.run(app=app, host='0.0.0.0', port=5010))
    manager.run()
Пример #19
0
import os
from app import create_app, socketio, db, login_manager
from app.models import User
from flask_script import Manager, Shell

app = create_app(os.getenv('FLASK_CONFIG') or 'default')
manager = Manager(app)
with app.app_context():
    db.create_all()


def make_shell_context():
    return dict(app=app, db=db, User=User)


@login_manager.user_loader
def load_user(user_id):
    return User.query.filter_by(id=int(user_id)).first()


manager.add_command("shell", Shell(make_context=make_shell_context))

if __name__ == '__main__':
    socketio.run(app, debug=False)
Пример #20
0
app.config['MAIL_SERVER'] = 'smtp.gmail.com'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USE_SSL'] = True
app.config[
    'MAIL_USERNAME'] = '******'  #La cuenta de correo electronico de donde saldran los correos
app.config['MAIL_PASSWORD'] = ''
app.config['UPLOAD_FOLDER'] = os.path.join(BASE_DIR, 'static')
jwt = JWTManager(app)

db.init_app(app)

Migrate(app, db)
CORS(app)
bcrypt = Bcrypt(app)
mail = Mail(app)
manager = Manager(app)
manager.add_command("db", MigrateCommand)


@app.route("/")
def root():
    return render_template('index.html')


@app.route('/login', methods=['POST'])
def login():
    if not request.is_json:
        return jsonify({"msg": "The number is not correct"}), 400

    email = request.json.get('email', None)
    password = request.json.get('password', None)
Пример #21
0
from flask_script import Manager, Shell, Server
from flask_script.commands import ShowUrls

from MarathonMR.app import create_app
from MarathonMR.config import ProdConfig, DevConfig

if os.environ.get("ENV") == 'prod':
    app = create_app(ProdConfig)
else:
    app = create_app(DevConfig)

HERE = os.path.abspath(os.path.dirname(__file__))
TEST_PATH = os.path.join(HERE, 'tests')

manager = Manager(app)


def _make_context():
    return {'app': app}


@manager.command
def test():
    import pytest
    exit_code = pytest.main([TEST_PATH, '--verbose'])
    return exit_code


manager.add_command('server', Server(port=1234))
manager.add_command('shell', Shell(make_context=_make_context))
Пример #22
0
def main(create_app_func=None):
    """
    TODO: commands pour créer fixtures de chaque mode pour démo
    """
    if not create_app_func:
        from mongo_mail_web.wsgi import create_app
        create_app_func = create_app

    class ServerWithGevent(Server):
        help = description = 'Runs the Flask development server with WSGI SocketIO Server'

        def __call__(self, app, host, port, use_debugger, use_reloader,
                     threaded, processes, passthrough_errors):
            #console_path='/console'
            if use_debugger:
                app = DebuggedApplication(app, evalex=True)
            """
            TODO: 
            from policyng_web.clients import tasks
            tasks.start_all(app)
            """
            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('MMW_SETTINGS',
                                 'mongo_mail_web.settings.Prod')

    manager = Manager(create_app_func, with_default_commands=False)
    manager.add_option('-c', '--config', dest="config", default=env_config)

    manager.add_command("shell", Shell())

    manager.add_command("server", ServerWithGevent(host='0.0.0.0', port=8081))

    manager.add_command("config", ShowConfigCommand())
    manager.add_command("urls", ShowUrlsCommand())
    manager.add_command("reset-db", ResetCommand())
    manager.add_command("reset-metrics", ResetMetrics())

    manager.add_command('users', ShowUsersCommand())
    manager.add_command('create-superadmin', CreateSuperAdminCommand())

    manager.run()
Пример #23
0
from flask_script import Manager, Server
from app import create_app

# Creating app instance
app = create_app('development')

manager = Manager(app)
manager.add_command('server', Server)

if __name__ == "__main__":
    manager.run()
Пример #24
0
from aleph.logic.collections import delete_collection, delete_documents
from aleph.logic.alerts import check_alerts
from aleph.logic.roles import update_role
from aleph.logic.entities import bulk_load
from aleph.logic.xref import xref_collection
from aleph.logic.permissions import update_permission
from aleph.logic.triples import export_triples
from aleph.util import load_config_file


log = logging.getLogger('aleph')
flask_script_commands.text_type = str

app = create_app()
mount_app_blueprints(app)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
manager.add_command('routes', ShowUrls)


@manager.command
def collections():
    """List all collections."""
    for collection in Collection.all():
        print collection.id, collection.foreign_id, collection.label


@manager.command
def alerts():
    """Generate alert notifications."""
    check_alerts.apply_async([], priority=8)
Пример #25
0
#!/usr/bin/env python
import os, json, string, sys
from flask import request, current_app
from collections import defaultdict
from app import create_app, db
from app.models import User, Role, Permission, Post, EntityStream, SearchKey
from flask_script import Manager, Shell
from flask_migrate import Migrate, MigrateCommand
from flask.ext.alchemydumps import AlchemyDumps, AlchemyDumpsCommand
from kitchen.text.converters import to_unicode, to_bytes

app = create_app(os.getenv('FLASK_CONFIG') or 'default')
manager = Manager(app)
migrate = Migrate(app, db)


def make_shell_context():
    return dict(app=app,
                db=db,
                User=User,
                Role=Role,
                Permission=Permission,
                Post=Post)


manager.add_command("shell", Shell(make_context=make_shell_context))
manager.add_command('db', MigrateCommand)

alchemydumps = AlchemyDumps(app, db)
manager.add_command('alchemydumps', AlchemyDumpsCommand)
Пример #26
0
"""Manage the database and some other items required to run the API
"""
import logging

from flask import url_for
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager  # class for handling a set of commands

# models included so that migrate can build the database migrations
from auth_api import models  # pylint: disable=unused-import
from auth_api import create_app
from auth_api.models import db

APP = create_app()
MIGRATE = Migrate(APP, db)
MANAGER = Manager(APP)

MANAGER.add_command('db', MigrateCommand)


@MANAGER.command
def list_routes():
    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)
Пример #27
0
def main():
    app = make_app(set_path=True)
    migrate.init_app(app, db, os.path.join(app.root_path, '..', 'migrations'))
    manager = Manager(app, with_default_commands=False)

    manager.add_command('shell', IndicoShell())
    manager.add_command('admin', IndicoAdminManager)
    manager.add_command('db', DatabaseManager)
    manager.add_command('plugindb', PluginDatabaseManager)
    manager.add_command('runserver', IndicoDevServer())
    manager.add_command('i18n', IndicoI18nManager)
    manager.add_command('celery', IndicoCeleryCommand)
    signals.plugin.cli.send(manager)

    try:
        manager.run()
    except KeyboardInterrupt:
        print
        sys.exit(1)
Пример #28
0
#!/usr/bin/env python

from flask_assets import ManageAssets
from flask_script import Manager

from app import app, assets, db
from app.models import User


manager = Manager(app)
manager.add_command('assets', ManageAssets(assets))


@manager.command
def db_create():
    db.create_all()


@manager.command
def db_seed():
    user = User(
        first_name='Gabi',
        last_name='Nagy',
        email='*****@*****.**',
        picture_url='http://helpfulsheep.com/assets/helpful-sheep.png',
        social_id='facebook_12345',
        social_profile_url='http://helpfulsheep.com/',
    )
    db.session.add(user)
    db.session.commit()
Пример #29
0
import os
import subprocess
import shutil
import urllib.request
from collections import defaultdict

from flask_script import Manager
from app import app, db
from app.models import BinSet, EssentialGene

from scripts import export_data


manager = Manager(app)


def setup_database():
    db.drop_all()
    db.create_all()
    for line in open('data/essential.hmm', 'r'):
        if line.startswith('NAME'):
            gene = line.rstrip().split(' ')[-1]
            db.session.add(EssentialGene(name=gene, source='essential'))
    db.session.commit()


@manager.command
def createdb():
    setup_database()

Пример #30
0
        for copr in coprs_logic.CoprsLogic.get_all():
            CoprWhoosheer.insert_copr(writer, copr)
        writer.commit(optimize=True)


class GenerateRepoPackagesCommand(Command):
    """
    go through all coprs and create configuration rpm packages
    for them, if they don't already have it
    """

    def run(self):
        generate_repo_packages.main()


manager = Manager(app)
manager.add_command("test", TestCommand())
manager.add_command("create_sqlite_file", CreateSqliteFileCommand())
manager.add_command("create_db", CreateDBCommand())
manager.add_command("drop_db", DropDBCommand())
manager.add_command("create_chroot", CreateChrootCommand())
manager.add_command("alter_chroot", AlterChrootCommand())
manager.add_command("display_chroots", DisplayChrootsCommand())
manager.add_command("drop_chroot", DropChrootCommand())
manager.add_command("alter_user", AlterUserCommand())
manager.add_command("add_debug_user", AddDebugUserCommand())
manager.add_command("fail_build", FailBuildCommand())
manager.add_command("update_indexes", UpdateIndexesCommand())
manager.add_command("generate_repo_packages", GenerateRepoPackagesCommand())
manager.add_command("rawhide_to_release", RawhideToReleaseCommand())
Пример #31
0
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand

from app import app  # we import the app object from the app module
from app import db

migrate = Migrate(app, db)
manager = Manager(
    app
)  # keeps track of all the commands and handles how they are called from the command line
manager.add_command('db', MigrateCommand)

if __name__ == '__main__':
    manager.run(
    )  # prepares your Manager instance to receive input from the command line.
Пример #32
0
# limitations under the License.

import os
from flask import Flask, jsonify
from flask_script import Manager, Server
from flask_migrate import Migrate, MigrateCommand
from flask_sqlalchemy import SQLAlchemy
from flask_bootstrap import Bootstrap
from .db import get_uri

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = get_uri()
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.config['SECRET_KEY'] = '1234'

manager = Manager(app)

port = os.getenv('PORT', '5000')
manager.add_command('runserver', Server(host='0.0.0.0', port=int(port)))

db = SQLAlchemy(app)
migrate = Migrate(app, db)
manager.add_command('db', MigrateCommand)

Bootstrap(app)

from JBToDo.navigation import nav
nav.init_app(app)

import JBToDo.model
import JBToDo.views
Пример #33
0
from flask_script import Manager, Server,Shell
from tigereye.app import create_app
from tigereye.models import db
from tigereye.models.cinema import Cinema
from tigereye.models.hall import Hall
from tigereye.models.seat import Seat
from tigereye.models.movie import Movie
from tigereye.models.play import Play
from tigereye.models.order import Order
from tigereye.configs.production import ProductionConfig

app = create_app()
manager = Manager(app)

def _make_context():

    from tigereye.models import Model
    from tigereye.helper.code import Code
    from tigereye.extensions.validator import Validator


    locals().update(globals())
    return dict(**locals())

manager.add_command('runserver',Server('127.0.0.1',port=5000))
manager.add_command('shell', Shell(make_context=_make_context))

@manager.command
def createdb():
    db.create_all()
Пример #34
0
import os
import re

from functools import wraps
from distutils.dist import Distribution
from pkgutil import walk_packages

from flask_script import Manager, Command, Option
from babel.messages import frontend

IndicoI18nManager = Manager(usage="Takes care of i18n-related operations")

TRANSLATIONS_DIR = 'indico/translations'
MESSAGES_POT = os.path.join(TRANSLATIONS_DIR, 'messages.pot')
MESSAGES_JS_POT = os.path.join(TRANSLATIONS_DIR, 'messages-js.pot')

DEFAULT_OPTIONS = {
    'init_catalog': {
        'output_file': MESSAGES_POT,
        'output_dir': TRANSLATIONS_DIR
    },

    'extract_messages': {
        'keywords': 'N_:1,2',
        'width': 120,
        'output_file': MESSAGES_POT,
        'mapping_file': 'babel.cfg'
    },

    'compile_catalog': {
        'domain': 'messages',
Пример #35
0
from __future__ import absolute_import
import logging
from flask_script import Manager
from app import topics_app
from app.corpus.generator import generate
from app.utils.indexer import index

logging.basicConfig(level=logging.INFO)

manager = Manager(topics_app)


@manager.command
def run_indexer():
    index()


@manager.command
def run_generator():
    logging.info("Running generator")
    generate()



if __name__ == "__main__":
    manager.run()
Пример #36
0
from __future__ import unicode_literals

import unittest
import os

from flask_script import Manager
from flask_migrate import MigrateCommand

from emcweb import flask_app
from emcweb.exts import connection

__author__ = 'Aspanta Limited'
__email__ = '*****@*****.**'


manager = Manager(flask_app.create_app)
manager.add_command('db', MigrateCommand)


@manager.command
def init():
    connection.drop_all()
    connection.create_all()


@manager.command
def test():
    tests = unittest.defaultTestLoader.discover(os.path.join(os.getcwd(), 'tests'))
    unittest.TextTestRunner().run(tests)

Пример #37
0
from app import app
from flask_script import Manager

manage = Manager(app)

if __name__ == "__main__":
    #manage.run()
    app.run()
Пример #38
0
def import_env():
    if os.path.exists('.env'):
        print 'Importing environment from .env...'
        for line in open('.env'):
            var = line.strip().split('=', 1)
            if len(var) == 2:
                os.environ[var[0]] = var[1]

import_env()
app = create_app(app_config)
app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
app.config['ZIMBRA_URL']='https://192.168.22.110:7071/service/admin/soap'
app.config['ZIMBRA_ADMIN']='*****@*****.**'
app.config['ZIMBRA_ADMIN_PASSWORD']='******'

manager = Manager(app)
test_manager = Manager(usage='Performs test related operations')

manager.add_command('db', db_manager)
manager.add_command('test', test_manager)
manager.add_command("routes", ShowUrls())

@manager.shell
def make_context_shell():
    """
    Usage: ./manage.py shell
    Starts a python shell with with app, db and models loaded
    """
    # Loads all the models which inherit from Base
    models_map = {name: cls for name, cls in models.__dict__.items() if isinstance(cls, type(Base))}
    return dict(app=app, db=db, **models_map)
Пример #39
0
from App import create_app
from flask_script import Manager

app = create_app()
manage = Manager(app=app)

if __name__ == '__main__':
    manage.run()
Пример #40
0
from os import path
import sys
sys.path.append(path.abspath(path.join(path.dirname(__file__), '..')))

from flask_script import Manager, Server
from flask_script.commands import InvalidCommand
from flask_migrate import MigrateCommand


def create_app(quiet=False):
    from project import app

    return app


manager = Manager(create_app)

# Turn on debugger by default and reloader
manager.add_command("runserver", Server(
    use_debugger = True,
    use_reloader = True,
    host = '0.0.0.0')
)

manager.add_command('db', MigrateCommand)


from accounts.commands import *


if __name__ == "__main__":
Пример #41
0
from flask import Flask
from flask_script import Manager, Server
from flask_migrate import MigrateCommand

from app import create_app

app = create_app()
manager = Manager(app=app)

manager.add_command('start', Server(host='127.0.0.1', port=9000))
manager.add_command('db', MigrateCommand)

if __name__ == '__main__':
    manager.run()
Пример #42
0
import os
import subprocess

import redis
from flask_script import Manager, Server
from flask_script.commands import ShowUrls, Clean
from jeopardy import create_app

# default to dev config because no one should use this in
# production anyway
from jeopardy.models import BoardManager

env = os.environ.get('JEOPARDY_ENV', 'dev')
app = create_app('jeopardy.settings.%sConfig' % env.capitalize())

manager = Manager(app)
manager.add_command("show-urls", ShowUrls())
manager.add_command("clean", Clean())


@manager.option('-b', '--boards', dest='boards', default='board.yml')
@manager.option('--skip-npm',
                dest='skip_npm',
                action='store_true',
                default=False)
def run_server(boards, skip_npm):
    bm = app.config.get('BOARD_MANAGER')
    bm.load_board(boards)
    bm.init_boards()

    if not skip_npm:
Пример #43
0
from application.settings import DevConfig, ProdConfig
from application.models.foo import Foo
from application.models.basket import Basket
from application.models.page import Page
from application.models.kv import KV
from application.extensions import db

if os.environ.get("APPLICATION_ENV") == 'prod':
    app = create_app(ProdConfig)
else:
    app = create_app(DevConfig)

HERE = os.path.abspath(os.path.dirname(__file__))
TEST_PATH = os.path.join(HERE, 'tests')

manager = Manager(app)


def _make_context():
    """Return context dict for a shell session so you can access
    app, db and the Foo model by default.
    """
    return {
        'app': app,
        'db': db,
        'Foo': Foo,
        'Basket': Basket,
        'Page': Page,
        'KV': KV
    }
Пример #44
0
from flask import g

from flask_script import Manager
from flask_cors import CORS

import json

import cv2 as cv
import numpy

import os

app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = "./"
CORS(app)
manager = Manager(app)

SIFT_OUTPUT_FILE = "sift_matches.json"
DUPLICATE_WEIGHT_THRESHHOLD = 3


def GunicornServer():

    from gunicorn.app.base import Application

    class FlaskApplication(Application):
        def init(self, parser, opts, args):
            return {
                'bind': '{0}:{1}'.format('0.0.0.0', 5000),
                'workers': 5,
                'timeout': 10,
Пример #45
0

if os.path.exists('.env'):
    print('Importing environment from .env...')
    for line in open('.env'):
        var = line.strip().split('=')
        if len(var) == 2:
            os.environ[var[0]] = var[1]


from app import create_app, db
from app.models import User, Role, Post, Comment
from flask_script import Manager

app = create_app(os.getenv('FLASK_CONFIG') or 'default')
manager= Manager(app)

@manager.command
def profile(length=25, profile_dir=None):
    """Start the application under the code profiler."""
    from werkzeug.contrib.profiler import ProfilerMiddleware
    app.wsgi_app = ProfilerMiddleware(app.wsgi_app, restrictions=[length],
                                      profile_dir=profile_dir)
    app.run()


@manager.command
def deploy():
    """Run deployment tasks."""
    from flask_migrate import upgrade
    from app.models import Role, User
Пример #46
0
# -*- coding: utf-8 -*-
# @Time    :2021/1/13 22:57
# @Author  :robot_zsj
# @File    :app_1.py
import os

from flask import Flask, Blueprint
from flask_sqlalchemy import SQLAlchemy
from flask_script import Manager

app = Flask(__name__)

manager = Manager( app )

# 放入到配置文件中
# app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://*****:*****@47.115.163.10/' \
#                                         'flask_for_movie'
# 之后就通过以下命令来设置环境
# linux export ops_config=local|production
# windwos set ops_config=local|production
app.config.from_pyfile("config/base_setting.py")
if "ops_config" in os.environ:
    app.config.from_pyfile("config/%s_setting.py" % ( os.environ['ops_config']))

app.logger.info("+++++++++++++++++++++")

db = SQLAlchemy(app)

Пример #47
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-

__author__ = 'royrusso'

import os

from flask_migrate import MigrateCommand
from flask_script import Command, Manager, Option, Server as _Server

from elastichq import create_app
from elastichq.globals import db, socketio

manager = Manager(create_app)


class Server(_Server):
    """
    From https://github.com/miguelgrinberg/flack/blob/master/manage.py
    This is the only way to call ./manage.py runserver, as flask-socketio blocks the call otherwise.
    """

    help = description = 'Runs the Socket.IO web server'
    host = '0.0.0.0'
    port = 5000
    use_debugger = False
    use_reloader = False
    default_url = 'http://localhost:9200'

    def get_options(self):
        options = (
Пример #48
0
from flask_script import Manager
from app import create_app
from dotenv import load_dotenv

load_dotenv()

app = create_app()
manager = Manager(app)

if __name__ == '__main__':
    manager.run()
Пример #49
0
from unittest import TestLoader, TextTestRunner
from coverage import Coverage
from datetime import datetime

import os
import sys

cov = None
if os.environ.get('FLASK_COVERAGE'):
    cov = Coverage(branch=True, include=['app/*'])
    cov.start()

from app import create_app, db

app = create_app()
manager = Manager(app)
migrate = Migrate(app, db)


def make_shell_context():
    return dict(app=app, db=db)


class GeventServer(Server):

    help = description = 'Runs the Flask development gevent server.'

    def __call__(self, app, host, port, use_debugger, use_reloader, threaded, processes, passthrough_errors):
        if use_debugger is None:
            use_debugger = app.debug
            if use_debugger is None:
Пример #50
0
from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand

from app import *

migrate = Migrate(app, db)

manager = Manager(app)
manager.add_command('db', MigrateCommand)


if __name__ == '__main__':
    manager.run()
Пример #51
0
#!/usr/bin/env python
# encoding: utf-8


"""
@author: chenzhangpeng
@contact: [email protected]
@site: http://www.qinqinbaby.com
@file: manage.py.py
@time: 16/6/8 下午2:26
"""

from flask_script import Manager,Server
from app import app
from app.models import Todo

manager = Manager(app)
manager.add_command("runserver",Server(host='0.0.0.0',port=5000))

# 测试mongodb连接
# @manager.command
# def save_todo():
#     todo = Todo(content="哈哈哈哈")
#     todo.save()

if __name__ == '__main__':
    manager.run()
Пример #52
0
# THIS FILE CREATES THE FLASK APP AND START SERVER

import os
from flask_script import Manager, Server
from flask_ci import CICommand

from application import create_app
import settings
import config

debug = config.DEBUG
host = os.getenv('IP', '0.0.0.0')
port = int(os.getenv('PORT', 8080))

app = create_app(debug)
manager = Manager(app)

manager.add_command("ci", CICommand(settings))
manager.add_command(
    "runserver",
    Server(use_debugger=debug, use_reloader=debug, host=host, port=port))

if __name__ == "__main__":
    manager.run()
Пример #53
0
import os, sys
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

from flask_script import Manager, Server
from assetmanager import create_app, loaddata


app = create_app()
manager = Manager(app)

# Turn on debugger by default and reloader
manager.add_command("runserver", Server(
    use_debugger = True,
    use_reloader = True,
    host = "0.0.0.0",
    port = 8888)
)
manager.add_command("import", loaddata.RSS())

if __name__ == "__main__":
    manager.run()
Пример #54
0
# coding=utf-8
import os
from flask_script import Manager, Command

from flask_test import create_app

app = create_app(os.getenv('FLASK_CONFIG') or 'default')
manager = Manager(app)


# flask_script自定义命令两种方式
# 使用add_command自定义 python run.py hello1
class Hello(Command):
    def run(self):
        print('hello world')


manager.add_command('hello1', Hello())


# 使用装饰器@manager.command自定义 python run.py hello2
@manager.command
def hello2():
    print("server is running")


if __name__ == '__main__':
    manager.run()
Пример #55
0
from flask_migrate import Migrate, MigrateCommand
from flask_script import Command, Manager, Option, Server, Shell
from flask_script.commands import Clean, ShowUrls

from doc_dash.app import create_app
from doc_dash.database import db
from doc_dash.settings import DevConfig, ProdConfig
from doc_dash.user.models import User

CONFIG = ProdConfig if os.environ.get('DOC_DASH_ENV') == 'prod' else DevConfig
HERE = os.path.abspath(os.path.dirname(__file__))
TEST_PATH = os.path.join(HERE, 'tests')

app = create_app(CONFIG)
manager = Manager(app)
migrate = Migrate(app, db)


def _make_context():
    """Return context dict for a shell session so you can access app, db, and the User model by default."""
    return {'app': app, 'db': db, 'User': User}


@manager.command
def test():
    """Run the tests."""
    import pytest
    exit_code = pytest.main([TEST_PATH, '--verbose'])
    return exit_code
Пример #56
0
from app import kora_app, db
from flask_script import Manager, Server
from app.models import User, Pitch
# , Category, Vote, Comment
from flask_migrate import Migrate, MigrateCommand

# Creating app instance
app = kora_app('development')
# app = kora_app('production')

manager = Manager(app)
manager.add_command('server',Server)

migrate = Migrate(app, db)
manager.add_command('db', MigrateCommand)

@manager.command
def test():
    """Run the unit tests."""
    import unittest
    tests = unittest.TestLoader().discover('tests')
    unittest.TextTestRunner(verbosity=2).run(tests)

@manager.shell
def make_shell_context():
    return dict(app = app,db = db,User = User, Pitch = Pitch, Category = Category, Vote = Vote, Comment = Comment)

if __name__ == '__main__':
    manager.run()
Пример #57
0
    return app


"""Define flask app creation in different environments."""
if os.getenv('TRAVIS'):
    app = create_app(os.environ.get('travis'))
elif sys.argv[0] == 'nosetests':
    app = create_app('testing')
else:
    app = create_app('default')

api = Api(app)

migrate = Migrate(app, db)

manager = Manager(app)
manager.add_command('db', MigrateCommand)

login_manager = LoginManager()
login_manager.init_app(app)


@login_manager.request_loader
def load_user(request):
    """Check authorization header and authenticate user for request.

    Authenticate user with provided token where the login_required
    decorator is used
    """
    token = request.headers.get('token')
    if token:
Пример #58
0
from app import create_app, socketio, db
from app.database import UserModel, RoomModel
from flask_script import Manager, Shell
from flask_migrate import Migrate, MigrateCommand

import rethinkdb as r
from rethinkdb.errors import RqlRuntimeError, RqlDriverError

app = create_app()
manager = Manager(app)
migrate = Migrate(app, db)

rethink_db = 'Chat'


@manager.command
def rethinkDbSetup():

    connection = r.connect(host='localhost', port=28015)

    try:
        r.db_create(rethink_db).run(connection)
        r.db(rethink_db).table_create('Message').run(connection)
        r.db(rethink_db).table_create('Room').run(connection)
        print('Database setup completed')
    except RqlRuntimeError:
        print('App database already exists')
    finally:
        connection.close()

Пример #59
0
import os
from flask_script import Manager, Shell
from flask import Flask, render_template, url_for, flash, redirect, abort, request, session
from flask_bootstrap import Bootstrap
# from flask.ext.nav import Nav
from flask_wtf import Form
from wtforms import StringField, SubmitField, PasswordField, BooleanField
from wtforms.validators import Email, DataRequired, EqualTo, Length
from flask_login import LoginManager, login_user,login_required, logout_user, UserMixin, current_user
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate, MigrateCommand
from werkzeug.security import generate_password_hash, check_password_hash

basedir = os.path.abspath(os.path.dirname(__file__))
app = Flask(__name__)
manager = Manager(app)
app.config['SQLALCHEMY_DATABASE_URI'] = \
    'sqlite:///' + os.path.join(basedir, 'data.sqlite')
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True

app.config['SECRET_KEY'] = 'lambdaplus'
bootstrap = Bootstrap(app)
#nav = Nav(app)
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'login'
login_manager.init_app(app)
db = SQLAlchemy(app)
migrate = Migrate(app, db)

Пример #60
0
from flask_bcrypt import Bcrypt

BASEDIR = os.path.abspath(os.path.dirname(__file__))

app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///" + os.path.join(
    BASEDIR, "test.db")
app.config["DEBUG"] = True
app.config["ENV"] = "development"
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
app.config["SECRET_KEY"] = "secret-key"
app.config['JWT_SECRET_KEY'] = 'encrypt'

db.init_app(app)
Migrate(app, db)
manager = Manager(app)
jwt = JWTManager(app)
bcrypt = Bcrypt(app)
manager.add_command("db", MigrateCommand)  # init, migrate, upgrade

CORS(app)


@app.route('/user/<int:id>', methods=["GET", "DELETE", "PUT"])
@app.route('/user', methods=["POST"])
def user(id=None):
    if id is not None:
        if request.method == "GET":
            user = User.query.filter_by(id=id).first()
            return jsonify(user.serialize()), 200