def setup_manager(): import main app = main.create_app(**main.OPTIONS) manager = Manager(app) manager.add_command('resetdb', InitDatabase()) from flask_security import script manager.add_command('create-user', script.CreateUserCommand()) manager.add_command('create-role', script.CreateRoleCommand()) manager.add_command('add-role', script.AddRoleCommand()) manager.add_command('remove-role', script.RemoveRoleCommand()) manager.add_command('activate-user', script.ActivateUserCommand()) manager.add_command('deactivate-user', script.DeactivateUserCommand()) from flask_migrate import MigrateCommand manager.add_command('db', MigrateCommand) from flask_script.commands import ShowUrls manager.add_command('rules', ShowUrls) from flask_assets import ManageAssets manager.add_command("assets", ManageAssets()) return manager
def add(model, f): app = create_app() app.test_request_context().push() for line in csv.reader(f): if not line: # skip empty lines continue line = [unicode(l, 'utf_8') for l in line] try: email, password, name, sexe, ecole, portable = line except ValueError: raise ValueError("La ligne semble trop courte (sur {}) !".format(line)) try: sexe = Sexe[sexe].value except: raise ValueError("sexe: reçu {} au lieu de M ou F pour {}".format(sexe, name)) u = User(email, password, name, sexe, ecole, portable) m = model(u) db.session.add(m) print "Créé {}".format(m) send_email(m) db.session.commit() print "Tout s'est bien passé !"
def setUp(self): os.environ['SERVER_NAME'] = 'test' os.environ['SERVER_PORT'] = '1234' self.mox = Mox() self.login() self.creator = self.make_creator() self.app = TestApp(main.create_app()) self.stubs = StubOutForTesting()
def get_app(): app = create_app() root = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..') try: os.remove(os.path.join(root, 'var', 'test.db')) except OSError: pass os.environ['SETTINGS_FILE'] = os.path.join(root, 'config', 'test.cfg') with app.app_context(): db.create_all() CreateBankAccounts().run() CreateTickets().run() return app.test_client(), app, db
def app(): """ Fixture to provide an instance of the app. This will also create a Flask app_context and tear it down. This fixture is scoped to the module level to avoid too much Postgres teardown/creation activity which is slow. """ if 'SETTINGS_FILE' not in os.environ: root = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..') os.environ['SETTINGS_FILE'] = os.path.join(root, 'config', 'test.cfg') tmpdir = os.environ.get('TMPDIR', '/tmp') prometheus_dir = os.path.join(tmpdir, 'emf_test_prometheus') os.environ['prometheus_multiproc_dir'] = prometheus_dir if os.path.exists(prometheus_dir): shutil.rmtree(prometheus_dir) if not os.path.exists(prometheus_dir): os.mkdir(prometheus_dir) app = create_app() with app.app_context(): try: db_obj.session.close() except: pass db_obj.drop_all() db_obj.create_all() CreateBankAccounts().run() CreateTickets().run() yield app db_obj.session.close() db_obj.drop_all()
def create_app(self): return create_app()
from main import create_app from main import ProductionConfig __all__ = ['application'] application = create_app(ProductionConfig())
import sys sys.path.insert(0, '/home/narlab/webapps/touravel') from main import create_app, db from flask.ext.script import Manager, Shell from flask.ext.migrate import Migrate, MigrateCommand from main.models.user import User application = create_app('development') manager = Manager(application) migrate = Migrate(application, db) manager.add_command('db', MigrateCommand) def make_shell_context(): return dict(app=application, db=db, User=User) manager.add_command("shell", Shell(make_context=make_shell_context)) @application.route("/") def hello(): return "It Works!" if __name__ == '__main__': manager.run()
from flask import Flask from flask_script import Manager from flask_migrate import Migrate, MigrateCommand from models import db from main import create_app app = create_app('config') migrate = Migrate(app, db) migrate.init_app(app, db) manager = Manager(app) manager.add_command('db', MigrateCommand) if __name__ == "__main__": manager.run() db.create_all() db.session.commit()
def app(): app = main.create_app(config_class=Config) app.debug = True client = app.test_client(use_cookies=True) app.client = client return app
import os from dotenv import load_dotenv from flask import render_template from main import create_app dotenv_path = os.path.join(os.path.dirname(__file__), ".env") if os.path.exists(dotenv_path): load_dotenv(dotenv_path) app = create_app(os.getenv("FLASK_CONFIG") or "default") @app.route("/", defaults={"path": ""}) @app.route("/<path:path>") def default_route(path): return render_template("index.html") if __name__ == "__main__": app.run(host="0.0.0.0", port=5000)
from main import db, create_app db.create_all(app=create_app())
def app(): app = create_app(testing=True) return app
#!/usr/bin/env python # coding=utf-8 from main import create_app config = "default" app = create_app(config) if __name__ == '__main__': app.run(host="0.0.0.0", port=5100)
from os import getenv from flask_migrate import Migrate from flask_script import Manager from api.datab import db from config import config from main import create_app config_name = getenv("FLASK_ENV", "production") app = create_app(config.get(config_name)) migrate = Migrate(app, db) manager = Manager(app) if "__main__ " == __name__: manager.run()
def app(): """Setup & teardown app""" app = create_app("testing") return app
from main import create_app if __name__ == '__main__': app, socketio_app = create_app() socketio_app.run(app, host='0.0.0.0', debug=True, port=5000)
from tasks.cfp import (ImportCFP, EmailSpeakersAboutSlot, EmailSpeakersAboutFinalising, RejectUnacceptedProposals) from tasks.dev import MakeFakeData, MakeVolunteerData from tasks.external_calendars import (CreateCalendars, RefreshCalendars, ExportCalendars) from tasks.schedule import (ImportVenues, RunScheduler, ApplyPotentialSchedule) from tasks.tickets import ( CreateTickets, SendTickets, SendTransferReminder, CancelReservedTickets, ) from tasks.exportdb import ExportDB if __name__ == "__main__": manager = Manager(create_app()) manager.add_command('db', MigrateCommand) manager.add_command('exportdb', ExportDB()) manager.add_command('createbankaccounts', CreateBankAccounts()) manager.add_command('loadofx', LoadOfx()) manager.add_command('reconcile', Reconcile()) manager.add_command('sendtransferreminder', SendTransferReminder()) manager.add_command('cancelreservedtickets', CancelReservedTickets()) manager.add_command('createtickets', CreateTickets()) manager.add_command('sendtickets', SendTickets()) manager.add_command('importcfp', ImportCFP()) manager.add_command('createperms', CreatePermissions())
def test_create_app(self): """Branch coverage for production server.""" self.mock(utils, 'is_local_dev_server', lambda: False) main.create_app()
from main import create_app # Запуск приложения if __name__ == '__main__': create_app()
#!/usr/bin/python '''Flask app runner for dev''' from main import create_app app = create_app() app.config.from_object('config.Development') if __name__ == '__main__': app.run(host="0.0.0.0", debug=True, use_reloader=True)
import os from main import create_app # Entry point for uWSGI application = create_app() if __name__ == "__main__": port = int(os.environ.get("METAWAHL_PORT", 9000)) app.run(port=port)
# Copyright 2015 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Initialize all the apps. This module cannot be imported by tests (requires Datastore), so keep it super simple. """ import admin_handler import main main_app = main.create_app() admin_app = admin_handler.create_app()
import os from main import create_app, logger, db from flask import request, _request_ctx_stack from flask_mail import email_dispatched if __name__ == "__main__": app = create_app(dev_server=True) if app.config.get('DEBUG'): email_dispatched.connect(logger.mail_logging) if app.config.get('FIX_URL_SCHEME'): # The Flask debug server doesn't process _FORWARDED_ headers, # so there's no other way to set the wsgi.url_scheme. # Consider using an actual WSGI host (perhaps with ProxyFix) instead. @app.before_request def fix_url_scheme(): if request.environ.get('HTTP_X_FORWARDED_PROTO') == 'https': request.environ['wsgi.url_scheme'] = 'https' _request_ctx_stack.top.url_adapter.url_scheme = 'https' if os.path.exists('.inside-vagrant'): # Make it easier to access from host machine default_host = '0.0.0.0' default_port = 5000 else: # Safe defaults default_host = None # i.e. localhost default_port = None # i.e. 5000 host = app.config.get('HOST', default_host)
"""This file is the entry point for the app""" import os from main import create_app app = create_app(os.environ.get("ENV", "development")) if __name__ == "__main__": app.run(host="127.0.0.1", port=3001, debug=True)
def app(): app = create_app() return app
class create_users(Command): """Create a user""" def run(self): company_user = User(username='******', email='*****@*****.**', password=guard.hash_password('super.super'), first_name='Raul', last_name='Escamilla', roles='company') interpreter_user = User(username='******', email='*****@*****.**', password=guard.hash_password('super.super'), first_name='Alberto', last_name='Salinas', roles='interpreter') users.save(company_user) users.save(interpreter_user) app = create_app() migrate = Migrate(app, db) manager = Manager(app) manager.add_command('db', MigrateCommand) manager.add_command('create_users', create_users()) if __name__ == '__main__': manager.run()
import os from main import create_app web = create_app() web.app_context().push() if __name__ == '__main__': web.run(debug=True, port=os.getenv('PORT'))
def client(): """Flask test client with Google Cloud logging client removed.""" from main import create_app app = create_app() return app.test_client()
def get_app(self): """Return HTTP/WS server.""" self.close_future = Future() return create_app(SHELL, self.close_future)
#-*-coding:utf-8-*- import os from main import create_app from flask_script import Manager,Server from flask_migrate import Migrate,MigrateCommand from main.models import db,User config = os.environ.get('shape_cfg','dev') app = create_app('main.config.%sConfig'%config.capitalize()) manager = Manager(app) migrate = Migrate(app,db) manager.add_command("server",Server()) manager.add_command("db",MigrateCommand) @manager.shell def make_shell_context(): return dict(app=app,db=db,User=User) if __name__=="__main__": # app.run(host="0.0.0.0") manager.run()
# Third-Party libraries from flasgger import swag_from from flask import jsonify from decouple import config as env_config # Config from main import create_app, rest_api from config import config #utils from api.utils.pre_request import PreRequest config_name = env_config('FLASK_ENV', 'production') app = create_app(rest_api, config=config[config_name]) @app.before_request def check_tenant_param(): return PreRequest.check_tenant() @app.route('/health') @swag_from('/api/docs/status.yml') def index(): return jsonify(dict(message=f'App status - OK.')) if __name__ == '__main__': app.run()
# Show a debugging info on console logging.debug("__file__ = %s", __file__) logging.debug("sys.version = %s", sys.version) logging.debug("os.getpid() = %s", os.getpid()) logging.debug("os.getcwd() = %s", os.getcwd()) logging.debug("os.curdir = %s", os.curdir) logging.debug("sys.path:\n\t%s", "\n\t".join(sys.path)) logging.debug("PYTHONPATH:\n\t%s", "\n\t".join(os.environ.get('PYTHONPATH', "").split(';'))) logging.debug("sys.modules.keys() = %s", repr(sys.modules.keys())) logging.debug("sys.modules.has_key('website') = %s", ('website' in sys.modules)) if 'website' in sys.modules: logging.debug("sys.modules['website'].__name__ = %s", sys.modules['website'].__name__) logging.debug("sys.modules['website'].__file__ = %s", sys.modules['website'].__file__) # # Setup proper logging # from website.logcfg import setup_logging # # log_file = os.path.join(ROOT_DIR, "logs", 'website.log') # setup_logging(log_file=log_file, console_verbosity=logging.DEBUG if PRODUCTION else logging.DEBUG) from main import create_app, OPTIONS try: application = create_app(**OPTIONS) except Exception as ex: logging.error("Failed to create a WSGI app", exc_info=True) logging.debug("app.debug: %s" % application.debug) logging.debug("app.testing: %s" % application.testing)
import os from main import create_app from flask import Flask from flask_sqlalchemy import SQLAlchemy config_name = os.getenv('FLASK_CONFIG') app = create_app(config_name) if __name__ == '__main__': app.run()
import os import sys sys.path.append(os.path.realpath('.')) from flask_script import Manager from flask_migrate import Migrate, MigrateCommand from main import create_app from models.models import db from config import Config app = create_app(Config) migrate = Migrate(app, db) manager = Manager(app) manager.add_command('db', MigrateCommand) if __name__ == '__main__': manager.run()
import os from main import create_app from api.config.config import ProductionConfig,\ DevelopmentConfig, TestConfig if os.environ.get('WORK_ENV') == 'PROD': app = create_app(ProductionConfig) elif os.environ.get('WORK_ENV') == 'TEST': app = create_app(TestConfig) else: app = create_app(DevelopmentConfig) celery = app.celery if __name__ == "__main__": app.run()
def setUp(self): """尝试创建一个测试环境""" self.app = create_app('testing') self.app_context = self.app.app_context() self.app_context.push() db.create_all()
import os from flask_script import Manager from flask_migrate import Migrate, MigrateCommand from dotenv import load_dotenv from pathlib import Path from main import create_app, db env_path = Path('.') / '.env' load_dotenv(dotenv_path=env_path, verbose=True) env_name = os.getenv('FLASK_ENV') app = create_app(env_name) migrate = Migrate(app=app, db=db) manager = Manager(app=app) manager.add_command('db', MigrateCommand) if __name__ == '__main__': manager.run()
for rec in EmailJobRecipient.query.filter(EmailJobRecipient.sent == False): # noqa self.send_email(conn, rec) def send_email(self, conn, rec): msg = Message(rec.job.subject, sender=app.config['CONTACT_EMAIL']) msg.add_recipient(rec.user.email) msg.body = rec.job.text_body msg.html = rec.job.html_body conn.send(msg) rec.sent = True db.session.add(rec) db.session.commit() if __name__ == "__main__": manager = Manager(create_app()) manager.add_command('createdb', CreateDB()) manager.add_command('db', MigrateCommand) manager.add_command('createbankaccounts', CreateBankAccounts()) manager.add_command('loadofx', LoadOfx()) manager.add_command('reconcile', Reconcile()) manager.add_command('sendtransferreminder', SendTransferReminder()) manager.add_command('createtickets', CreateTickets()) manager.add_command('sendtickets', SendTickets()) manager.add_command('lockproposals', LockProposals()) manager.add_command('importcfp', ImportCFP()) manager.add_command('createperms', CreatePermissions())
"""Application entry point""" from config import AppConfig from main import create_app # application object app = create_app(AppConfig) if __name__ == '__main__': app.run()
import shutil from main import create_app, db from flask import request, _request_ctx_stack from flask_mail import email_dispatched if __name__ == "__main__": prometheus_dir = 'var/prometheus' os.environ['prometheus_multiproc_dir'] = prometheus_dir if os.path.exists(prometheus_dir): shutil.rmtree(prometheus_dir, True) if not os.path.exists(prometheus_dir): os.mkdir(prometheus_dir) app = create_app(dev_server=True) # Prevent DB connections and random numbers being shared ppid = os.getpid() @app.before_request def fix_shared_state(): if os.getpid() != ppid: db.engine.dispose() random.seed() import prometheus_client.multiprocess @app.after_request def prometheus_cleanup(response): # this keeps livesum and liveall accurate # other metrics will hang around until restart
# system import from os import getenv # third party import from flask import jsonify # local import from main import create_app from config import config # get flask config name from env or default to production config config_name = getenv('FLASK_ENV', default='production') # create application object app = create_app(config[config_name]) if __name__ == '__main__': app.run()
def app_module(self): return main.create_app()
def setUpClass(cls): cls.app = create_app() cls.client = cls.app.test_client()
import sys from os import path sys.path.append('lib') print path.dirname(path.abspath(__file__)) sys.path.append(path.dirname(path.abspath(__file__))) from datetime import datetime, timedelta import arrow import io import string import websocket import thread import time import json from main import create_app app = create_app(schedule_events=False) app.app_context().push() class AdminUser(HttpLocust): host = 'https://api-virtumedix-vm2.nimaws.com/' admin = AdminUser() pat_id = '560dcedd02b9d75f7e663653' cli_id = '55e7210f02b9d75d61fbe02b' total_cnt = 0 def on_message(ws, message): global total_cnt total_cnt = total_cnt + 1 pass #print message
#!/usr/bin/env python from main import create_app from gevent import pywsgi from geventwebsocket.handler import WebSocketHandler if __name__ == '__main__': # from flask_script import Manager # manager = Manager(create_app()) # manager.run() server = pywsgi.WSGIServer(('0.0.0.0', 5000), create_app(), handler_class=WebSocketHandler) print('server start') server.serve_forever()