def init(): """initialize database and directories""" try: remakedir(settings.DATA_DIR_PATH) remakedir(settings.DEMO_DIR_PATH) remakedir(settings.THUMBNAIL_DIR_PATH) except: print sys.exc_info() try: if os.path.exists(settings.DB_PATH): os.remove(settings.DB_PATH) init_db() if getpwuid(os.getuid())[0] == "root": os.chown(settings.DB_PATH, apache_uid, apache_gid) except: print sys.exc_info() try: role_admin = UserRole("admin", "for administrators") db_session.add(role_admin) user_admin = User("admin", role=role_admin) db_session.add(user_admin) db_session.commit() db_session.remove() except: print sys.exc_info()
def main(): init_db() rebase() contact = Contact.create( "John F Kidd", "0765242421", "*****@*****.**", comments="A test comment @ {}".format(time.strftime("%H:%M:%S"))) execute = handle_error(log_error, log_info) execute(lambda: create_and_read(contact), get_description)
def startmeup(): wsgi_app = WSGIContainer(app) application = Application([ (r"/s/(.*)", StaticFileHandler, { "path" : basedir + "/app/static" }), (r"/socket", core.ClientSocket), (r"/publish", core.Publisher), (r".*", FallbackHandler, dict(fallback=wsgi_app)), ]) CONN_STR = app.config['SQLALCHEMY_DATABASE_URI'] print("Connection string is ? " + CONN_STR) db.init_db( CONN_STR ) application.listen(8888) IOLoop.instance().start()
def conn() -> sqlite3.Connection: conn = sqlite3.connect(":memory:") db.init_db(conn) return conn
async def startup_event(): """initialize the db on startup""" log.info("starting up") init_db(app)
def setUpClass(cls): os.environ['APP_SETTINGS'] == 'testing' or os.environ.update(APP_SETTINGS='testing') cls.config_obj = get_env_config() cls.meta_db = get_db_metadata() init_db(seed_data=True, rebuild=True)
async def startup_event(): log.info("Starting Up...") init_db(app)
def db(): init_db()
from app import app, db if __name__ == "__main__": db.init_db("schema.sql") app.run(debug=False)
from app import db db.init_db() for _t in db.Base.metadata.tables: print("Table: ", _t)
async def startup_event(): print('Starting up...') init_db(app)
import unittest import json import tempfile import time import app as sensors_app from app import db # データベースの準備 tempDB = tempfile.mkstemp() tempDBPath = tempDB[1] dburl = "sqlite:///" + tempDBPath app = sensors_app.create_app(dburl) db.init_db(app) with app.app_context(): db.create_all() class TestUserControl(unittest.TestCase): def setUp(self): self.app = app.test_client() def test_health(self): rv = self.app.get("/api/") self.assertIn(b"Sensors", rv.data) def test_user_isexist(self): testuser = {"name": "test_user_isexist", "password": "******"}
def run(self): from app import db with app.app_context(): db.init_db()
def setup_func(): """ Initializes the database before each test run. """ init_db()
def create_app(environment="development"): """ Setup de la aplicacion """ app = Flask(__name__) app.response_class = CookiesLaxResponse # Compilacion de archivos scss Scss(app, static_dir='app/static', asset_dir='app/assets/scss') cors = CORS(app, resources={r"/api/*": { "origins": "*" }}, support_credentials=True) app.config['CORS_HEADERS'] = 'Content-Type' # Configuracion de variables de flask app.config.from_object(config[ENVIRONMENT]) # Inicializacion de la base de datos init_db() load_database() # Global de jinja para obtener los permisos en navbar from app.helpers.permission import user_permissions app.jinja_env.globals.update(user_permissions=user_permissions) from app.helpers.auth import check_login app.jinja_env.globals.update(check_login=check_login) # Global de jinja para el path de los archivos publicos app.jinja_env.globals.update( UPLOADS_PUBLIC_DIRECTORY=UPLOADS_PUBLIC_DIRECTORY.replace('./app', '')) # Reglas de ruteo from app.resources import user app.register_blueprint(user.bp) from app.resources import auth app.register_blueprint(auth.bp) from app.resources import configuration app.register_blueprint(configuration.bp) from app.resources import center app.register_blueprint(center.bp) from app.resources.api import center as center_api app.register_blueprint(center_api.bp) from app.resources.api import tipo as tipo_api app.register_blueprint(tipo_api.bp) from app.resources.api import configuration as configuration_api app.register_blueprint(configuration_api.bp) from app.resources.api import statistics as statistics_api app.register_blueprint(statistics_api.bp) from app.resources import turn app.register_blueprint(turn.bp) # Config de la sesion app.config["SESSION_TYPE"] = "filesystem" Session(app) # Config del directorio publico de archivos app.config["UPLOADS_PUBLIC_DIRECTORY"] = UPLOADS_PUBLIC_DIRECTORY @app.route('/') def home(): """ Página inicial del sistema. """ from app.models.configuration import Configuration as Config config = Config.query.filter(Config.name.like('home%')).all() homeConfig = {} from app.helpers.auth import desloguear_usuario_inactivo from app.models.user import User from flask import session if check_login(): desloguear_usuario_inactivo( User.query.filter( User.username == session["username"]).first()) for element in config: homeConfig[element.name] = element.value return (render_template('home.html', homeConfiguration=homeConfig)) @app.teardown_appcontext def shutdown_session(exception=None): """ Codigo para que se puede bajar la base de datos automaticamente """ db_session.remove() return app
def create_db(): init_db()
async def startup_event(): logger.info("Starting up...") init_db(application)
from flask import (Flask) from app.db import init_db, get_dynamodb from app.api.routes import (api as api_blueprint) def create_app(): app = Flask(__name__) app.config.from_object('app.config.Config') app.register_blueprint(api_blueprint) return app app = create_app() dynamodb = get_dynamodb( app.config.get('AWS_REGION'), app.config.get('AWS_KEY'), app.config.get('AWS_SECRET'), ) init_db(dynamodb, app) if __name__ == '__main__': app.run()
import os from flask import Flask, make_response, jsonify from flask_cors import CORS from app import db mongo = db.init_db() def create_app(test_config=None): # create and configure the app app = Flask(__name__, instance_relative_config=True) app.config.from_mapping() CORS(app) if test_config is None: app.config.from_pyfile('config.py', silent=True) else: app.config.from_mapping(test_config) # ensure the instance folder exists try: os.makedirs(app.instance_path) except OSError: pass @app.errorhandler(400) def not_found(error):
from app import create_app from app.db import init_db, seed app = create_app({}) init_db(app) seed()
from flask import Flask import config app = Flask('phobook') app.config.from_object('config') # Handling OPTION Method request for cross site from flask_cors import CORS, cross_origin cors = CORS(app, resources={r"/*":{"origins":"*"}}) # Identicon generator from pydenticon import Generator pydent = Generator(8, 8) from app.db import init_db, db_session init_db() from app.login import * @app.teardown_appcontext def shutdown_session(exception): db_session.remove() from app.controller import routes routes(app) from flask_socketio import SocketIO socketio = SocketIO(app) from app.socket import register_socket
def create_app(self): self.app = Flask(__name__, template_folder='../app/templates') self.app.config['TESTING'] = True self.app.config['USERNAME'] = '******' self.app.config['PASSWORD'] = '******' self.app.testing = True self.app.config.from_mapping( SECRET_KEY='dev', DATABASE=os.path.join(self.app.instance_path, 'test_app.sqlite'), ) # ensure the instance folder exists try: os.makedirs(self.app.instance_path) except OSError: pass with self.app.app_context(): db.init_app(self.app) db.init_db() self.db = db.get_db() from app.routers import recipes, meals, ingredients, auth self.app.register_blueprint(auth.bp) self.app.register_blueprint(ingredients.bp) self.app.register_blueprint(recipes.bp) self.app.register_blueprint(meals.bp) @self.app.route('/') def index(): """ Displays the index page accessible at '/' """ return redirect(url_for('recipes.index')) # adding ingredients # liquid ingredient ing1 = {'id': 1, 'name': "ing_unittest1_liquid", 'name_key': "ing_unittest1_liquid", 'portion_size': 4, 'portion_size_unit': "cup", 'portion_converted': h.convert("cup", 4), 'protein': 5.5, 'fat': 7.1, 'carbs': 20.5, 'calories': 98, 'price': 0 * 100, 'price_size': 0.01, 'price_size_unit': "gal", 'tag': "dairy", 'notes': "no notes"} # spice ingredient (macros are 0, price is based on units) ing2 = {'id': 2, 'name': "ing_unittest2_spice", 'name_key': "ing_unittest2_spice", 'portion_size': 2, 'portion_size_unit': "unit", 'portion_converted': h.convert("unit", 2), 'protein': 0, 'fat': 0, 'carbs': 0, 'calories': 0, 'price': 2.99 * 100, 'price_size': 2, 'price_size_unit': "unit", 'tag': "spices", 'notes': "no notes"} # solid ingredient ing3 = {'id': 3, 'name': "ing_unittest3_solid", 'name_key': "ing_unittest3_solid", 'portion_size': 355, 'portion_size_unit': "g", 'portion_converted': h.convert("g", 355), 'protein': 21.2, 'fat': 14, 'carbs': 133, 'calories': 257, 'price': 3.79 * 100, 'price_size': .5, 'price_size_unit': "kg", 'tag': "proteins", 'notes': "no notes"} # flour (cup measures are to be converted to grams, not volume) ing4 = {'id': 4, 'name': "ing_unittest4_cup", 'name_key': "ing_unittest4_cup", 'portion_size': 4, 'portion_size_unit': "cup", 'portion_converted': h.convert("cup", 4), 'protein': 5.2, 'fat': 23, 'carbs': 23, 'calories': 240, 'price': 3.04 * 100, 'price_size': 5, 'price_size_unit': "lb", 'tag': "carbs", 'notes': "no notes"} # onion (portion is unit but price is in lbs) ing5 = {'id': 5, 'name': "ing_unittest5_onion", 'name_key': "ing_unittest5_onion", 'portion_size': 2, 'portion_size_unit': "unit", 'portion_converted': h.convert("unit", 2), 'protein': 2, 'fat': 2, 'carbs': 2, 'calories': 17, 'price': 2.99 * 100, 'price_size': 5, 'price_size_unit': "lb", 'tag': "vegetables", 'notes': "no notes"} for ing in [ing1, ing2, ing3, ing4, ing5]: self.db.execute('INSERT INTO ingredient VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', tuple(ing.values())) # adding recipes recipe1 = [ {'id': 1, 'author_id': "unittest", 'title': "recipe_unittest1", 'body': "Empty body", 'servings': 3, 'tag': "beans"}, [(ing2, 1, 't'), (ing3, 14, 'oz'), (ing5, 1, 'unit')]] recipe2 = [ {'id': 2, 'author_id': "unittest", 'title': "recipe_unittest2", 'body': "Empty body", 'servings': 4, 'tag': "dessert"}, [(ing2, 1, 'T'), (ing1, 6, 'oz'), (ing4, 280, 'g')]] for r, ings in [recipe1, recipe2]: self.db.execute('INSERT INTO recipe VALUES (?, ?, ?, ?, ?, ?)', tuple(r.values())) for ing in ings: self.db.execute('INSERT INTO recipeIngredientRelationship (recipeID, ingredientID, quantity, units) ' 'VALUES (?, ?, ?, ?)', (r['id'], ing[0]['id'], ing[1], ing[2])) # adding meals meal1 = [{'id': 1, 'author_id': "unittest", 'title': "meal_unittest1", 'tag': "easy", 'notes': "None."}, [recipe1], 4] meal2 = [{'id': 2, 'author_id': "unittest", 'title': "meal_unittest2", 'tag': "brunch", 'notes': "None."}, [recipe1, recipe2], 3] for m, recipes, servings in [meal1, meal2]: self.db.execute('INSERT INTO meal VALUES (?, ?, ?, ?, ?)', tuple(m.values())) for r in recipes: self.db.execute('INSERT INTO mealRecipeRelationship (mealID, recipeID, servings) ' 'VALUES (?, ?, ?)', (m['id'], r[0]['id'], servings)) self.db.commit() return self.app
async def startup_event(): """ startup event definition """ log.info("Starting up...") init_db(app)
controller['rv'] = line[7:11] larr.append(line) payload = dict( controllerId = controller['id'], controllerName = controller['name'], fridge = controller['fv'], fridgeSet = cs['fridgeSet'], beer = controller['bv'], beerSet = cs['beerSet'], room = controller['rv'], status = larr[-1]) if cs['mode'] == 'p': payload.update( dict(profile = cs['profile'])) return dict( channel = "data", payload = payload ) def scan(self): for controller in self.controllers: lcd = self.getData(controller, "lcd") cs = self.getData(controller, "getControlSettings") msg = self.createDataMessage(controller, lcd, cs) self.postMessage("data", msg) # init db connection - this may create it if not there ?!? db.init_db( SQLALCHEMY_DATABASE_URI ) # create the maelstrom -> brewpi bridge bridge = BrewPiBridge( db.DBSession().query(db.IOController).all() ) while True: bridge.scan() time.sleep(5)
def setUp(self): if not self.client: self.skipTest("Client not initialized") else: self.client.implicitly_wait(3) init_db(rebuild=True, seed_data=True)
def reset(): init_db() return 'ok'
def setUp(self): os.environ['APP_SETTINGS'] == 'testing' or os.environ.update(APP_SETTINGS='testing') self.config_obj = get_env_config() self.db = db_session() init_db() self.meta_db = get_db_metadata()
def main() -> None: logger.info("Creating initial data") asyncio.run(init_db()) logger.info("Initial data created")
async def startup_event() -> None: """Initialize ORM for summarizer web app.""" logger.info('Starting up...') init_db(app)
#!/usr/bin/env python3 from app import db if __name__ == '__main__': print('Initializing the database...') admin_username, admin_password = db.init_db() print('Initialization done') print('Initial admin username: {}, password: {}'.format( admin_username, admin_password))
#============================================================================== # File: run.py # Auth: Andrew Calvano / Jim Ching # Desc: Start the Flask Application #============================================================================== from app import app # __init__.py globals from app.db import init_db # db.py globals from sys import argv if len(argv) >= 2: # initialize the admin account if argv[1] == 'init': init_db() else: print 'Usage: \'python run.py\' or \'python run.py init\' only.' else: # start the flask application app.run('127.0.0.1', debug = True)
def setUp(self): app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///test.db" # For most tests we don't care about the CSRF token. flask_wtf.csrf.validate_csrf = lambda token: True db.drop_all() init_db()