def test_envvar_config_load(self): old = os.environ.get('EQUANIMITY_SERVER_SETTINGS') os.environ['EQUANIMITY_SERVER_SETTINGS'] = '../config/test.py' try: create_app() except Exception: raise finally: if old is not None: os.environ['EQUANIMITY_SERVER_SETTINGS'] = old
def test_config_dev_default_load(self): old = os.environ.get('EQUANIMITY_SERVER_SETTINGS') if old is not None: del os.environ['EQUANIMITY_SERVER_SETTINGS'] try: create_app(config=None) except Exception: raise finally: if old is not None: os.environ['EQUANIMITY_SERVER_SETTINGS'] = old
def test_prod_config(self): """ Tests if the production config loads correctly """ app = create_app('server.settings.ProdConfig', env='prod') assert app.config['SQLALCHEMY_DATABASE_URI'] == 'sqlite:///../database.db' assert app.config['CACHE_TYPE'] == 'simple'
def test_logger_setup_no_debug(self): # There's nothing to really test besides to make sure the code # doesn't crash. This only affects the logging levels set app = create_app(config='test') app.config['DEBUG'] = False app.config['DEBUG_LOGGING'] = False attach_loggers(app)
def startTornado(): global http_server http_server = HTTPServer(WSGIContainer(create_app("settings.DevelopmentConfig"))) http_server.listen(80) ioloop = IOLoop.instance() autoreload.start(ioloop) ioloop.start()
def init_db(): ''' Create tables necessary for this app to work. ''' app = create_app() db.init_app( app ) with app.test_request_context(): db.create_all()
def test_dev_config(self): """ Tests if the development config loads correctly """ app = create_app('server.settings.DevConfig', env='dev') assert app.config['DEBUG'] is True assert app.config['SQLALCHEMY_DATABASE_URI'] == 'sqlite:///../database.db' assert app.config['CACHE_TYPE'] == 'null'
def test_test_config(self): """ Tests if the test config loads correctly """ app = create_app('server.settings.TestConfig', env='dev') assert app.config['DEBUG'] is True assert app.config['SQLALCHEMY_ECHO'] is True assert app.config['CACHE_TYPE'] == 'null'
def start_app(): """ Run in development mode, never used in production. """ port = int(os.getenv("PORT", 5000)) try: app = create_app() app.run(host='0.0.0.0', port=port) except APIException as e: print ("Application failed to register with Service Discovery")
def export(path=None, gfm=False, context=None, username=None, password=None, render_offline=False, out_filename=None): """Exports the rendered HTML to a file.""" app = create_app(path, gfm, context, username, password, render_offline, render_inline=True) if out_filename is None: out_filename = os.path.splitext(app.config['GRIP_FILE'])[0] + '.html' print 'Exporting to', out_filename content = render_app(app) with io.open(out_filename, 'w', encoding='utf-8') as f: f.write(content)
def test_api_status_code_handling(self): app = create_app(config='test') b = Blueprint('test', __name__, url_prefix='/test') @b.route('/') @api def status_return(): return dict(msg='ok'), 666 app.register_blueprint(b) client = app.test_client() with app.test_request_context('/'): url = url_for('test.status_return') r = client.get(url) self.assertEqual(r.status_code, 666)
def test_non_jsonifiable_return_value(self): app = create_app(config='test') bad = Blueprint('test', __name__, url_prefix='/test') @bad.route('/hey') @api def bad_view(): return ['hey'] app.register_blueprint(bad) client = app.test_client() with app.test_request_context('/'): url = url_for('test.bad_view') r = client.get(url) self.assertEqual(r.status_code, 500)
def testapp(request): app = create_app('server.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
def cli(loop, test_client): app = server.create_app() return loop.run_until_complete(test_client(app))
def setUp(self): self.USER_GNUPGHOME = tempfile.TemporaryDirectory() self.ADMIN_GNUPGHOME = tempfile.TemporaryDirectory() self.INVALID_GNUPGHOME = tempfile.TemporaryDirectory() self.NEW_USER_GNUPGHOME = tempfile.TemporaryDirectory() self.config = ConfigParser() self.config.read_string(""" [mtls] min_lifetime=60 max_lifetime=0 [ca] key = secrets/certs/authority/RootCA.key cert = secrets/certs/authority/RootCA.pem issuer = My Company Name alternate_name = *.myname.com [gnupg] user={user_gnupghome} admin={admin_gnupghome} [storage] engine=sqlite3 [storage.sqlite3] db_path=:memory: """.format( user_gnupghome=self.USER_GNUPGHOME.name, admin_gnupghome=self.ADMIN_GNUPGHOME.name, )) self.key = generate_key() self.engine = storage.SQLiteStorageEngine(self.config) cur = self.engine.conn.cursor() cur.execute("DROP TABLE IF EXISTS certs") self.engine.conn.commit() self.engine.init_db() self.user_gpg = gnupg.GPG(gnupghome=self.USER_GNUPGHOME.name) self.admin_gpg = gnupg.GPG(gnupghome=self.ADMIN_GNUPGHOME.name) self.invalid_gpg = gnupg.GPG(gnupghome=self.INVALID_GNUPGHOME.name) self.new_user_gpg = gnupg.GPG(gnupghome=self.NEW_USER_GNUPGHOME.name) app = create_app(self.config) self.app = app.test_client() self.users = [ User("user@host", gen_passwd(), generate_key(), gpg=self.user_gpg), User("user2@host", gen_passwd(), generate_key(), gpg=self.user_gpg), User("user3@host", gen_passwd(), generate_key(), gpg=self.user_gpg), ] self.invalid_users = [ User("user4@host", gen_passwd(), generate_key(), gpg=self.invalid_gpg) ] self.admin_users = [ User("admin@host", gen_passwd(), generate_key(), gpg=self.admin_gpg) ] self.new_users = [ User("newuser@host", gen_passwd(), generate_key(), gpg=self.new_user_gpg), User("newuser2@host", gen_passwd(), generate_key(), gpg=self.new_user_gpg), ] for user in self.users: self.user_gpg.import_keys( self.user_gpg.export_keys(user.fingerprint)) self.user_gpg.trust_keys([user.fingerprint], "TRUST_ULTIMATE") for user in self.admin_users: # Import to admin keychain self.admin_gpg.import_keys( self.admin_gpg.export_keys(user.fingerprint)) self.admin_gpg.trust_keys([user.fingerprint], "TRUST_ULTIMATE") # Import to user keychain self.user_gpg.import_keys( self.admin_gpg.export_keys(user.fingerprint)) self.user_gpg.trust_keys([user.fingerprint], "TRUST_ULTIMATE") for user in self.invalid_users: self.invalid_gpg.import_keys( self.invalid_gpg.export_keys(user.fingerprint)) self.invalid_gpg.trust_keys([user.fingerprint], "TRUST_ULTIMATE") for user in self.new_users: self.new_user_gpg.import_keys( self.new_user_gpg.export_keys(user.fingerprint)) self.new_user_gpg.trust_keys([user.fingerprint], "TRUST_ULTIMATE")
# Script to run server; pass port option to change listening port # Place one level outside of directory server/ from tornado.wsgi import WSGIContainer from tornado.httpserver import HTTPServer from tornado.ioloop import IOLoop from tornado.options import define, options from server import create_app from server.config import ProductionConfig define("port", default=5000, help="Port to listen on", type=int) #app = create_app(config=ProductionConfig) app = create_app() #DebugConfig http_server = HTTPServer(WSGIContainer(app)) http_server.listen(options.port) IOLoop.instance().start()
def create_app(self): return create_app({'SQLALCHEMY_DATABASE_URI': 'sqlite://'})
import server from config import DefaultConfig application = server.create_app(DefaultConfig) if __name__ == "__main__": application.run()
def setUp(self): self.app = create_app() self.ctx = self.app.app_context() self.ctx.push()
def create_app(self): app = create_app('settings/test.py') # Default port is 5000 app.config['LIVESERVER_PORT'] = 8943 return app
def setUp(self): ''' Setup function ''' self.app = create_app('config.Test') self.tester_app = self.app.test_client()
#!/usr/bin/env python # encoding: utf-8 from server import create_app if __name__ == '__main__': MAIN = create_app() MAIN.run()
import server app = server.create_app() if __name__ == "__main__": app.run()
#! /usr/bin/env python """ Initializes the database schema. """ from server import create_app from database import db from models import * app = create_app("settings.DevelopmentConfig") db.create_all(app=app)
import unittest from flask_assets import ManageAssets from flask_rq import get_worker from flask_script import Manager, Server, Command from flask_script.commands import ShowUrls, Clean from flask_migrate import Migrate, MigrateCommand from server import create_app, generate from server.models import db, User, Course, Version from server.extensions import assets_env, cache # default to dev config env = os.getenv('OK_ENV', 'dev') app = create_app(env) migrate = Migrate(app, db) manager = Manager(app) class RunTests(Command): def run(self): test_loader = unittest.defaultTestLoader test_runner = unittest.TextTestRunner() test_suite = test_loader.discover('tests/') test_runner.run(test_suite) manager.add_command("server", Server(host='localhost')) manager.add_command("show-urls", ShowUrls())
# -*- encoding:utf-8 -*- from flask.ext.script import Manager from flask.ext.assets import ManageAssets from flask.ext.zen import Test, ZenTest from server import create_app from server.db import ( CreateDbCommand, CreateUserCommand, CreateUserDbCommand, ImportDataCommand, ) manager = Manager(create_app()) manager.add_command("assets", ManageAssets()) manager.add_command("test", Test()) manager.add_command("zen", ZenTest()) manager.add_command("create_user_db", CreateUserDbCommand()) manager.add_command("create_data_db", CreateDbCommand(None)) manager.add_command("create_user", CreateUserCommand()) manager.add_command("import_data", ImportDataCommand()) if __name__ == "__main__": manager.run()
def app(): os.environ["TODOS_FS_MODE"] = "testing" flask_app = create_app() return flask_app
def app(): return create_app('test')
#!/usr/bin/env python3 """ For WSGI Server To run: $ gunicorn -b 0.0.0.0:5000 wsgi:app OR $ export FLASK_APP=wsgi $ flask run """ import os from server import create_app env = os.environ.get('FLASK_ENV', 'prod') app = create_app('server.settings.%sConfig' % env.capitalize())
import logging import os from dotenv import load_dotenv from server import create_app, socketio for file in [x.strip() for x in os.getenv('CONFIG_ENV', default='').split(',')]: load_dotenv(file) #print(os.environ.values()) logging.basicConfig(level=logging.INFO) app = create_app(debug=True) if __name__ == '__main__': socketio.run(app)
from server import create_app app = create_app() if __name__ == "__main__": app.run()
# Get the locationless users no_location_users = db.session.query(User)\ .filter(User.lat==None)\ .filter(User.lng==None)\ .filter(User._location!=None)\ .execution_options(show_all=True)\ .all() for u in no_location_users: _set_user_gps_from_location(u.id, u._location, user_obj=u) db.session.commit() # from app folder: python ./migations/seed.py if __name__ == '__main__': current_app = create_app() ctx = current_app.app_context() ctx.push() create_ussd_menus() create_business_categories() reserve_token = create_reserve_token(current_app) create_master_organisation(current_app, reserve_token) create_float_transfer_account(current_app) refresh_user_locations(current_app) ctx.pop()
def setUp(self): self.app = create_app("dev") db = SQLAlchemy(self.app, {'expire_on_commit': False}) db.create_all() self.app_context = self.app.app_context() self.app_context.push()
import os from server import db, create_app os.system('export FLASK_APP=./server') db.create_all(app=create_app()) # export FLASK_APP= os.system('export FLASK_APP=./server')
from server import create_app application = create_app()
chain_config = app.config['CHAINS'][app.config['DEFAULT_CHAIN']] float_transfer_account = TransferAccount( private_key=chain_config['FLOAT_PRIVATE_KEY'], account_type=TransferAccountType.FLOAT, token=t, is_approved=True) db.session.add(float_transfer_account) db.session.flush() t.float_account = float_transfer_account t.float_account.is_public = True db.session.commit() print_section_conclusion('Done Creating/Updating Float Wallet') # from app folder: python ./migations/seed.py if __name__ == '__main__': current_app = create_app(skip_create_filters=True) ctx = current_app.app_context() ctx.push() create_ussd_menus() create_business_categories() reserve_token = create_reserve_token(current_app) create_master_organisation(current_app, reserve_token) create_float_transfer_account(current_app) ctx.pop()
#!/usr/bin/env python3 # To run: # gunicorn -b 0.0.0.0:5000 wsgi:app import os from server import create_app env = os.environ.get('OK_ENV', 'dev') app = create_app(env)
from server import create_app app = create_app()
def lambda_handler(event, context): print("Lambda event", event) return awsgi.response(create_app(), event, context, base64_content_types={"application/octet-stream"})
#!/usr/bin/env python3 import logging from logging.handlers import TimedRotatingFileHandler from server import create_app app, _args, _task_runner = create_app() def _configure_logging(): # System wide logging logger = logging.getLogger() log_fh = TimedRotatingFileHandler('logs/log', when='midnight', backupCount=30) log_fh.suffix = '%Y_%m_%d' formatter = logging.Formatter('[%(asctime)s] [%(levelname)8s] --- %(message)s (%(filename)s:%(lineno)s)"') log_fh.setFormatter(formatter) stderr_fh = logging.StreamHandler() logger.addHandler(log_fh) logger.addHandler(stderr_fh) logger.setLevel(logging.DEBUG) if __name__ == '__main__': _configure_logging() if _task_runner: logging.info('Starting task runner') _task_runner.start()
def create_cli_app(info): return create_app()
def create_app(self): return create_app('settings/test.py')
import os from server import create_app app = create_app(os.environ.get('CONFIG_MODE')) if __name__ == "__main__": print("eeee") app.run(ssl_context="adhoc")
import os import server env_flask_env = os.environ.get('FLASK_ENV') or 'development' env_conn_string = os.environ.get('DATABASE_CONNECTION_STRING') or 'postgresql://postgres@db:5432/' server.create_app({ 'SQLALCHEMY_DATABASE_URI': env_conn_string }) server.load_db() server.app.run(host='0.0.0.0', debug=(env_flask_env == 'development'))
from server import create_app create_app().run(debug=True, threaded=True)
configs = { 'SCREEN_WIDTH': width, 'SCREEN_HEIGHT': height, 'CARLA_HOST': servername, 'CARLA_PORT': carlaport, 'AUTO_PILOT': autopilot, 'ROLENAME': car_name, 'FILTER': car_type, 'WORLD_NAME': world, 'RCNN_MODEL_PATH': rcc_model_path, 'RCNN_MAP_PATH': rcnn_map_path, 'RCNN_NET_DIM': rcnn_net_dim, 'RCNN_MAX_PROPOSALS': rcnn_max_proposals, 'RCNN_POSITIVE_CLASS': rcc_positive_class, 'RCNN_THRESHOLD': rcnn_threshold, 'RCNN_LOOP_COUNTER': rcnn_loop_counter, } create_app(width,height,debug) init(configs) loop() stop() print("Service started") except Exception as e: show_traceback(override=True) print("Service failed: " + str(e))
def cli(loop, aiohttp_client): return loop.run_until_complete(aiohttp_client(create_app()))
# Copyright 2015 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import server import config app = server.create_app(config) # This is only used when running locally. When running live, gunicorn runs # the application. if __name__ == '__main__': app.run(host='127.0.0.1', port=8080, debug=True)
def check_recent_transaction_sync_status(interval_time, time_to_error): # Create app and get context, since this is running in new background processes on a timer! from server import create_app app = create_app(skip_create_filters=True) with app.app_context(): _check_recent_transaction_sync_status(interval_time, time_to_error)
from flask import Flask, render_template, jsonify, request, Blueprint from server.models.client import * from server.config import config from server import create_app debug = __name__ == '__main__' app = create_app(config, debug) if __name__ == '__main__': app.run(debug=debug, port=5000)
def test_request_context(): flask_app = create_app() # can be used in combination with the WITH statement to activate a request context temporarily. # with this you can access the request, g and session objects in view functions yield flask_app.test_request_context
from server import create_app from gevent.wsgi import WSGIServer from gevent import monkey # Change the host and port here HOST = '0.0.0.0' PORT = 8888 app = create_app('development') kwargs = { 'host':HOST, 'port':PORT, } if __name__ == '__main__': #app.run(**kwargs) monkey.patch_socket() server = WSGIServer((HOST, PORT), app) server.serve_forever()
#!/usr/bin/env python from common import hack_syspath hack_syspath(__file__) import argparse from equanimity.world import init_db from server import create_app def get_args(): p = argparse.ArgumentParser() p.add_argument('--reset', action='store_true', help='Reset original world') p.add_argument('-v', '--verbose', action='store_true', help='Verbose output') p.add_argument('--grid-radius', type=int, default=8, help='Radius of world and field grids') p.add_argument('--square-grid', action='store_true', help='Use a square grid') return p.parse_args() if __name__ == '__main__': args = get_args() with create_app().test_request_context(): init_db(reset=args.reset, verbose=args.verbose, grid_radius=args.grid_radius, square_grid=args.square_grid)
def setUp(self): if not self.is_setup: self.__class__.app = server.create_app(Testing).test_client() self.__class__.is_setup = True self.__class__.data_directory = os.path.join( os.getcwd(), 'tests/data')
from server import create_app import config print dir(config) # initialize the application app = create_app(config, debug=True)
def create_test_app(self): app = create_app( {'SQLALCHEMY_DATABASE_URI': self.SQLALCHEMY_DATABASE_URI}) return app
def create_app(self, mongo, dropbox, datastore_manager): app = create_app() app.config['TESTING'] = True self.db = mongo().db.geonauts return app
from server import create_app from config import ProductionConfig from routes.notes_routes import notes from routes.users_routes import users app = create_app(ProductionConfig, users, notes) if __name__ == "__main__": app.run()