def parser_artist(artist_id): create_app() process = Process.get_or_create(id=artist_id) if process.is_success: return print 'Starting fetch artist: {}'.format(artist_id) start = time.time() process = Process.get_or_create(id=artist_id) tree = get_tree(ARTIST_URL.format(artist_id)) artist = Artist.objects.filter(id=artist_id) if not artist: artist_name = tree.xpath('//h2[@id="artist-name"]/text()')[0] picture = tree.xpath( '//div[contains(@class, "n-artist")]//img/@src')[0] artist = Artist(id=artist_id, name=artist_name, picture=picture) artist.save() else: artist = artist[0] song_items = tree.xpath('//div[@id="artist-top50"]//ul/li/a/@href') songs = [] for item in song_items: song_id = item.split('=')[1] song = parser_song(song_id, artist) if song is not None: songs.append(song) artist.songs = songs artist.save() process.make_succeed() print 'Finished fetch artist: {} Cost: {}'.format( artist_id, time.time() - start)
def test_create_app(): try: create_app() except SystemExit: # Clean git repository doesn't have `local_config.py`, so it is fine # if we get SystemExit error. pass
def run( context, host='127.0.0.1', port=5000, development=True, install_dependencies=True, upgrade_db=True ): """ Run DDOTS RESTful API Server. """ if install_dependencies: context.invoke_execute(context, 'app.dependencies.install') if upgrade_db: context.invoke_execute(context, 'app.db.upgrade') if development: context.invoke_execute( context, 'app.db.init_development_data', upgrade_db=False, skip_on_failure=True ) from app import create_app create_app( flask_config='development' if development else 'production' ).run( host=host, port=port )
def test_create_app_passing_FLASK_CONFIG_env(monkeypatch, flask_config_name): monkeypatch.setenv('FLASK_CONFIG', flask_config_name) if flask_config_name == 'production': from config import ProductionConfig monkeypatch.setattr(ProductionConfig, 'SQLALCHEMY_DATABASE_URI', 'sqlite://') monkeypatch.setattr(ProductionConfig, 'SECRET_KEY', 'secret') create_app()
def setUpClass(self): """ Sets up a test database before each set of tests """ create_app( MONGODB_SETTINGS={'DB': 'testing'}, TESTING=True, CSRF_ENABLED=False, WTF_CSRF_ENABLED=False ) from app import app self.app = app
def test_create_app(self): self.test_app = create_app("testing") self.test_app_context = self.test_app.app_context() self.test_app_context.push() self.test_client = self.test_app.test_client() self.test_app_context.pop() self.dev_app = create_app("development") self.dev_app_context = self.dev_app.app_context() self.dev_app_context.push() self.dev_client = self.dev_app.test_client() self.dev_app_context.pop()
def decorated_function(*args, **kwargs): """ エラーをログファイルに記録する """ try: r = f(*args, **kwargs) return r except Exception as e: from app import create_app create_app().logger.critical(datetime.datetime.now()) create_app().logger.critical(traceback.format_exc()) raise e
def setUp(self): app = create_app('testing') self.app = app self.ctx = app.app_context() self.ctx.push() self.client = app.test_client() db.create_all()
def stamp(context, directory='migrations', revision='head', sql=False, tag=None): """'stamp' the revision table with the given revision; don't run any migrations""" from app import create_app with create_app().app_context(): config = _get_config(directory) command.stamp(config, revision, sql=sql, tag=tag)
def setUp(self): self.app = create_app('testing') self.app_context = self.app.app_context() self.app_context.push() db.create_all() Role.insert_roles() self.client = self.app.test_client()
def setUp(self): """ Initialize the test cases. """ self.app = create_app(TestConfiguration) self.client = self.app.test_client() self.app_context = self.app.app_context() self.app_context.push() self.request_context = self.app.test_request_context('/') self.request_context.push() db.create_all() # Add a few test models. role_1 = Role(name='A') role_2 = Role(name='B') role_3 = Role(name='C') role_4 = Role(name='D') role_5 = Role(name='E') role_6 = Role(name='F') role_7 = Role(name='G') db.session.add(role_1) db.session.add(role_2) db.session.add(role_3) db.session.add(role_4) db.session.add(role_5) db.session.add(role_6) db.session.add(role_7) db.session.commit()
def setUpClass(cls): #start Firefox try: cls.client = webdriver.Firefox() except: pass if cls.client: #create the application cls.app = create_app('testing') cls.app_context = cls.app.app_context() cls.app_context.push() #suppress logging to keep unitteset output clean import logging logger = logging.getLogger('werkzeug') logger.setLevel("ERROR") #create database with fake user and post db.create_all() u = User(username='******', password='******', role=1) db.session.add(u) p = Post(title='test_post', body='test_post_body', user_id=u.id) db.session.add(p) db.session.commit() #start the Flask server in a thread threading.Thread(target=cls.app.run).start()
def setUpClass(cls): try: cls.client = webdriver.Firefox() except: pass if cls.client: cls.app = create_app('testing') cls.app_context = cls.app_context() cls.app_context.push() import logging logger = logging.getLogger('werkzeug') logger.setLevel("ERROR") db.create_all() Role.insert_roles() User.generate_fake(10) Post.generate_fake(10) admin_role = Role.query.filter_by(permissions=0xff).first() admin = User(email='*****@*****.**', username='******', password='******', role=admin_role, confirmed=True) db.session.add(admin) db.session.commit() threading.Thread(target=cls.app.run).start() time.sleep(1)
def teardown(): app = create_app('test') with app.app_context(): db.session.remove() db.drop_all() db.engine.execute("drop table alembic_version") db.get_engine(app).dispose()
def setUp(self): """ Initialize the test cases. """ self.app = create_app(TestConfiguration) self.app_context = self.app.app_context() self.app_context.push() self.request_context = self.app.test_request_context('/') self.request_context.push() db.create_all() # Add a few test models. self.model_1 = TestModel() self.model_2 = TestModel() self.model_3 = TestModel() self.model_4 = TestModel() self.model_5 = TestModel() self.model_6 = TestModel() self.model_7 = TestModel() db.session.add(self.model_1) db.session.add(self.model_2) db.session.add(self.model_3) db.session.add(self.model_4) db.session.add(self.model_5) db.session.add(self.model_6) db.session.add(self.model_7) db.session.commit()
def setUp(self): self.app = create_app(AuthTestConfig) self.app_context = self.app.test_request_context() self.app_context.push() db.app = self.app db.create_all() self.client = self.app.test_client(use_cookies=True)
def setUp(self): # Use an in memory database settings.EQ_SERVER_SIDE_STORAGE_TYPE = "DATABASE" settings.EQ_SERVER_SIDE_STORAGE_DATABASE_URL = "sqlite://" self.application = create_app('development') self.client = self.application.test_client()
def setUpClass(cls): try: cls.client = webdriver.Chrome(executable_path=chrome_driver) except: pass if cls.client: # 创建 app cls.app = create_app('test') cls.app_context = cls.app.app_context() cls.app_context.push() # 建立数据库 db.create_all() setting = Settings( site_admin_email='*****@*****.**', site_initiated=True, ) db.session.add(setting) db.session.commit() user = User( name='test_user', password='******', email='*****@*****.**' ) db.session.add(user) db.session.commit() cls.host = 'http://localhost:5000' import logging logger = logging.getLogger('werkzeug') logger.setLevel("ERROR") threading.Thread(target=cls.app.run).start()
def setUpClass(cls): # 启动Firefox try: cls.client = webdriver.Firefox() except: pass # 如果无法启动浏览器,则跳过这些测试 if cls.client: # 创建程序 cls.app = create_app('testing') cls.app_context = cls.app.app_context() cls.app_context.push() # 禁止日志,保持输出简洁 import logging logger = logging.getLogger('werkzeug') logger.setLevel("ERROR") # 创建数据库 db.create_all() Role.insert_role() # 添加管理员 admin_role = Role.query.filter_by(permission=0xff).first() admin = User(email='*****@*****.**', username='******', pasword='cat', role=admin_role, confirmed=True) db.session.add(admin) db.session.commit() # 在一个线程中启动Flask服务器 threading.Thread(target=cls.app.run).start()
def setUpClass(cls): try: cls.client = webdriver.Firefox() except: pass if cls.client: # create app cls.app = create_app('testing') cls.app_context = cls.app.app_context() cls.app_context.push() # create log import logging logger = logging.getLogger('werkzeug') logger.setLevel(logging.ERROR) # create database db.create_all() Role.init_roles() User.generate_fake(count=10) Post.generate_fake(count=10) # add admin admin_role = Role.query.filter_by(permissions=0xff).first() admin = User(email='*****@*****.**', username='******', password='******', role=admin_role, confirmed=True) db.session.add(admin) db.session.commit() # run server in child thread Thread(target=cls.app.run).start()
def enter(context, install_dependencies=True, upgrade_db=True): """ Enter into IPython notebook shell with an initialized app. """ if install_dependencies: context.invoke_execute(context, 'app.dependencies.install') if upgrade_db: context.invoke_execute(context, 'app.db.upgrade') import pprint import logging from werkzeug import script import flask import app flask_app = app.create_app() def shell_context(): context = dict(pprint=pprint.pprint) context.update(vars(flask)) context.update(vars(app)) return context with flask_app.app_context(): script.make_shell(shell_context, use_ipython=True)()
def setUp(self): self.app = create_app('testing') self.app_context = self.app.app_context() self.app_context.push() db.create_all() Role.insert_roles() self.client = self.app.test_client(use_cookies=True) #测试客户端对象 (启用cookie像浏览器一样可能接收和发半发送cookie)
def setUp(self): self.app = create_app("testing") self.app_context = self.app.app_context() self.app_context.push() db.create_all() Role.insert_roles() self.client = self.app.test_client(use_cookies=True)
def setUp(self): self.app = create_app('testing') self.app_context = self.app.app_context() self.app_context.push() db.create_all()
def setUpClass(cls): #launch Firefox try: cls.client = webdriver.Chrome() except: pass if cls.client: cls.app = create_app('testing') cls.app_context = cls.app.app_context() cls.app_context.push() import logging logger = logging.getLogger('werkzeug') logger.setLevel('ERROR') # create database, and fill it up with some faked data db.create_all() Role.insert_roles() User.generate_fake(10) Post.generate_fake(10) # add administrater admin_role = Role.query.filter_by(permissions=0xff).first() admin = User(email='*****@*****.**', username='******', password='******', role=admin_role, confirmed=True) db.session.add(admin) db.session.commit() # launch Flask server in a thread threading.Thread(target=cls.app.run).start() # give the server a second to ensure it is up time.sleep(1)
def search_results(query): app = create_app('test') test_client = app.test_client() setup_authorization(app) response = test_client.get('/index-to-create/services/search?%s' % query) return json.loads(response.get_data())
def create_app(self): '''Create the wsgi application''' app_ = app.create_app() db.session = mock.Mock() one = db.session.query.return_value.filter.return_value.one one.return_value = Exception() return app_
def create_app(self): """ Create the wsgi application for flask :return: application instance """ return app.create_app(config_type='TEST')
def setUp(self): self.app = create_app('testing') self.app_context = self.app.app_context() self.app_context.push() self.test_client = self.app.test_client()
def setUp(self): self.app = create_app('testing') self.app_context = self.app.app_context() self.app_context.push() db.create_all() self.client = self.app.test_client() self.url = api.url_for(RegisterResource)
"""Database migration and upgrade manager.""" from flask_migrate import Migrate from flask_migrate import MigrateCommand from flask_script import Manager from app import config from app import create_app from app import db app = create_app(config.set_config()) app.app_context().push() migrate = Migrate(app, db, compare_type=True) manager = Manager(app) manager.add_command("db", MigrateCommand) if __name__ == "__main__": manager.run()
def setUp(self): self.app = create_app(TestConfig) self.app_context = self.app.app_context() self.app_context.push() db.create_all()
import os
from app import create_app app = create_app('config') if __name__ == '__main__': app.run(host=app.config['HOST'], port=app.config['PORT'], debug=app.config['DEBUG'])
""" server.py: Run Flask server with Deep Learning model. """ __author__ = "alvertogit" __copyright__ = "Copyright 2018-2020" import os from app import create_app app = create_app(os.environ.get("FLASK_ENV")) if __name__ == "__main__": app.run(host="0.0.0.0", port=5000)
#!/usr/bin/env python # before use SET PYTHONPATH=<project_path> # TODO: https://flask.palletsprojects.com/en/1.1.x/cli/#custom-scripts import sys from app.views.renders import render_cut_filepath from render_worker import tasks from flask import url_for from app import create_app from app.models import Render app = create_app(debug=True) render_id = sys.argv[1] render = Render.query.filter(Render.id == render_id).one() print("Queueing this render: ", render) with app.app_context(): demo_url = url_for('static', filename=render_cut_filepath(render.gtv_match_id, render.map_number, render.client_num, render.start, render.end)) print("Cut demo url:", demo_url) # exit() tasks.render.send(render.id, demo_url, render.start, render.end)
import eventlet eventlet.monkey_patch() # from app import create_app, socketio # # app = create_app(debug=True) # # if __name__ == '__main__': # socketio.run(app) from app import create_app, socketio app = create_app(debug=False) if __name__ == '__main__': socketio.run(app, host="127.0.0.1", port="3002")
from os import getenv from app import create_app from app.models import Area, Comment, Concept, Country, Document, DocumentType, Index, Region, \ Role, State, Travel, User, Workflow, db app = create_app(getenv('FLASK_CONFIG') or 'default') @app.shell_context_processor def make_shell_context(): return dict(app=app, Area=Area, Comment=Comment, Concept=Concept, Country=Country, \ Document=Document, DocumentType=DocumentType, Index=Index, Region=Region, \ Role=Role, State=State, Travel=Travel, User=User, Workflow=Workflow, db=db) @app.cli.command() def init(): insert(Area) insert(Concept) insert(Country) insert(DocumentType) insert(Role) insert(User) insert(State) insert(Travel) insert(Document) def insert(model): print(f'Inserting table {model.__tablename__} ...') model.insert()
from app import create_app, db from flask_script import Manager,Server from app.models import Role ,PostCategory, Comment, BlogPost,Subscriber,Admin from flask_migrate import Migrate, MigrateCommand app = create_app('development') manager = Manager(app) manager.add_command('server',Server) migrate = Migrate(app,db) manager.add_command('db',MigrateCommand) @manager.shell def make_shell_context(): return dict(app = app,db = db,Admin = Admin, BlogPost = BlogPost, Role = Role, Comment = Comment,Subscriber= Subscriber,PostCategory=PostCategory ) if __name__ == '__main__': manager.run()
def setUp(self): self.app = create_app(config="testing") self.client = self.app.test_client() self.app_context = self.app.app_context()
# coding: utf-8 import os from app import create_app, db from app.models import User, Role from flask_script import Manager, Shell from flask_migrate import Migrate, MigrateCommand app = create_app(os.getenv('CHENGSITE_ENV') or 'DevConfig') 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) if __name__ == '__main__': manager.run()
# _*_ coding: utf-8 _*_ """ Created by Alimazing on 2018/5/12. """ from werkzeug.exceptions import HTTPException from flask_script import Manager, Command, Server from app import create_app from app.libs.error import APIException from app.libs.error_code import ServerError __author__ = 'Alimazing' app = create_app() @app.errorhandler(Exception) def framework_error(e): if isinstance(e, APIException): return e elif isinstance(e, HTTPException): code = e.code msg = e.description error_code = 1007 return APIException(code, error_code, msg) else: if not app.config['DEBUG']: return ServerError() else: raise e
# -*- coding: utf-8 -*- from flask import request from app import create_app from flask_script import Manager app = create_app('debug') print app.config def before_request(): app.jinja_env.cache = {} app.before_request(before_request) manager = Manager(app) @manager.command def test(): """Run the unit tests.""" pass if __name__ == '__main__': manager.run() # from flask import Flask # app = Flask(__name__) # @app.route('/')
import os from kubeflow.kubeflow.crud_backend import config, logging import app log = logging.getLogger(__name__) APP_NAME = os.environ.get("APP_NAME", "Tensorboard Web App") BACKEND_MODE = os.environ.get("BACKEND_MODE", "prod") # 'prod' or 'dev' # Load the Dev config based on BACKEND_MODE env var if BACKEND_MODE == "dev": cfg = config.DevConfig else: cfg = config.Config _app = app.create_app(name=APP_NAME, config_class=cfg) if __name__ == "__main__": _app.run()
import os from app import create_app if __name__ == '__main__': # Get flask env 'development' from env env_name = os.getenv("FLASK_ENV") app = create_app(env_name) app.run()
def setUp(self): self.app = create_app('testing') self.app_context = self.app.app_context() self.app_context.push()
def setUp(self): self.app = create_app('testing') self.app_context = self.app.app_context() self.app_context.push() self.client = self.app.test_client(use_cookies=True)
#!/usr/bin/env python from app import create_app, db from app.models import User, Role, Permission from flask_script import Manager, Shell from flask_migrate import Migrate, MigrateCommand app = create_app('default') manager = Manager(app) migrate = Migrate(app, db) def make_shell_context(): return dict(app=app, db=db, User=User, Role=Role, Permission=Permission) manager.add_command("shell", Shell(make_context=make_shell_context)) manager.add_command('db', MigrateCommand) if __name__ == '__main__': manager.run()
#start position import os from app import create_app, db from app.models import User, Role from flask_script import Manager, Shell from flask_migrate import Migrate, MigrateCommand app = create_app(os.environ.get('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) manager.add_command('shell', Shell(make_context=make_shell_context)) manager.add_command('db', MigrateCommand) @manager.command def test(): '''run the tests.''' import unittest tests = unittest.TestLoader().discover('tests') unittest.TextTestRunner(verbosity=2).run(tests) if __name__ == '__main__': manager.run()
import os from app import create_app, db from app.models import User, Role from flask_migrate import Migrate app = create_app(os.getenv('FLASKY_CONFIG') or 'default') migrate = Migrate(app, db) @app.shell_context_processor def make_shell_context(): return dict(db=db, User=User, Role=Role) @app.cli.command() def test(): """Run the unit tests.""" import unittest tests = unittest.TestLoader().discover('tests') unittest.TextTestRunner(verbosity=2).run(tests)
from app import create_app application = create_app()
def create_app(self): return create_app(self)
import os from flask_script import Manager from flask_migrate import Migrate, MigrateCommand from app import create_app, db config_name = os.environ.get('APP_SETTINGS') app = create_app(config_name) manager = Manager(app) migrate = Migrate(app, db) manager.add_command('db', MigrateCommand) # add db command if __name__ == "__main__": manager.run()
import os from flask import jsonify from config import config from app import create_app flask_env = os.getenv('FLASK_ENV', 'production') app = create_app(config=config[flask_env]) @app.route('/') def status(): return jsonify({ 'status': 'success', 'message': 'up and running' }) 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()
from app import create_app, db from flask_script import Manager, Server from flask_migrate import Migrate, MigrateCommand from app.models import User, Role app = create_app("development") manager = Manager(app) manager.add_command("server", Server) migrate = Migrate(app, db) manager.add_command('db', MigrateCommand) @manager.shell def make_shell_context(): return dict(app = app, db = db, User = User, Role = Role) if __name__ == "__main__": manager.run()
def setUp(self): self.app = app.create_app() self.app.testing = True self.app = self.app.test_client(self)
def create_app(self): return biu.create_app('testing')
def setUp(self): self.app = TestClient(create_app("testing"))
import os from flask_script import Manager # class for handling a set of commands from flask_migrate import Migrate, MigrateCommand from app import db, create_app from app import models from app.models import Pizza app = create_app(config_name=os.environ.get('APP_SETTINGS')) migrate = Migrate(app, db) manager = Manager(app) @manager.shell def make_shell_context(): return dict(app=app, db=db, Pizza=Pizza) manager.add_command('db', MigrateCommand) if __name__ == '__main__': manager.run()