def admin_install(user): db.drop_all() db.create_all() create_test_data() return redirect("/admin", code=302)
def create_app(config_file): # load config app.config.from_pyfile(config_file) from views.backgrounds import load_backgrounds load_backgrounds(app) # setup db from database import db db.init_app(app) # setup login login_manager.init_app(app) # login_manager.setup_app(app) from monkey.views import index_view, login_view for bp in [login_view, index_view]: app.register_blueprint(bp) # init all with app.app_context(): db.create_all() import api api.start_api([UserModel]) UserModel.initialize() return app
def create_app(app): # config app app.config.from_object(os.environ["APP_SETTINGS"]) # initiate extensions db.init_app(app) ma.init_app(app) celery.init_app(app) jack_apns.init_app(app) # declare models import models # init app with app.app_context(): # db.reflect() # db.drop_all() db.create_all() app.register_blueprint(auth, url_prefix="/auth") app.register_blueprint(user, url_prefix="/user") app.register_blueprint(group, url_prefix="/group") app.register_blueprint(post, url_prefix="/post") app.register_blueprint(comment, url_prefix="/comment") app.register_blueprint(invite, url_prefix="/invite") app.register_blueprint(generic, url_prefix="/generic") app.register_blueprint(rule, url_prefix="/rule")
def setup_db(): with app.app_context(): # print app db.drop_all() db.create_all() db.session.commit() print "database is set up!"
def setUp(self): # Change the database to a test one in memory and # create all our tables there app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://' with app.app_context(): db.create_all() self.app = app.test_client()
def create_app(debug=False): def load_env(env_name, conf_name = None): """Load the specified key to config from env if exists""" if conf_name is None: conf_name = env_name app.config[conf_name] = os.environ.get(env_name, app.config.get(conf_name)) app = Flask(__name__) app.debug = debug app.config.from_object(os.environ.get('APP_CONFIG', 'config.DevelopmentConfig')) load_env('DATABASE_URL', 'SQLALCHEMY_DATABASE_URI') load_env('GCM_TOKEN') app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension') # Database creation db.init_app(app) with app.app_context(): db.create_all() # # Create the services # gcm = GCM(app.config['GCM_TOKEN']) authService = AuthenticationService(db) messageService = GCMMessengerService(db, gcm) locatorService = LocatorService(db, messageService) relayService = RelayService(db, messageService) # Easy method to get currentuser def current_user(): token = request.headers.get('Authorization') return authService.getUserFromAccessToken(token) # # Blueprints # authcheckBlueprint = authcheck_blueprint(authService, locatorService) locatorBlueprint = locator_blueprint(db, locatorService, current_user) relayBlueprint = relay_blueprint(db, relayService, current_user) refBlueprint = refactor_blueprint(db, authService, app, current_user) # Needs app for now as it has the apimanager... app.register_blueprint(locatorBlueprint) app.register_blueprint(relayBlueprint) app.register_blueprint(authcheckBlueprint) app.register_blueprint(refBlueprint) # Create admin interface admin.init_app(app, messageService, locatorService) # I'm a teapot. @app.route("/") def index(): abort(418) return app
def create_app(): app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/user_management.db' db.init_app(app) db.app = app from models import User, Group db.create_all() migrate.init_app(app,db) return app
def setUp(self): app.config.from_object('config.TestingConfig') self.client = app.test_client() db.init_app(app) with app.app_context(): db.create_all() user_datastore.create_user(email='test', password=encrypt_password('test')) db.session.commit()
def setUp(self): if not main.app.config['SQLALCHEMY_DATABASE_URI'].startswith('sqlite://'): raise RuntimeError('Test against sqlite DB! not %r' % main.app.config['SQLALCHEMY_DATABASE_URI']) main.app.config['TESTING'] = True main.app.debug = True main.app.test_request_context().push() db.drop_all() db.create_all()
def test_db(flask_app): uuid = str(uuid4()) flask_app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test-{}.db'.format(uuid) db.init_app(flask_app) with flask_app.app_context(): db.create_all() return db
def setup_database(app): with app.app_context(): db.create_all() home = Page() home.name = "Home" contact = Page() contact.name = Page() db.session.add(home) db.session.add(contact) db.session.commit()
def create_db(): import os if os.path.exists(DB_PATH): return db.create_all() roles = [u'user', u'operator', u'administrator'] subjects = [u'Programming'] categories = [ u'ASP.NET', u'Assembler', u'C', u'C#', u'C++', u'Delphi | Pascal', u'Java', u'HTML | CSS | JavaScript', u'Oracle', u'Python', u'QT', u'SQL | MySQL | MS SQL | PL/SQL', u'Visual Basic', u'Other' ] os_list = [u'Windows', u'Unix-like'] task_statuses = [ ('New', 'Client submitted the new task and operator hasn\'t got it yet'), ('Discussion', 'Operator discussing details with Client'), ('Solving', 'Task went off to solving'), ('Pending', 'Payment is going to be delivered soon by PayPal'), ('Done', 'User received solution'), ] for r in roles: db.session.add(Role(r)) db.session.commit() for s in subjects: db.session.add(Subject(s)) db.session.commit() s = Subject.query.filter_by(name=u'Programming').first() for c in categories: db.session.add(Category(name=c, subject_id=s.id)) for o in os_list: db.session.add(OS(n=o)) for ts in task_statuses: db.session.add(TaskStatus(*ts)) db.session.commit()
def setUp(self): db.create_all() man1 = Manufacturer('chrysler', 3, 32971.67, 'town-and-country', 291.33) db.session.add(man1) man2 = Manufacturer('buick', 3, 31050.0, 'cascada', 236.33) db.session.add(man2) man3 = Manufacturer('kia', 9, 28725.56, 'k900', 216.11) db.session.add(man3) man4 = Manufacturer('lexus', 25, 52488.2, 'ls-600h-l', 290.32) db.session.add(man4) db.session.commit()
def setUp(self): db.create_all() engine1 = Engine('3.5 V6', 6, 'premium unleaded (recommended)', 279, 252) db.session.add(engine1) engine2 = Engine('Engine', 4, 'regular unleaded', 200, 206) db.session.add(engine2) engine3 = Engine('Engine', 4, 'premium unleaded (required)', 237, 258) db.session.add(engine3) engine4 = Engine('Hybrid', 6, 'premium unleaded (recommended)', 377, 341) db.session.add(engine4) db.session.commit()
def setUp(self): db.create_all() car1 = Car('acura', 'ilx', 2016, 31890.0, 201) db.session.add(car1) car2 = Car('toyota', 'tundra', 2015, 46530.0, 381) db.session.add(car2) car3 = Car('ford', 'fusion', 2017, 33360.0, 325) db.session.add(car3) car4 = Car('acura', 'rdx', 2016, 40370.0, 279) db.session.add(car4) db.session.commit()
def create_app(config): """ Given a configuration object, create a WSGI(Flask) app See `APP_CONFIG` in ../config.py for example configuration. """ app = Flask(__name__) app.config.update(config) register_blueprints(app) db.init_app(app) with app.app_context(): db.create_all() return app
def initialize_database(): """ Initialisiere die Datenbank mit Testdaten. Alle vorhandenen Daten werden geluescht. """ stations = (("Oper", "Operngasse 1", "1010", "Wien", u"Österreich"), ("Hohe Warte Stadium", "Heiligenstadt", "1190", "Wien", u"Österreich"), ("Fliegerhorst Brumowski", "Brumowskigasse 23", "3425", "Tulln an der Donau", u"Österreich"), ("FH Technikum Wien", "Höchstädtplatz 6", "1200", "Wien", u"Österreich"), ("Red Bull Ring", u"Schloßweg 1", "8724", "Spielberg", u"Österreich")) cars = (("Citroen", u"C3", "silber", 5, 4.8, 50, "W-997G"), ("Ford", u"Focus", "rot", 5, 5.9, 70, "W-997GH"), ("Smart", u"ForTwo", "gelb", 2, 3.5, 70, "W-997GI"), ("VW", u"Käfer", "Rost", 4, 6.8, 40, "W 992223" ), ("Renault", "Grand Espace", "schwarz", 7, 8.8, 120, "K 009DF"), ("McLaren", "P1", "gelb", 2, 12.3, 190, "S 99823")) kunden = (("Alice Amber", "Nussdorfer Strasse 77", "1090", "Wien", u"Österreich"), ("Bob Builder", "Lederwaschstrasse 2", "5589", "Tamsweg", u"Österreich"), ("Istvan Nagy", "Halasz utca 25", "9400", "Sopron", u"Ungarn"), ("Ignaz Zurbgriggen", "Wildbachstrasse 9", "8340", "Hinwil", u"Schweiz"), ("Charly Custer", "Albrechtgasse 530", "3571", "Gars am Kamp", u"Österreich"), ("Eve Easter", "Kardinal Piffl Platz 2", "3400", "Klosterneuburg", u"Österreich")) db.drop_all() db.create_all() for c in cars: d = dict(zip( ('manufacturer', 'typ', 'color', 'seats', 'consumption', 'price', 'platenumber'), c)) db.session.add(Car(**d)) for s in stations: d = dict(zip( ('name', 'street', 'plz', 'city', 'country'), s)) db.session.add(Station(**d)) for k in kunden: d = dict(zip( ('name', 'street', 'plz', 'city', 'country'), k)) db.session.add(Kunde(**d)) db.session.flush() c3, focus, fortwo, kaefer, espace, p1 = Car.query.all() oper, hohewarte, lale, fh, rbr = Station.query.all() alice, bob, istvan, ignaz, charly, eve = Kunde.query.all() c3.station = hohewarte focus.station = lale espace.station = hohewarte Leihe(kunde=alice, car=c3, von=parsedate('2014-02-01 14:00'), bis=parsedate('2014-02-10 10:00'), returned=True, station_abhol=hohewarte, station_return=hohewarte) Leihe(kunde=alice, car=c3, von=parsedate('2014-02-14 08:00'), bis=parsedate('2014-02-15 22:00'), returned=True, station_abhol=hohewarte, station_return=lale) Leihe(kunde=ignaz, car=c3, von=datetime.today() - timedelta(days=2), bis=datetime.today() + timedelta(days=5), returned=False, station_abhol=hohewarte, station_return=rbr) Leihe(kunde=istvan, car=p1, von=parsedate('2014-01-14 09:00'), bis=datetime.today() + timedelta(days=2), returned=False, station_abhol=lale, station_return=fh) Leihe(kunde=charly, car=p1, von=datetime.today() + timedelta(days=10), bis=datetime.today() + timedelta(days=12), returned=False, station_abhol=lale, station_return=fh) db.session.commit()
def main(run_folders, users_file): db.init_app(app) logging.basicConfig(filename = 'NIPT_database_log', level=logging.DEBUG) db.create_all() NDBS = NiptDBSetup(db) NDBS.set_users(users_file) for folder in run_folders: BM = BatchMaker(db) BM.get_run_folder_info(folder) if BM.batch_id: BM.update_nipt_db(folder) else: logging.warning("Could not add to database from resultfile: %s" % path)
def configure_app(app, workdir): import os.path workdir = os.path.abspath(workdir) app.config['OSMPOINT_ADMINS'] = [] app.config['IMPORTED_POINTS_PATH'] = None config_file = os.path.join(workdir, 'config.py') app.config.from_pyfile(config_file, silent=False) app.config['IMPORTED_POINTS'] = load_imported_points( app.config['IMPORTED_POINTS_PATH']) with app.test_request_context(): db.create_all()
def main(flowcell_ids, users_file): db.init_app(app) logging.basicConfig(filename = 'NIPT_database_log', level=logging.DEBUG) db.create_all() NDBS = NiptDBSetup(db) NDBS.set_users(users_file) for flowcell_id in flowcell_ids: BM = BatchMaker(db) BM.parse_path(flowcell_id) BM.get_run_folder_info() if BM.batch_id: BM.update_nipt_db() else: logging.warning("Could not add to database from run: %s" % flowcell_id)
def build_db(app): with app.app_context(): print("dropping...") db.drop_all() print("creating structure...") db.create_all() if prompt_bool("Populate from 'rare pepes (tm)' album"): if not client: raise RuntimeError("no imgur credentials found") for album in ["U2dTR"]: for img in client.get_album_images(album): add_from_img(img, origin="1270 rare pepes (U2dTR)") #sleep(1) db.session.commit()
def check(): #database stuff db.create_all() ans = request.form ans_graded = [] for item in ans: if item == ans[item]: modifyDatabase(item, True) ans_graded.append(True) else: modifyDatabase(item, False) ans_graded.append(False) return jsonify(answers = ans_graded)
def setUp(self): app.config.from_object('config.DevelopmentConfig') app.config['TESTING'] = True app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql:///contacts_test' app.config['WTF_CSRF_ENABLED'] = False self.app = app.test_client() with app.app_context(): db.create_all() self.data = { 'first_name': "first_name", "last_name": "last_name", "phone_number": "1111111111", "email": "*****@*****.**", "birthdate": str(int(time.mktime(datetime.date.today().timetuple()) * 1000)) }
def create_app(): from views import auth, main app = Flask(__name__, template_folder='templates') app.config.from_object(config) # Blueprints: app.register_blueprint(auth) app.register_blueprint(main) # Custom modules: login_manager.init_app(app) # login_manager.login_view = 'auth.login' db.init_app(app) # Dynamic context: with app.app_context(): db.create_all() return app
def __init__(self, name, config=None, reinit_db=False): if not config: config = {"SQLALCHEMY_DATABASE_URI": "sqlite:///platformer_node_{}.db".format(name)} self.app = flask.Flask(__name__) self.app.config.update(config) db.init_app(self.app) with self.app.app_context(): if reinit_db: db.drop_all() db.create_all() manager = flask.ext.restless.APIManager(self.app, flask_sqlalchemy_db=db) manager.create_api(Peer, url_prefix="", methods=["GET", "POST", "PUT", "DELETE"], include_columns=["url"]) manager.create_api(Secret, url_prefix="", methods=["POST"]) # Note that route definitions have to go here, because the app is not global. @self.app.route("/", methods=["HEAD"]) def pong(): return ""
def setUp(self): # Change the database to a test one in memory and # create all our tables there app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://' app.config['UPLOAD_LOCATION'] = os.path.join(HERE, 'test_uploads') with app.app_context(): db.create_all() self.app = app.test_client() # Create a test user self.app.post("/user", data={'username': '******', 'password': '******', 'email': '*****@*****.**'}) with open(os.path.join('test_data', 'test.mp3'), 'rb') as f: self.mp3_file = f.read() with open(os.path.join('test_data', 'test.txt'), 'rb') as f: self.text_file = f.read()
def setup(): if not config.get('setup', bool): abort(404) if request.method == 'POST': if not check_keys(): flash(error_message) return render_template('setup.html') username = request.form['username'] password = request.form['password_1'] email = request.form['email'] db_uri = request.form['database_uri'] # create database config.set('database_uri', db_uri) app.config['SQLALCHEMY_DATABASE_URI'] = db_uri db.drop_all() db.create_all() # create admin user admin = NewUser(username, password, email) admin.admin = True admin.active = True admin.create() # generate secret key secret_key = os.urandom(24) config.set('secret_key', secret_key) app.config['SECRET_KEY'] = secret_key # set a default upload directory blackboard_root = os.path.dirname(os.path.abspath(__file__)) config.set('upload_destination', blackboard_root + '/static/upload') # disable setup config.set('setup', 'False') flash(messages.setup_finished, 'message') return redirect(url_for('login')) else: return render_template('setup.html')
def create_database(): db.create_all() '''car_json = json.load(open('cars_list.json')) create_cars(car_json) manufacturer_json = json.load(open('makes_list.json')) create_manufacturers(manufacturer_json)''' with open('cars_list.json') as car_json: car_data = json.load(car_json) create_cars(car_data) with open('makes_list.json') as manufacurer_json: manufacturer_data = json.load(manufacturer_json) create_manufacturers(manufacturer_data) with open('engines_list.json') as engine_json: engine_data = json.load(engine_json) create_engines(engine_data)
def setup_flask(drop_all=False): ''' initialize top level objects give orm and router accesss flash returns app and api to simplify usining this independently of the full app ''' # TODO error handling app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test.db' db.init_app(app) with app.app_context(): # Extensions like Flask-SQLAlchemy now know what the "current" app # is while within this block. Therefore, you can now run........ if drop_all: db.drop_all() db.create_all() api = Api(app, catch_all_404s=True) build_endpoints(api) return app, api
def __new__(cls, *args, **kwargs): if cls._instance is None: app = Flask(__name__) app.register_blueprint(PeopleBluePrintFactory.create()) flask_injector = FlaskInjector( app=app, modules=[DatabaseModule(), ], ) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/production.db' db.init_app(app) with app.app_context(): db.create_all() cls._instance = flask_injector return cls._instance
def init_db(database_path): if not os.path.exists(database_path): db.create_all() populateEmployeeTable() populateEmployeeLeaveTable()
from flask import Flask from flask_restful import Api from flask_cors import CORS from flask_sqlalchemy import SQLAlchemy import json from controllers import mainControllers from database import db from models import Organization app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///static/db/ey.db' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True CORS(app) db.init_app(app) # db.drop_all(app=app) db.create_all(app=app) api = Api(app) api.add_resource(mainControllers.OrganizationList, '/orgs') api.add_resource(mainControllers.OrganizationController, '/orgs/<org_id>') api.add_resource(mainControllers.NewsController, '/news/<news_keyword>') def populate_db(): with app.app_context(): o = Organization('Testing', '555-512-1234') db.session.add(Organization('Real Estate', '555-555-5555')) db.session.add(Organization('Insurance', '555-555-5556')) db.session.add(Organization('Private Equity', '555-555-5557')) db.session.commit()
def setUp(self): db.create_all()
d.session.add(db_game) db_steamgame = database.SteamGame(game=db_game, steam_app_id=game["appid"], steam_app_name=game["name"]) d.session.add(db_steamgame) copy = d.session.query(database.SteamGame) \ .filter_by(steam_app_id=game["appid"]) \ .join(database.Game) \ .join(database.Copy) \ .filter_by(owner_id=user["id"]) \ .first() if copy is not None: continue print(game["name"]) if game["playtime_forever"] > 0: play_status = None else: play_status = database.GameProgress.NOT_STARTED d.session.flush() copy = database.Copy(owner_id=user["id"], game_id=db_steamgame.game_id, progress=play_status) d.session.add(copy) d.session.commit() return f.redirect(f.session.get("openid_redirect_to")) if __name__ == "__main__": d.create_all(app=app) app.run()
def setUp(self): create_test_app() db.create_all()
def create_db(): db.create_all()
def create_database(): from database import db db.create_all()
def init_db(app): with app.app_context(): db.create_all() print 'created tables'
def index(): db.create_all() return 'Hello World'
def create_db(): """Create database migrations and upgrade it""" db.create_all()
api_instance.add_namespace(endpoint_api, path='/endpoint') api_instance.init_app(app) # Initialize the api TaskBase = celery.Task # Fiddle with celery because Flask needs to be able to work with celery, and without this bit celery doesn't have the correct app context. class ContextTask(TaskBase): abstract = True def __call__(self, *args, **kwargs): with app.app_context(): return TaskBase.__call__(self, *args, **kwargs) celery.Task = ContextTask # Set up database db.init_app(app) # Initialize the database with the app print("Resetting the database") db.drop_all( app=app) # Drop the table here, so we have a fresh start every time. db.create_all( app=app ) # If the database table doesn't already exist, then create it here. # Setup cache cache.init_app(app) if __name__ == '__main__': app.run(host='127.0.0.1', debug=True, port=80)
def create(): db.create_all()
def create_db(app): with app.app_context(): db.create_all()
def init_db(flask_app): db.init_app(flask_app) db.create_all()
def create_db(): """Creates database""" db.create_all()
def basic_auto_migrate_relational_db(app, bind): """Inspired with http://stackoverflow.com/questions/2103274/""" from sqlalchemy import Table from sqlalchemy import MetaData print('Performing very simple automigration in', bind, 'database...') db.session.commit() db.reflect() db.session.commit() db.create_all(bind=bind) with app.app_context(): engine = db.get_engine(app, bind) tables = db.get_tables_for_bind(bind=bind) metadata = MetaData() metadata.engine = engine ddl = engine.dialect.ddl_compiler(engine.dialect, None) for table in tables: db_table = Table(table.name, metadata, autoload=True, autoload_with=engine) db_columns = get_column_names(db_table) columns = get_column_names(table) new_columns = columns - db_columns unused_columns = db_columns - columns existing_columns = columns.intersection(db_columns) for column_name in new_columns: column = getattr(table.c, column_name) if column.constraints: print('Column %s skipped due to existing constraints.' % column_name) continue print('Creating column: %s' % column_name) definition = ddl.get_column_specification(column) add_column(engine, table.name, definition) if engine.dialect.name == 'mysql': sql = 'SHOW CREATE TABLE `%s`' % table.name table_definition = engine.execute(sql) columns_definitions = {} to_replace = { 'TINYINT(1)': 'BOOL', # synonymous for MySQL and SQLAlchemy 'INT(11)': 'INTEGER', 'DOUBLE': 'FLOAT(53)', ' DEFAULT NULL': '' } for definition in table_definition.first()[1].split('\n'): match = re.match( '\s*`(?P<name>.*?)` (?P<definition>[^,]*),?', definition) if match: name = match.group('name') definition_string = match.group('definition').upper() for mysql_explicit_definition, implicit_sqlalchemy in to_replace.items( ): definition_string = definition_string.replace( mysql_explicit_definition, implicit_sqlalchemy) columns_definitions[ name] = name + ' ' + definition_string columns_to_update = [] for column_name in existing_columns: column = getattr(table.c, column_name) old_definition = columns_definitions[column_name] new_definition = ddl.get_column_specification(column) if old_definition != new_definition: columns_to_update.append( [column_name, old_definition, new_definition]) if columns_to_update: print( '\nFollowing columns in `%s` table differ in definitions ' 'from those in specified in models:' % table.name) for column, old_definition, new_definition in columns_to_update: answer = get_answer( 'Column: `%s`\n' 'Old definition: %s\n' 'New definition: %s\n' 'Update column definition?' % (column, old_definition, new_definition)) if answer == 'y': update_column(engine, table.name, new_definition) print('Updated %s column definition' % column) else: print('Skipped %s column' % column) if unused_columns: print('\nFollowing columns in `%s` table are no longer used ' 'and can be safely removed:' % table.name) for column in unused_columns: answer = get_answer('Column: `%s` - remove?' % column) if answer == 'y': drop_column(engine, table.name, column) print('Removed column %s.' % column) else: print('Keeping column %s.' % column) print('Automigration of', bind, 'database completed.')
def db(app): _db.create_all() yield _db _db.drop_all()
def db(request, app): app.config['SQLALCHEMY_DATABASE_URI'] = TEST_DB test_db.init_app(app) test_db.create_all() yield test_db
def init_db(): ''' Initialize the database ''' with app.test_request_context(): db.create_all()
def _preload(): db.create_all() roles = _role_preload() _user_preload(roles)
def create_tables(): db.create_all()
def init_db(): db.init_app(app) db.app = app db.create_all()
""" for _, name, _ in pkgutil.iter_modules(package_path): import_string = '%s.%s' % (package_name, name) if package_name else name m = pkgutil.importlib.import_module(import_string) for item in dir(m): item = getattr(m, item) if isinstance(item, Blueprint): app.register_blueprint(item) register_blueprints("modules", ["modules"]) @app.route("/") def home(): return jsonify({"test": "home"}) if __name__ == "__main__": import sys if len(sys.argv) == 2 and sys.argv[1] == "create": from database import db from models import * db.create_all() else: manager.run() # app.run(debug=True, port=5000, host='0.0.0.0')
def setup_database(app): with app.app_context(): db.create_all()
def setUp(self): self.logged_user = None self.add_csrf_to_default_post() db.create_all()
def setUp(self): db.create_all() db.session.commit()
def create_tables(): db.create_all( ) #when this runs, it'll create data.db and all the tables in the file unless they exist already
from flask import Flask from flask import render_template from flask import request # Flask is the web app that we will customize from flask import redirect, url_for from database import db from models import Note as Note from models import User as User app = Flask(__name__) # create an app app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///flask_note_app.db' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # Bind SQLAlchemy db object to this Flask app db.init_app(app) # Setup models with app.app_context(): db.create_all() # run under the app context # @app.route is a decorator. It gives the function "index" special powers. # In this case it makes it so anyone going to "your-url/" makes this function # get called. What it returns is what is shown as the web page @app.route('/') @app.route('/index') def index(): a_user = db.session.query(User).filter_by(email='*****@*****.**').one() return render_template('index.html', user=a_user) @app.route('/notes') def get_notes():
def create_tables(): db.create_all() from models.user import UserModel user = UserModel('flask', 'flask') user.save_to_db()
# 2. SETTING UP FLASK DATABASE from database import db, Puppy db.create_all() # Transforms the Model class to the database table sam = Puppy('Sam', 3) # Creating database entries frank = Puppy('Frankie', 1) # This will report back "None", since we haven't added these into our database yet print(sam.id) print(frank.id) db.session.add_all([sam, frank]) db.session.commit() # commit the changes in the database print(frank.id) print(sam.id)