def test_get_user(): """Test get_user fanction with valid data""" app = create_app("flask_test.cfg") with app.app_context(): with patch("requests.get") as MockTask: MockTask.return_value.raise_for_status = Mock() MockTask.return_value.json.return_value = { "results": [ { "gender": "male", "name": {"title": "Mr", "first": "Felix", "last": "Hansen"}, "location": { "street": {"number": 5177, "name": "Hyldevej"}, "city": "Gørløse", "country": "Denmark", }, "email": "*****@*****.**", "cell": "29130618", "picture": { "large": "https://randomuser.me/api/portraits/men/76.jpg", "medium": "https://randomuser.me/api/portraits/med/men/76.jpg", "thumbnail": "https://randomuser.me/api/portraits/thumb/men/76.jpg", }, } ] } assert isinstance(get_user(1), list)
def reclassify_photos(): ''' Для каждой неотклассифицированной фотографии запускает отдельную задачу классификации ''' logger.info('Task 3: reclassify_photos') app = create_app() with app.app_context(): current_cnn_version = get_current_cnn_version() photos = db.session.query(Photos.id.label('id'), StorageUsers.id.label('id_storage')) \ .join(Folders) \ .join(StorageUsers) \ .filter(StorageUsers.storage_id == 1).all() for photo in photos: logger.info('Проверяем картинку с id: %s, id_storage: %s' % (photo.id, photo.id_storage)) c_q = db.session.query(func.count(photosclasses.c.alg_id)) \ .select_from(photosclasses) \ .filter(photosclasses.c.photo_id == photo.id) \ .filter(photosclasses.c.alg_id == current_cnn_version) \ .group_by(photosclasses.c.alg_id) cnt = db.session.execute(c_q).scalar() if cnt is None or cnt == 0: logger.info('Отправляем на классификацию картинку с id: %s' % photo.id) get_class.delay(photo.id, photo.id_storage)
def dbdowngrade(configkey, version=None): """ Resets / upgrades / downgrades DB (up / down to some version). """ dbapp = create_app(configkey) logger.debug("Going to downgrade %s", dbapp.config.__class__) dbapp.db.downgradedb(dbapp.config, version)
def __init__(self): cur_path = os.path.dirname(os.path.abspath(__file__)) self.app = webapp.create_app() self.app.debug = True self.port = get_config().getint("setup", "listen_port") self.pidfile = os.path.join(cur_path, "..", get_config().get("setup", "pidpath")) Daemon.__init__(self, self.pidfile)
def db(): app = create_app('testing') DBAdmin.resetdb(app.config) DBAdmin.create_table_changelog(app.config) DBAdmin.upgradedb(app.config, None) DBAdmin.insert_initial_data(app) return app.db
def setUp(self): # Bug workarounds: Flask Admin和Flask Restful扩展中, # 它们会为应用生成蓝图对象并在内部保存起来,但在应用销毁时不会主动将其移除。 admin._views = [] rest_api.resources = [] self.app = create_app('test') # 必须push context,否则会报错误 self.app_context = self.app.app_context() self.app_context.push() self.client = self.app.test_client(use_cookies=True) # Bug workaround: 如果不在webapp目录中运行, # 则Flask SQLAlchemy的初始化代码就不能正确地在应用对象中进行初始化 db.app = self.app db.create_all() # create role and user # 由于下面有个test_register_and_login测试,要注册新用户, # 在register路由中会默认添加上'poster'和'default'角色,因此这里要先创建两种角色 poster = Role('poster') poster.description = 'poster role' default = Role('default') default.description = 'default role' db.session.add(poster) db.session.add(default) test_user = User('test') test_user.email = '*****@*****.**' test_user.password = '******' test_user.confirmed = True test_user.roles.append(poster) db.session.add(test_user) db.session.commit()
def setUp(self): admin._views = [] rest_api.resources = [] app = create_app('webapp.config.TestConfig') self.client = app.test_client() db.app = app db.create_all()
def send(filenames, conf): app = create_app(filenames) app.config.update(conf) http_server = serve(app) address, port = http_server.address announce(address, port) gevent.wait(count=1)
def setUp(self): app = create_app('webapp.config.TestConfig') self.client = app.test_client() # Bug workaround db.app = app db.create_all()
def test_test_config(self): """ Tests if the test config loads correctly """ app = create_app('webapp.settings.TestConfig') assert app.config['DEBUG'] is True assert app.config['SQLALCHEMY_ECHO'] is True assert app.config['CACHE_TYPE'] == 'null'
def setup_class(cls): cls.app = create_app('testing') cls.app_context = cls.app.app_context() cls.app_context.push() if cls.app.db.conn is not None: cls.app.db.conn.close() cls.app.db.createdb(cls.app.config)
def test_prod_config(self): """ Tests if the production config loads correctly """ app = create_app('webapp.settings.ProdConfig') assert app.config[ 'SQLALCHEMY_DATABASE_URI'] == 'sqlite:///../database.db' assert app.config['CACHE_TYPE'] == 'simple'
def setUp(self) -> None: admin._views = [] rest_api._resources = [] app = create_app('config.TestConfig') self.client = app.test_client() db.app = app db.create_all()
def setUp(self): admin._views = [] rest_api.resources = [] app = create_app("config.TestConfig") self.client = app.test_client() db.app = app db.create_all()
def app(): app = create_app({ 'TESTING': True, 'WTF_CSRF_SECRET_KEY': 'Testing secret key', 'SECRET_KEY': 'Testing secret key' }) yield app
def choose_run_type(cmd_args): """ function to help determine which type of function to use """ if cmd_args.postgresql: # create app and db app, db = create_app(app_type="PROD") # return app and db return app, db else: # create app and db app, db = create_app(app_type="TEST", verify_ask=False) # create tables db.create_all() # load test data curr_f_name = "Jon" curr_l_name = "Snow" curr_procedure = "ileostomy" curr_bday = datetime.strptime("1990-10-10", "%Y-%m-%d") # define test objects usr = User( curr_f_name, curr_l_name, curr_bday, curr_procedure, ) # add user and commit db.session.add(usr) db.session.commit() # read in fixtures path = "resources/application_settings.yaml" with open(path, "r") as f: data = yaml.load(f) # add data to database add_and_commit_fixtures(data, db) # return app and db return app, db
def init_manager(config=None): global manager global app app = create_app(config) manager = Manager(app) project_root_path = os.path.join(os.path.dirname(app.root_path)) manager.add_command('run', RunServer()) manager.add_command('debug', DebugServer()) manager.add_command('reset', Reset())
def setup_class(cls): cls.app = create_app('testing') cls.app_context = cls.app.app_context() cls.app_context.push() if cls.app.db.conn is not None: cls.app.db.conn.close() cls.admin_conn = cls.app.db.connectdb( cls.app.config['DB_CONN_URI_ADMIN']) cls.app.db.createdb(cls.app.config)
def test_dev_config(self): """ Tests if the development config loads correctly """ app = create_app('webapp.settings.DevConfig') assert app.config['DEBUG'] is True assert app.config[ 'SQLALCHEMY_DATABASE_URI'] == 'sqlite:///../database.db' assert app.config['CACHE_TYPE'] == 'null'
def main(): """ Example for literal string interpolation (f-string) """ opts = parseargs() print("Configuration key: {}".format(opts.configkey)) app = create_app(opts.configkey) migratedb(app) casepath = os.path.join(app.confg['BASEDIR'], 'tests', opts.testcase) pytest.main(['-x', '-v', casepath])
def setUp(self): """ Create temp application and database in memory for tests """ app = create_app("config.TestConfig") app.config["WTF_CSRF_ENABLED"] = False self.client = app.test_client() db.app = app db.create_all() self.app = app
def app(): test_app = create_app(env='testing') with test_app.app_context(): db.create_all() yield test_app db.session.remove() db.drop_all()
def bypass_storages(): ''' Для каждого хранилища запускаем отдельную задачу синхронизации ''' logger.info('Task 1: bypass storages') app = create_app() with app.app_context(): for storage in StorageUsers.query.all(): sync_file_list.delay(storage.id)
def setUp(self): admin._views = [] self.app = create_app('config.TestingConfig') self.app_context = self.app.app_context() self.app_context.push() self.client = self.app.test_client() #db.app = app db.create_all() Clinic.insert_clinic() Role.insert_roles() User.insert_users()
def main(): # create app and db app, db = create_app(app_type="MIGRATION") # read in fixtures path = "resources/application_settings.yaml" with open(path, "r") as f: data = yaml.load(f) # call function to add and commit data add_and_commit_fixtures(data, db)
def app(request): """Session-wide test `Flask` application.""" app = create_app("config.TestConfig") with app.app_context() as ctx: ctx.push() def teardown(): ctx.pop() request.addfinalizer(teardown) return app
def setup_app(): # need to freeze time so that time specific functional tests are not flaky world.freezer = freeze_time("2015-03-14 09:26:53") world.freezer.start() world.now = get_utcnow() # start responses mock world.responses_mock = responses.RequestsMock() world.responses_mock.start() # create a test client app world.app = create_app('test') world.app.logger.setLevel(logging.ERROR) logging.getLogger("CSSUTILS").setLevel(logging.ERROR)
def setUp(self): # Bug workarounds admin._views = [] rest_api.resources = [] app = create_app('webapp.config.TestConfig') self.client = app.test_client() # Bug workaround db.app = app db.create_all()
def setUp(self): # type: () -> None self._storage_path = tempfile.mkdtemp() self.mock_env = mock.patch.dict(os.environ, { 'STORAGE_PATH': self._storage_path, }) self.mock_env.start() self.app = webapp.create_app() # type: flask.Flask self.app_context = self.app.test_request_context( ) # type: flask.ctx.RequestContext self.app_context.push() self.client = self.app.test_client() # type: flask.testing.FlaskClient
def create_app(self): app = create_app('webapp.config.TestConfig') self.client = app.test_client() app.config['WTF_CSRF_ENABLED'] = False # Bug workaround db.app = app db.create_all() return app
def setUp(self): admin._views = [] rest_api.resources = [] app = create_app('test') self.client = app.test_client() # 弥补 bug 的方法 db.app = app db.create_all()
def test_client(): flask_app = create_app() flask_app.config.from_pyfile('../tests/flask_test.py') testing_client = flask_app.test_client() ctx = flask_app.app_context() ctx.push() yield testing_client ctx.pop()
def setUp(self): # Bug workarounds: Flask Admin和Flask Restful扩展中, # 它们会为应用生成蓝图对象并在内部保存起来,但在应用销毁时不会主动将其移除。 admin._views = [] rest_api.resources = [] self.app = create_app('test') self.app_context = self.app.app_context() self.app_context.push() # Bug workaround: 如果不在webapp目录中运行, # 则Flask SQLAlchemy的初始化代码就不能正确地在应用对象中进行初始化 db.app = self.app db.create_all()
def init_services(self): # General Services self.logger = LoggingService() self.file_service = FileService(self.logger) # Drive Services distance_config = DistanceConfig() self.distance_service = DistanceService(distance_config, self.logger) # will need distance service eventually motor_config = MotorConfig() self.drive_service = DriveService(motor_config, self.logger) # Input services keyboard_config = KeyboardServiceConfig() self.keyboard_service = KeyboardInputService(keyboard_config, self.logger) user_control_config = UserControlConfig() self.user_control_service = UserControlService(user_control_config, self.keyboard_service, self.drive_service, self.logger) # Power service power_config = PowerConfig() self.power_service = PowerService(power_config, self.logger) # Wifi service wifi_config = WifiServiceConfig() self.wifi_service = WifiService(wifi_config, self.logger) # Menu menu_config = MenuConfig() self.menu_service = MenuService(menu_config, self.keyboard_service, self.power_service, self.distance_service, self.wifi_service, self.logger) self.logger.log(self.TAG, "All services initialized, starting web server...") # Bluetooth bt_config = BluetoothConfig() self.bluetooth = BluetoothService(bt_config, self.user_control_service, self.logger) # Web server self.web_config = WebServerConfig() self.webapp = create_app(self.user_control_service)
def setUp(self): # # Bug workarounds (?) # admin._views = [] rest_api.resources = [] # # Create the test app # app = create_app('webapp.config.TestConfig') self.client = app.test_client() # # Bug workaround # db.app = app db.create_all()
def create_new(): ''' Функция создания структуры новой БД. Также: 1) в таблице Storages создается справочник из 3 типов хранилищ: dropbox, yadisk, NAS; 2) в таблице Classes создается справочник используемых классов classes_dict; 3) создается запись о фиктивном алгоритме в таблице algorithms ''' try: app = create_app() db.create_all(app=app) with app.app_context(): # Создаем записи в таблице storages dropbox = Storages(id=1, name='dropbox', full_path='https://www.dropbox.com') yadisk = Storages(id=2, name='yadisk', full_path='https://disk.yandex.ru/') NAS = Storages(id=3, name='NAS', full_path='') db.session.add(dropbox) db.session.add(yadisk) db.session.add(NAS) # Создаем словарь базовых классов for item in classes_dict: class_ = Classes(id=(classes_dict.index(item) + 1), name=item['label']) db.session.add(class_) # Создаем фиктивный алгоритм в справочнике используемых алгоритмов alg_fict = Algorithms(id=0, name='test', create_date=datetime.strptime( '2000-01-01', '%Y-%m-%d')) db.session.add(alg_fict) db.session.commit() except: print( 'ОШИБКА при попытке создания новой БД: Возможно Вы не удалили старую базу...' ) sys.exit(0)
def testapp(request): app = create_app('webapp.settings.TestConfig', env='dev') client = app.test_client() db.app = app db.create_all() if getattr(request.module, "create_user", True): admin = User('admin', 'supersafepassword') db.session.add(admin) db.session.commit() def teardown(): db.session.remove() db.drop_all() request.addfinalizer(teardown) return client
from webapp import create_app application = create_app("webapp.config.ProdConfig")
from webapp import create_app app = create_app("webapp.config.ProdConfig")
#!venv/bin/python from webapp import create_app, socketio from flask.ext.script import Manager from flask.ext.migrate import MigrateCommand from flask.ext.script import Command app = create_app('production') class Server(Command): def run(self): socketio.run(app) manager = Manager(app) manager.add_command('db', MigrateCommand) manager.add_command('runserver', Server()) if __name__ == '__main__': manager.run()
#!/usr/bin/env python #coding=utf-8 from flask import Flask, current_app from flaskext.script import Server, Shell, Manager, Command from webapp import create_app from webapp.extensions import db manager = Manager(create_app('config.cfg')) manager.add_command("runserver", Server('0.0.0.0',port=80)) def _make_context(): return dict(db=db) manager.add_command("shell", Shell(make_context=_make_context)) @manager.command def createall(): "Creates database tables" db.create_all() @manager.command def dropall(): "Drops all database tables" if prompt_bool("Are you sure ? You will lose all your data !"): db.drop_all() if __name__ == "__main__": manager.run()
# COPY (select customer.id, user_id, email, is_shop_owner, temp_password, confirmed_at, last_login_at, stripe_customer_id, stripe_subscription_id, subscription.timestamp as subscription_timestamp from customer, public.user, subscription where customer.user_id=public.user.id and subscription.customer_id=customer.id) TO '/tmp/current_customers.csv' DELIMITER ',' CSV HEADER; from webapp import models, db, create_app import datetime app = create_app("development") with app.app_context(): platform_shopify = models.Platform.query.filter_by(id=2).first() no_shopify_basic = models.Plan.query.filter_by(id=7).first() shopify_basic = models.Plan.query.filter_by(id=8).first() shopify_simple = models.Plan.query.filter_by(id=9).first() # Edit beauty kitchen subscription bk_s = models.Subscription.query.filter_by(id=2).first() bk_s.stripe_subscription_id = "sub_8EBtDUle9oaBQ2" bk_s.plan = shopify_simple bk_s.trialed_for = 30 db.session.add(bk_s) # Edit rachel mcmillan subscription s2 = models.Subscription.query.filter_by(id=6).first() s2.stripe_subscription_id = "sub_8EBoQIKzdvzYtZ" s2.plan = shopify_simple s2.trialed_for = 30 db.session.add(s2) # Edit white rabbit subscription s4 = models.Subscription.query.filter_by(id=7).first() s4.stripe_subscription_id = "sub_8EBrRGwWacDbBi" s4.plan = shopify_simple s4.trialed_for = 30
#!/usr/bin/env python from webapp import create_app app = create_app('config.cfg') from flup.server.fcgi import WSGIServer WSGIServer(app,bindAddress='/tmp/webapp.sock').run()
from webapp import create_app from webapp.config import DevConfig from webapp.models import db from webapp.tasks import log def make_celery(app): celery = Celery( app.import_name, broker=app.config['CELERY_BROKER_URL'], backend=app.config['CELERY_BACKEND_URL'] ) celery.conf.update(app.config) TaskBase = celery.Task class ContextTask(TaskBase): abstract = True def __call__(self, *args, **kwargs): with app.app_context(): return TaskBase.__call__(self, *args, **kwargs) celery.Task = ContextTask return celery # make a dev app (with no REST) flask_app = create_app(DevConfig) db.init_app(flask_app) celery = make_celery(flask_app)
def create_app(self): """Create and return a testing flask app.""" app = create_app(TestConfig) self.twill = Twill(app, port=3000) return app
model_one_name, model_two_name = fname.split('_') headers = csv_reader.next() for row in csv_reader: model_one_class = getattr(models, model_one_name) model_two_class = getattr(models, model_two_name) model_one_instance = model_one_class.query.filter_by(id=row[0]).first() model_two_instance = model_two_class.query.filter_by(id=row[1]).first() getattr(model_one_instance, headers[1]).append(model_two_instance) db_instance.session.add(model_one_instance) db_instance.session.commit() if __name__ == '__main__': arguments = sys.argv if not len(sys.argv) == 2 or arguments[1] not in ['db_dev', 'db_prod']: print "USAGE: ./repopulate.py db_dev|db_prod" exit(1) option = arguments[1] app = create_app(option) db.init_app(app) ############################### # INIT DB ############################### app.app_context().push() db.create_all() db_dir = os.path.join(basedir, 'install', 'db', current_app.config.get('MODE')) import_tables(db, db_dir)
import unittest import webapp from webapp import db, models from tests import testing_constants app = webapp.create_app('testing') class BaseTest(unittest.TestCase): @classmethod def setUpClass(cls): cls.app = app cls.client = cls.app.test_client() cls.app.app_context().push() db.create_all() db.engine.dialect.supports_sane_multi_rowcount = False @classmethod def tearDownClass(cls): db.session.remove() db.drop_all() def setUp(self): pass def tearDown(self): db.session.close() db.session.rollback() def register(self, email, password):
if FLASK_COVERAGE: COV = coverage.coverage(branch=True, include='opac/webapp/*') COV.start() else: COV = None from webapp import create_app, dbsql, dbmongo, mail from opac_schema.v1.models import Collection, Sponsor, Journal, Issue, Article from webapp import controllers from webapp.utils import reset_db, create_db_tables, create_user, create_image from flask_script import Manager, Shell from flask_migrate import Migrate, MigrateCommand from webapp.admin.forms import EmailForm from flask import current_app app = create_app() migrate = Migrate(app, dbsql) manager = Manager(app) manager.add_command('dbsql', MigrateCommand) def make_shell_context(): app_models = { 'Collection': Collection, 'Sponsor': Sponsor, 'Journal': Journal, 'Issue': Issue, 'Article': Article, } return dict(app=app, dbsql=dbsql, dbmongo=dbmongo, mail=mail, **app_models) manager.add_command("shell", Shell(make_context=make_shell_context))
import webapp from config import Config from werkzeug.contrib.fixers import ProxyFix # Inicializa o aplicativo com as configurações desejadas app = webapp.create_app(Config) # Configura o aplicativo para proxy reverso app.wsgi_app = ProxyFix(app.wsgi_app) # Condicional importante para não invocar o servidor de debugging if __name__ == "__main__": app.run()
from os import getenv from webapp import create_app from argparse import ArgumentParser app = create_app(getenv("FLASK_CONFIG") or "development") def main(): parser = ArgumentParser() parser.add_argument("-p", "--port", help="port number") args = parser.parse_args() port = int(args.port or 5000) app.run(port=port) if __name__ == "__main__": main()
import os from flask.ext.script import Manager, Server from flask.ext.script.commands import ShowUrls from flask.ext.migrate import Migrate, MigrateCommand from webapp import create_app from webapp.models import db, User # default to dev config env = os.environ.get("WEBAPP_ENV", "DEV") app = create_app("webapp.config.%sConfig" % env.capitalize()) migrate = Migrate(app, db) manager = Manager(app) manager.add_command("server", Server()) manager.add_command("show-urls", ShowUrls()) manager.add_command('db', MigrateCommand) @manager.shell def make_shell_context(): return dict( app=app, db=db, User=User ) if __name__ == "__main__": manager.run()
from tornado.wsgi import WSGIContainer from tornado.httpserver import HTTPServer from tornado.ioloop import IOLoop from webapp import create_app app = WSGIContainer(create_app("webapp.config.ProdConfig")) http_server = HTTPServer(app) http_server.listen(80) IOLoop.instance().start()
from webapp import create_app from async.email_sender import send_email if __name__ == '__main__': app = create_app('dummy') app.app_context().push() send_email(recipients=['*****@*****.**'], template='email/new_user.html', template_ctx={"subject": "New user", "user_password": "******"}, subject="Welcome to Opinew")
import os from webapp import create_app from webapp.config import DevConfig from flask_script import Manager, Server #default to dev config #env = os.environ.get("WEBAPP_ENV", "dev") app = create_app('webapp.config.DevConfig') manager = Manager(app) manager.add_command("server", Server(host='0.0.0.0', port='5000')) @manager.shell def make_shell_context(): return dict( app=app, User = User, Role=Role ) if __name__ == "__main__": manager.run()
from gevent.wsgi import WSGIServer from webapp import create_app app = create_app('webapp.config.ProdConfig') server = WSGIServer(('', 80), app) server.serve_forever()
#!venv/bin/python from webapp import create_app from flask.ext.script import Manager from flask.ext.migrate import MigrateCommand app = create_app('development') manager = Manager(app) manager.add_command('db', MigrateCommand) if __name__ == '__main__': manager.run()
import os from flask.ext.script import Manager, Server from flask.ext.script.commands import ShowUrls from flask_migrate import Migrate, MigrateCommand from webapp import create_app from webapp.models import db, Account, Investment, AccountHistory from webapp.session_helper import PickleSessionInterface # default to dev config env = os.environ.get('WEBAPP_ENV', 'dev') app = create_app('webapp.config.%sConfig' % env.capitalize()) migrate = Migrate(app, db) manager = Manager(app) manager.add_command("server", Server()) manager.add_command("show-urls", ShowUrls()) manager.add_command('db', MigrateCommand) @manager.shell def make_shell_context(): return dict( app=app, db=db, Account=Account, Investment=Investment, AccountHistory=AccountHistory )
def setup_app(): app = create_app('test') world.client = app.test_client() world.ctx = app.test_request_context() world.ctx.push()
import facebook from webapp import create_app app = create_app('db_dev') app.app_context().push() # TODO: Facebook requires page access token... # http://aseriesoftubes.com/articles/obtaining-facebook-page-access-tokens-the-4-step-program/ fb_graph = facebook.GraphAPI(access_token=app.config.get('FB_USER_ACCESS_SECRET')) fb_profile = fb_graph.get_object('me')
from webapp import create_app app = create_app('dev') if __name__ == "__main__": app.run("0.0.0.0",port=5050)