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
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
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
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()
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_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)
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
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 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 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']
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
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
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()
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 ############################# #############################
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()
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 = []
from flask_script import Manager from flask_bcolz.app import create_app manager = Manager(create_app()) if __name__ == "__main__": manager.run()
# 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()
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)
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)
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))
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()
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()
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)
#!/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)
"""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)
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)
#!/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()
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()
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())
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.
# 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
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()
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',
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()
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)
from app import app from flask_script import Manager manage = Manager(app) if __name__ == "__main__": #manage.run() app.run()
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)
from App import create_app from flask_script import Manager app = create_app() manage = Manager(app=app) if __name__ == '__main__': manage.run()
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__":
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()
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:
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 }
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,
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
# -*- 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)
#!/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 = (
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()
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:
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()
#!/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()
# 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()
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()
# 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()
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
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()
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:
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()
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)
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