def setup_database(): """ Initialize the database file, maybe drop all tables. """ # ------------------------------------------------------------------------- # Set up the database. # ------------------------------------------------------------------------- # !!AI uncomment me when needed. #models.drop_all() models.initialize()
def setUp(self): """Runs before every test, creating the User table and one entry if either are not present""" # Opens connection, creates table, and closes connection models.initialize() # Creates one mock entry in the database models.User.create_user(username='******', email='*****@*****.**', password='******') # Retrieves mock entry from database and stores it locally self.user = models.User.get(email='*****@*****.**')
def init(): db_session = DBSession() system_version = SystemVersion.get(db_session) # Handles database schema migration for version in range(system_version.schema_version, CURRENT_SCHEMA_VERSION+1): handler_class = get_schema_migrate_class(version) if handler_class is not None: try: handler_class(version).execute() except: print(traceback.format_exc()) # Initialize certain tables initialize()
def __init__(self, db_name, encrypter=None, store_text=True): self.session_maker = models.initialize(db_name) self.session = None models.ENCRYPTER = encrypter self.store_text = store_text self.nrmoves = 0 self.latestx = 0 self.latesty = 0 self.lastspecial = None self.specials_in_row = 0 self.curtext = u"" self.key_presses = [] self.last_key_time = time.time() self.started = NOW() self.cur_class = None self.cur_window = None self.cur_name = None self.cur_process_id = None self.cur_win_id = None self.cur_win_proc = None
def init(): db_session = DBSession() system_version = SystemVersion.get(db_session) # Handles database schema migration starting from the next schema version for version in range(system_version.schema_version + 1, CURRENT_SCHEMA_VERSION + 1): handler_class = get_schema_migrate_class(version) if handler_class is not None: try: handler_class(version).execute() except: print(traceback.format_exc()) apply_dialect_specific_codes() # Initialize certain tables initialize()
def index(): return 'Hey' if __name__ == '__main__': models.initialize() try: models.User.create_user( username='******', email='*****@*****.**', password='******', admin=True ) except ValueError: pass app.run(debug=DEBUG, host=HOST, port=PORT)
def init(): if not is_ldap_supported(): print('LDAP authentication is not supported because it has not been installed.') db_session = DBSession() system_version = SystemVersion.get(db_session) # Handles database schema migration starting from the next schema version for version in range(system_version.schema_version + 1, CURRENT_SCHEMA_VERSION + 1): handler_class = get_schema_migrate_class(version) if handler_class is not None: try: handler_class(version).execute() except: print(traceback.format_exc()) # Initialize certain tables initialize()
def __init__(self, db_name, encrypter=None, store_text=True): self.session_maker = models.initialize(db_name) models.ENCRYPTER = encrypter self.store_text = store_text self.curtext = u"" self.key_presses = [] self.mouse_path = [] self.current_window = Display() self.last_key_time = time.time() self.started = NOW()
def delete_post(postid): post_id = int(postid) post = models.Post.get(models.Post.id == post_id) post.delete_instance() return redirect(url_for('posts')) @app.route('/post/<postid>/edit', methods=['GET', 'POST'] ) # called inside of post.html during second phase of editing logic @login_required def edit_post(postid): post_id = int(postid) # convert str to int post = models.Post.get(models.Post.id == post_id) form = forms.PostForm( ) # forms.py call class PostForm inherit its properties post.title = form.title.data # assign selected post.title tobe overwritten by form.title.data post.content = form.content.data # assign selected post.content tobe overwritten by form.content.data post.save() # http://docs.peewee-orm.com/en/latest/peewee/querying.html flash("Great, Your diary has been edited", "success") return redirect(f"/posts/{post_id}") if 'ON_HEROKU' in os.environ: print('hitting ') models.initialize() if __name__ == '__main__': models.initialize( ) # before our app runs we initialize a connection to the models app.run(debug=DEBUG, port=PORT)
try: email = g.user._get_current_object().email models.Taco.select().where(models.Taco.id == taco_id).get().delete_instance() flash('Deleted Taco!', 'success') except models.DoesNotExist: abort(404) return redirect(url_for('profile', email=email)) @app.errorhandler(404) def not_found(error): return render_template('404.html'), 404 @app.route('/') def index(): tacos = models.Taco.select().limit(100) return render_template('index.html', tacos=tacos) if __name__ == '__main__': models.initialize() try: models.User.create_user( email='*****@*****.**', password='******' ) except ValueError: pass app.run()
from database import PooledMDB as Database import tornado.httpserver import tornado.ioloop import tornado.options import tornado.web from tornado.options import define, options define("port", default=5000, help="port to bind to", type=int) from config import settings, dbconf, bsconf from routes import routes import models class Application(tornado.web.Application): def __init__(self, dbconf, bsconf, handlers=None, **settings): super(Application, self).__init__(handlers, **settings) self.blobstore = None # Blobstore(bsconf.nodes, **bsconf.opts) self.database = Database(stale_timeout=599, **dbconf) if __name__ == "__main__": tornado.options.parse_command_line() app = Application(dbconf, bsconf, routes, **settings) models.initialize(app.database, app.blobstore) server = tornado.httpserver.HTTPServer(app) server.listen(tornado.options.options.port) tornado.ioloop.IOLoop.instance().start()
def students(): models.initialize() students = models.Student.select() return render_template("entries.html", students=students)
@app.before_request # decorator function, that runs before a function def before_request(): """Connect to the database before each request.""" g.db = models.DATABASE g.db.connect() @app.after_request def after_request(response): """Close the database connection after each request.""" g.db.close() return response # test @app.route('/') def index(): return 'Hello, world!' if 'ON_HEROKU' in os.environ: print('\non heroku!') models.initialize() # Run the app when the program starts! if __name__ == '__main__': models.initialize() # invokes the function that creates our tables # in models.py app.run(debug=DEBUG, port=PORT)
def setUp(self): models.initialize() self.app = app.test_client()
def index(): models.initialize() return render_template("index.html",)
#!/usr/bin/env python from database import MDB as Database from config import dbconf, bsconf from models import * import models if __name__ == "__main__": database = Database(**dbconf) blobstore = None # Blobstore(bsconf.nodes, **bsconf.opts) models.initialize(database, blobstore) database.create_tables([ User, Token, Repo, HMap, CSet, Blob, CommitMessage ], safe=True)
flash("El usuario o la contraseña no son correctos", 'error') else: if check_password_hash(usuario.clave, form.clave.data): login_user(usuario) try: next = session['next'] except: response = redirect(url_for('inicio')) else: response = redirect(next) del session['next'] response.set_cookie( 'userdata', json.dumps({'usuario': usuario.persona.nombres})) return response else: flash("El usuario o la contraseña no son correctos", 'error') elif request.args.get('next') is not None: session['next'] = request.args.get('next') return render_template('login.html', form=form) if __name__ == '__main__': m.initialize() app.run(debug=config.DEBUG, host=config.HOST, port=config.PORT)
def index(): models.initialize() return render_template("polling.html")
@login_required def logout(): logout_user() return redirect(url_for("index")) @app.route("/taco", methods=('GET', 'POST')) @login_required def taco(): form = TacoForm() if form.validate_on_submit(): Taco.create( protein=form.protein.data, shell=form.shell.data, cheese=form.cheese.data, extras=form.extras.data, user=current_user._get_current_object() ) return redirect(url_for("index")) return render_template("taco.html", form=form) @app.route("/") def index(): return render_template("index.html", tacos=Taco.select()) if __name__ == "__main__": initialize() app.run(port=8000,debug=True, host="localhost")
def __init__(self): models.initialize() self.task_table = models.Task()
from flask import Flask, jsonify, render_template from config import HOST, PORT, DEBUG from peewee import * import models from resources.todos import todo_api app = Flask(__name__) app.register_blueprint(todo_api, url_prefix="/api/v1/todos") models.DATABASE.init('todo_api.db') models.initialize(models.Todo) @app.errorhandler(404) def not_found(e): message = str(e).split(':')[1] return jsonify(error=message), 404 @app.errorhandler(400) def bad_request(e): message = str(e).split(':')[1] return jsonify(error=message), 400 @app.route('/') def my_todos(): return render_template('index.html')
def events(): models.initialize() events = models.models.Myentry.select() return render_template("Events.html", events = events)
def test_create_todo_defaults(self): models.initialize()
def see_contacts(): models.initialize() contacts = models.Contact.select() return render_template("contacts.html", contacts=contacts)
import tornado.httpserver import tornado.ioloop import tornado.options import tornado.web from tornado.options import define, options define("port", default=5000, help="port to bind to", type=int) from config import settings, dbconf, bsconf from routes import routes import models class Application(tornado.web.Application): def __init__(self, dbconf, bsconf, handlers=None, **settings): super(Application, self).__init__(handlers, **settings) self.blobstore = None # Blobstore(bsconf.nodes, **bsconf.opts) self.database = Database(stale_timeout=599, **dbconf) if __name__ == "__main__": tornado.options.parse_command_line() app = Application(dbconf, bsconf, routes, **settings) models.initialize(app.database, app.blobstore) server = tornado.httpserver.HTTPServer(app) server.listen(tornado.options.options.port) tornado.ioloop.IOLoop.instance().start()
def _initialize_models(): models.initialize()
# deleting course @app.route('/api/v1/course/<int:course_id>', methods=['DELETE']) def delete_course(course_id): course = try_course(course_id) if course.delete_instance(): return jsonify(generate_response(data={})) else: abort(422) # helpers methods def try_course(course_id): try: return Course.get(Course.id == course_id) except Course.DoesNotExist as e: abort(404) def generate_response(status=200, data=None, error=None): return {'status': status, 'data': data, 'error': error} if __name__ == "__main__": # running the model function initialize() app.run(port=PORT, debug=DEBUG)
return None @app.before_request #decorator function that runs before function def before_request(): # this connect to a db before a request g.db = models.DATABASE g.db.connect() @app.after_request def after_request(response): g.db.close() return response CORS(user, origins=['http://localhost:3000'], supports_credentials=True) app.register_blueprint(user, url_prefix='/user') CORS(movie, origins=['http://localhost:3000'], supports_credentials=True) app.register_blueprint(movie, url_prefix='/movie') CORS(movie_pref, origins=['http://localhost:3000'], supports_credentials=True) app.register_blueprint(movie_pref, url_prefix='/movie_pref') CORS(food_pref, origins=['http://localhost:3000'], supports_credentials=True) app.register_blueprint(food_pref, url_prefix='/food_pref') if __name__ == '__main__': models.initialize() #invokes function to create tables in models.py app.run(debug=DEBUG, port=PORT)
def __init__(self, db_name, args): self.args = args self.session_maker = models.initialize(db_name) self.inmouse = False self.check_needs()
try: user = models.User.get(models.User.email == form.email.data) except models.DoesNotExist: flash("Your email or password doesn't match.", "error") else: if check_password_hash(user.password, form.password.data): login_user(user) flash("You've been logged in!", "success") return redirect(url_for('index')) else: flash("Your email or password doesn't match.", "error") return render_template('login.html', form = form) @app.route('/') def index(): return 'Hey' if __name__ == '__main__': models.initialize() try: models.User.create_user( username = '******', email = '*****@*****.**', password = '******', admin=True ) except ValueError: pass app.run(debug=DEBUG, host = HOST, port = PORT)
else: flash('You have unfollowing {}!'.format(to_user.username), 'alert-success') return redirect(url_for('stream', username=to_user.username)) @app.errorhandler(404) # error handeling view function def not_found(error): return render_template('404.html'), 404 if __name__ == '__main__': # launching our falsk application models.initialize() # initializing our models in the database try: models.User.create_user(username='******', email='*****@*****.**', password='******', name='Athoug Alsoughayer', department='CS') # for testing purposes except ValueError: pass app.run(debug=DEBUG)