def create_app(test_config=None): app = Flask(__name__) if not test_config: app.config.from_pyfile("config.py") else: app.config.update(test_config) database = create_engine(app.config["DB_URL"], encoding="utf-8", max_overflow=0) # 데이터베이스와 연결 app.database = database # Flask instance의 attribute로 가리킴 @app.route("/ping", methods=["GET"]) def ping(): return ping return "pong" @app.route("/sign-up", methods=["POST"]) def sign_up(): new_user = request.json new_user_id = insert_user(new_user) new_user = get_user(new_user_id) return jsonify(new_user) @app.route("/tweet", methods=["POST"]) def tweet(): user_tweet = request.json tweet = user_tweet["tweet"] if len(tweet) > 300: return "300자를 초과했습니다", 400 insert_tweet(user_tweet) return "", 200 @app.route("/timeline/<int:user_id>", methods=["GET"]) def timeline(user_id): return jsonify(dict(user_id=user_id, timeline=get_timeline(user_id)))
def create(config): """http://flask.pocoo.org/docs/patterns/appfactories/""" app = Flask(__name__.split('.')[0]) # Load YAML config into app.config if not isinstance(config, dict): with open(os.path.join(app.instance_path, config)) as f: config = yaml.load(f) config.update({k.upper(): v for k, v in config["flask"].items()}) app.config.update(config) del config # Configure logging logging.config.dictConfig(app.config["logging"]) # Initialize database app.database = Database(app) # Load blueprints from .views.submit import submit app.register_blueprint(submit) if False and app.debug: app.logger.warning("Debug mode is on. Do not use this in production.") from .views.debug import debug app.register_blueprint(debug) return app
def create_app(test_config=None): app = Flask(__name__) app.json_encoder = CustomJSONEncoder if test_config is None: app.config.from_pyfile("config.py") else: app.config.update(test_config) database = create_engine(app.config['DB_URL'], encoding='utf-8', max_overflow=0) app.database = database # ping @app.route("/ping", methods=['GET']) def ping(): return "pong" # 회원가입 엔드포인트 @app.route("/sign-up", methods=['POST']) def sign_up(): new_user = request.json new_user_id = insert_user(new_user) new_user = get_user(new_user_id) return jsonify(new_user) @app.route('/tweet', methods=['POST']) def tweet(): user_tweet = request.json tweet = user_tweet['tweet'] if len(tweet) > 300: return '300자를 초과했습니다', 400 insert_tweet(user_tweet) return '', 200 @app.route('/timeline/<int:user_id>', methods=['GET']) def timeline(user_id): return jsonify({'user_id': user_id, 'timeline': get_timeline(user_id)}) @app.route('/follow', methods=['POST']) def follow(): payload = request.json insert_follow(payload) return '', 200 @app.route('/unfollow', methods=['POST']) def unfollow(): payload = request.json insert_unfollow(payload) return '', 200 return app
def create_app(): app = Flask(__name__) app.config.from_pyfile('config.py') database = create_engine(app.config['DB_URL'], encoding='utf-8') app.database = database @app.route('/sign-up', methods=['POST']) def sign_up(): user = request.json user_id = app.database.execute( text(""" INSERT INTO user ( email, password ) VALUES ( :email, :password ) """), user).lastrowid return "", 200 from .views import main_views app.register_blueprint(main_views.bp) return app
def create_app(test_config=None): app = Flask(__name__) CORS(app) app.json_encoder = CustomJSONEncoder if test_config is None: app.config.from_pyfile("config.py") else: app.config.update(test_config) database = create_engine(app.config["DB_URL"], encoding="utf-8", max_overflow=0) app.database = database @app.route("/find-single/<string:index>", methods=["GET"]) def findSingle(index): # result = bf.findBetween("창",1, 2, 5) # return result[0]['text'] result = bf.findByIndex(index) return makeTr(result[0]) @app.route("/remember", methods=["GET"]) def remember(): num = random.randrange(0, len(list)) dict = list[num] dict['index'] = num return json.dumps(dict) @app.route("/remember/answer", methods=["POST"]) def rememberAnswer(): num = {"num": random.randint(1, 12)} return json.dumps(num) @app.route("/json/find-single/<string:index>", methods=["GET"]) def jsonFindSingle(index): result = bf.findByIndex(index) return json.dumps(result[0]) @app.route("/json/find-between", methods=["GET"]) def jsonFindBetween(): book = request.args.get('book', default="창", type=str) chapter = request.args.get('chapter', default=1, type=int) verseFrom = request.args.get('verseFrom', default=1, type=int) verseTo = request.args.get('verseTo', default=1, type=int) verses = bf.findBetween(book, chapter, verseFrom, verseTo) return json.dumps(verses) @app.route("/find-between", methods=["GET"]) def findBetween(): book = request.args.get('book', default="창", type=str) chapter = request.args.get('chapter', default=1, type=int) verseFrom = request.args.get('verseFrom', default=1, type=int) verseTo = request.args.get('verseTo', default=1, type=int) verses = bf.findBetween(book, chapter, verseFrom, verseTo) return makeTable(verses) return app
def create_app(cfg='dev'): app = Flask(__name__) CORS(app) config = config_meta.get(cfg) app.config.from_object(config) app.database = connect_to_db(app.config) create_tables(app.database) return app
def create_app(test_config=None, instance_relative_config=True): app = Flask(__name__) # create flask application cors = CORS(app) app.config.from_mapping( #dev environment SECRET_KEY='dev') app.config['CORS_HEADERS'] = 'Content-Type' app.config['MYSQL_HOST'] = 'remotemysql.com' app.config['MYSQL_USER'] = '******' app.config['MYSQL_PASSWORD'] = '******' app.config['MYSQL_DB'] = 'fhiZCqtsqe' app.config['MYSQL_CURSORCLASS'] = 'DictCursor' app.database = MySQL( app ) #we assign the mysql object to app.database here, we cannot create the object after any #request made, this will throw an error. We need to create in the beginning only try: #when instance_relative_config = True (look at the parameter) os.makedirs( app.instance_path ) #app.instance_path -> all the config details are stored. I dont know what config details except OSError: #if we are using a local db, it would be stored here. pass from . import db #We initialize app related stuff here -> go to db file for more details db.init_app( app ) # we are basically calling the init_app() function from here by importing it from . import auth # Here, auth contains some functions which can be classified as a view of specific type app.register_blueprint( auth.bp ) # NOT MVC VIEW. Here, view is basically a set of related events that can happen #like, authentication can be one view and you can have other such views # here, view name is bp #We are telling flask that, the view bp belongs to this particular object 'app', and when we # do this, by default , all the functions that route using 'bp' get registered to this # particular object from . import view # same as before. This is another view app.register_blueprint(view.vw) from . import user app.register_blueprint(user.ur) from . import genres app.register_blueprint(genres.genre) from . import friends app.register_blueprint(friends.friend) from . import book app.register_blueprint(book.bk) return app
def create_app(test_config=None): app = Flask(__name__) app.json_encoder = CustomJSONEncoder if test_config is None: app.config.from_pyfile("config.py") else: app.config.update(test_config) database = create_engine(app.config["DB_URL"], encoding="utf-8", max_overflow=0) app.database = database @app.route("/ping", methods=["GET"]) def ping(): return "pong" @app.route("/sign-up", methods=["POST"]) def sign_up(): new_user = request.json new_user_id = insert_user(new_user) new_user = get_user(new_user_id) return jsonify(new_user) @app.route("/tweet", methods=["POST"]) def tweet(): user_tweet = request.json tweet = user_tweet["tweet"] if len(tweet) > 300: return "300자를 초과 했습니다", 400 insert_tweet(user_tweet) return "", 200 @app.route("/follow", methods=["POST"]) def follow(): payload = request.json insert_follow(payload) return "", 200 @app.route("/unfollow", methods=["POST"]) def unfollow(): payload = request.json insert_unfollow(payload) return "", 200 @app.route("/timeline/<int:user_id>", methods=["GET"]) def timeline(user_id): return jsonify({"user_id": user_id, "timeline": get_timeline(user_id)}) return app
def create_app(test_config=None): print("FLASK IS LOADING...") app = Flask(__name__) app.json_encoder = CustomJSONEncoder if test_config is None: app.config.from_pyfile("config.py") else: app.config.update(test_config) database = create_engine( 'mysql+mysqlconnector://root:password@localhost:3306/miniter?charset=utf8', encoding='utf-8', max_overflow=0) app.database = database @app.route("/sign-up", methods=['POST']) def sign_up(): new_user = request.json new_user_id = app.database.execute( text(""" INSERT INTO users( name, email, profile, hashed_password ) VALUES ( :name, :email, :profile, :password ) """), new_user).lastrowid row = app.database.execute( text(""" SELECT id, name, email, profile FROM uesrs WHERE id = :userid """), { 'user_id': new_user_id }).fetchone() created_user = { 'id': row['id'], 'name': row['name'], 'email': row['email'], 'profile': row['profile'], } if row else None return jsonify(created_user) return app
def create_app(test_config=None): # 1) app = Flask(__name__) app.json_encoder = CustomJSONEncoder if test_config is None: # 2) app.config.from_pyfile("config.py") else: app.config.update(test_config) database = create_engine(app.config['DB_URL'], encoding='utf-8', max_overflow=0) # 3) app.database = database # 4) @app.route("/sign-up", methods=['POST']) def sign_up(): new_user = request.json sql = "INSERT INTO " + "users(name,email,profile,hashed_password)" + "VALUES (:name,:email,:profile,:password)" new_user_id = app.database.execute(text(sql), new_user).lastrowid # 2) return jsonify(new_user_id) @app.route('/tweet', methods=['POST']) def tweet(): user_tweet = request.json tweet = user_tweet['tweet'] sql = "INSERT INTO" + "tweets(user_id, tweet)" + " VALUES (:id,:tweet)" if len(tweet) > 300: return '300자를 초과했습니다', 400 app.database.execute(text(sql), user_tweet) # 2) return '', 200 @app.route('/timeline/<int:user_id>', methods=['GET']) def timeline(user_id): sql = "SELECT t.user_id, t.tweet " + "FROM tweets t" +\ " LEFT JOIN users_follow_list ufl ON ufl.user_id = :user_id"+ \ "WHERE t.user_id = :user_id" + " OR t.user_id = ufl.follow_user.id" rows = app.database.execute(text(sql), {'user_id': user_id}).fetchall() timeline = [ { # 2) 'user_id': row['user_id'], 'tweet': row['tweet'] } for row in rows ] return jsonify({ # 3) 'user_id': user_id, 'timeline': timeline }) return app
def create_app(test_config=None): app = Flask(__name__) if test_config is None: app.config.from_pyfile("config.py") else: app.config.update(test_config) database = create_engine(app.config['DB_URL'], encoding='utf-8', max_overflow=0) app.database = database @app.route("/sign-up", methods=['POST']) def sign_up(): new_user = request.json new_user_id = app.database.execute( text(""" # 1) INSERT INTO users( name, email, profile, hashed_password ) VALUES ( :name, :email, :profile, :password ) """), new_user).lastrowid # 2) row = current_app.database.execute( text(""" SELECT id, name, email, profile FROM users WHERE id =:user_id """), { 'user_id': new_user_id }).fetchone() # 3) created_user = { # 4) 'id': row['id'], 'name': row['name'], 'email': row['email'], 'profile': row['profile'] } if row else None return jsonify(created_user) return app
def create_app(test_config=None): app = Flask(__name__) if test_config is None: app.config.from_pyfile("dbconfig.py") else: app.config.update(test_config) database = create_engine(app.config["DB_URL"], encoding="UTF-8", max_overflow=0) app.database = database @app.route("/sign-up", methods=["POST"]) def sign_up(): print(request.json) new_user = request.json new_user_id = insert_user(new_user) new_user = get_user(new_user_id) return jsonify(new_user) @app.route("/tweet", methods=["POST"]) def tweet(): user_tweet = request.json tweet = user_tweet["tweet"] if len(tweet) > 300: return "300자를 초과하였습니다.", 400 insert_tweet(user_tweet) return "트윗이 등록되었습니다.", 200 @app.route("/follow", methods=["POST"]) def follow(): payload = request.json insert_follow(payload) return "팔로워가 등록되었습니다.", 200 @app.route("/unfollow", methods=["POST"]) def unfollow(): payload = request.json remove_follow(payload) return "팔로워가 삭제되었습니다.", 200 @app.route("/timeline/<int:user_id>", methods=["GET"]) def timeline(user_id): return jsonify({"user_id": user_id, "timeline": get_timeline(user_id)}) return app
def create_app(test_config = None): app = Flask(__name__) if test_config is None: app.config.from_pyfile("config.py") else: app.config.from_pyfile(test_config) database = create_engine(app.config['DB_URL'], encoding='utf-8', max_overflow=0) app.database = database return app
def create_app(test_config=None): # 1) app = Flask(__name__) app.json_encoder = CustomJSONEncoder if test_config is None: # 2) app.config.from_pyfile("config.py") else: app.config.update(test_config) database = create_engine(app.config['DB_URL'], encoding='utf-8', max_overflow=0) # 3) app.database = database # 4) return app
def create_app(test_config=None): app = Flask(__name__) api = Api(app) app.config['ERROR_404_HELP'] = False if test_config is None: app.config.from_pyfile("./db/config.py") else: app.config.update(test_config) database = create_engine(app.config['DB_URL'], encoding='utf-8', max_overflow=0) app.database = database api.add_namespace(Test, '/test') api.add_namespace(User, '/user') return app
def create_app(config_name): """ Usage: Factory function used to setup the application instance :return: application instance """ app = Flask(__name__) app.database = database app.current_user = current_user app.config.from_object(config[config_name]) login_manager.init_app(app) @login_manager.user_loader def load_user(username): for user in app.database: if user.username == username: return user from . import views app.register_blueprint(views.views) return app
def create_app(config_name): """ Usage: Factory function used to setup the application instance :return: application instance """ app = Flask(__name__, template_folder='../api_docs') app.database = DATABASE app.config.from_object(config[config_name]) app.config['BUNDLE_ERRORS'] = True @app.route('/') def api_docs(): """ Route to the api docs""" from flask import render_template return render_template('api.html') # Register Blueprint here app.register_blueprint(v1, url_prefix="/api/v1") return app
def create_app(config_name): """ Usage: Factory function used to setup the application instance :return: application instance """ app = Flask(__name__) app.database = database app.config.from_object(config[config_name]) app.config['JWT_SECRET_KEY'] = 'super-secret' app.config['JWT_BLACKLIST_ENABLED'] = True app.config['JWT_BLACKLIST_TOKEN_CHECKS'] = ['access', 'refresh'] app.jwt = JWTManager(app) app.blacklist = set() @app.jwt.token_in_blacklist_loader def check_if_token_in_blacklist(decrypted_token): jti = decrypted_token['jti'] return jti in app.blacklist app.register_blueprint(v1, url_prefix="/api/v1") return app
def create_app(): application = Flask(__name__) if os.environ.get('APP_ENV') == 'prod': print('prod') application.config.from_object('config_prod') elif os.environ.get('APP_ENV') == 'dev': print('dev') application.config.from_object('config_dev') else: print('local') application.config.from_object('config_local') print("SECRET_KEY : ", application.config.get("SECRET_KEY")) application.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # application.secret_key = 'samplewithflask' CORS(application, supports_credentials=True) configure_extensions(application) # TODO DB Pool 설정 database = create_engine(application.config['DB_URL'], encoding='utf-8') application.database = database CORS(application, supports_credentials=True) @application.route('/sign-up', methods=['POST']) def sign_up(): user = request.json user_id = app.database.execute(text(""" INSERT INTO user( email, password ) VALUE ( :email, :password ) """), user).lastrowid return "OK", 200 return application
def create_app(test_config=None): app = Flask(__name__) app.run(host='0.0.0.0', port=8080) app.json_encoder = CustomJSONEncoder if test_config is None: app.config.from_pyfile("config.py") else: app.config.update(test_config) database = create_engine(app.config['DB_URL'], encoding='utf-8', max_overflow=0) app.database = database @app.route("/ping", methods=['GET']) def ping(): return "pong" @app.route("/update", methods=['POST']) def update(): req = requests.get( 'http://openapi.seoul.go.kr:8088/414a5975666b796a3132324142416376/json/culturalEventInfo/1/1' ) originList = req.json info = insert_origin(originList) cinfo = get_origin(info) return jsonify(cinfo) @app.route("/preference", methods=['POST']) def preference(): new_prefernce = request.json new_prefernce_id = insert_prefernce(new_prefernce) new_prefernce = get_prefernce(new_prefernce_id) return jsonify(new_prefernce) return app
def create_app(): #flask run 했을 경우 자동 실행 app = Flask(__name__) #Flask class 객체화 -> 이 app 변수가 Flask 웹 API애플리케이션이다 #app 변수에 API설정과 엔드포인트들을 추가하면 APi 완성 database = create_engine(db_url, encoding='utf-8', max_overflow=0) app.database = database @app.route("/score", methods=['GET']) #Flask의 route 데코레이터 사용해서 엔드포인트 등록. score함수를 엔드포인트 함수로 등록 #고유주소=score,method=GET def score(): #user table을 보여주는 함수 result = app.database.execute(text("""SELECT * FROM user;""")) row = result.fetchone() return jsonify(row._mapping['id']) #@app.route("/ping",methods=["GET"]) #def ping(): #return "pong" return app
def application(database_uri, exclude_tables=[], include_models=[], read_only=True, schema=None): """Return an application instance connected to the database described in *database_uri*. :param str database_uri: The URI connection string for the database :param list exclude_tables: A list of tables to exclude from the API service :param list include_models: A list of user-defined models to include in the API service :param bool read_only: Only allow HTTP GET commands for all endpoints :param str schema: Use the specified named schema instead of the default """ app = Flask('flask_sandman') app.config['SQLALCHEMY_DATABASE_URI'] = database_uri app.config['SANDMAN2_READ_ONLY'] = read_only app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.classes = [] # Database from .database import DATABASE as db db.init_app(app) app.database = db # Administration from .admin import administration # admin = Admin(app, base_template = 'layout.html', template_mode = 'bootstrap3') admin = administration(app) # Sandman sandman(app, database=db, include_models=include_models or [], exclude_tables=exclude_tables or [], read_only=read_only, admin=admin, schema=schema) return app
def create_app(test_config=None): app = Flask(__name__) app.json_encoder = CustomJSONEncoder if test_config is None: app.config.from_pyfile("config.py") else: app.config.update(test_config) #생성한 Engin 객체를 Flask 객체에 저장 database = create_engine(app.config['DB_URL'], encoding='utf-8') app.database = database # @app.route("/sign-up",methods=['post']) # def sign_up(): # new_user = request.json # new_user_id = app.database.execute(text # (""" # Insert into users(name,email,profile,hashed_password) values (:name, :email, :profile, :password) # """),new_user).lastrowid # row = current_app.database.execute(text # (""" # select id, name,email,profile from users where id = :user_id # """),{'user_id':new_user_id}).fetchone() # created_user = { # 'id':row['id'], # 'name':row['name'], # 'email':row['email'], # 'profile':row['profile'] # }if row else None # return jsonify(created_user) #Flask 객체를 리턴.create_app 이라는 함수는 Flask가 자동 인지하여 Flask 객체를 찾아서 실행 return app
def create_app(test_config=None): app = Flask(__name__) CORS(app) app.json_encoder = CustomJSONEncoder if test_config is None: app.config.from_pyfile("config.py") else: app.config.update(test_config) database = create_engine(app.config['DB_URL'], encoding='utf-8', max_overflow=0) app.database = database @app.route("/ping", methods=['GET']) def ping(): return "pong" @app.route("/sign-up", methods=['POST']) def sign_up(): new_user = request.json new_user['password'] = bcrypt.hashpw( new_user['password'].encode('UTF-8'), bcrypt.gensalt()) new_user_id = insert_user(new_user) new_user = get_user(new_user_id) return jsonify(new_user) @app.route('/login', methods=['POST']) def login(): credential = request.json email = credential['email'] password = credential['password'] user_credential = get_user_id_and_password(email) if user_credential and bcrypt.checkpw( password.encode('UTF-8'), user_credential['hashed_password'].encode('UTF-8')): user_id = user_credential['id'] payload = { 'user_id': user_id, 'exp': datetime.utcnow() + timedelta(seconds=60 * 60 * 24) } token = jwt.encode(payload, app.config['JWT_SECRET_KEY'], 'HS256') return jsonify({ 'user_id': user_id, 'access_token': token.decode('UTF-8') }) else: return '', 401 @app.route('/tweet', methods=['POST']) @login_required def tweet(): user_tweet = request.json user_tweet['id'] = g.user_id tweet = user_tweet['tweet'] if len(tweet) > 300: return '300자를 초과했습니다', 400 insert_tweet(user_tweet) return '', 200 @app.route('/follow', methods=['POST']) @login_required def follow(): payload = request.json payload['id'] = g.user_id insert_follow(payload) return '', 200 @app.route('/unfollow', methods=['POST']) @login_required def unfollow(): payload = request.json payload['id'] = g.user_id insert_unfollow(payload) return '', 200 @app.route('/timeline/<int:user_id>', methods=['GET']) def timeline(user_id): return jsonify({'user_id': user_id, 'timeline': get_timeline(user_id)}) @app.route('/timeline', methods=['GET']) @login_required def user_timeline(): user_id = g.user_id return jsonify({'user_id': user_id, 'timeline': get_timeline(user_id)}) return app
def create_app(test_config=None): app = Flask(__name__) CORS(app) if not test_config: app.config.from_pyfile("config.py") else: app.config.update(test_config) database = create_engine(app.config["DB_URL"], encoding="utf-8", max_overflow=0) # 데이터베이스와 연결 app.database = database # Flask instance의 attribute로 가리킴 app.config["JWT_SECRET_KEY"] = "boseop" @app.route("/ping", methods=["GET"]) def ping(): return "pong" @app.route("/sign-up", methods=["POST"]) def sign_up(): new_user = request.json new_user["password"] = bcrypt.hashpw(password=new_user["password"].encode("utf-8"), salt=bcrypt.gensalt()) new_user_id = insert_user(new_user) new_user = get_user(new_user_id) return jsonify(new_user) @app.route("/login", methods=["POST"]) def login(): credential = request.json email = credential["email"] password = credential["password"] user_credential = get_user_id_and_password(email) if user_credential and bcrypt.checkpw(password=password.encode("utf-8"), hashed_password=user_credential["hashed_password"].encode("utf-8")): user_id = user_credential["id"] payload = { "user_id": user_id, "exp": datetime.utcnow() + timedelta(seconds = 60 * 60 * 24) } token = jwt.encode(payload=payload, key=app.config["JWT_SECRET_KEY"], algorithm="HS256") return jsonify({ "access_token": token.decode("utf-8") }) else: return "", 401 @app.route("/tweet", methods=["POST"]) @login_required def tweet(): user_tweet = request.json user_tweet['id'] = g.user_id tweet = user_tweet["tweet"] if len(tweet) > 300: return "300자를 초과했습니다", 400 insert_tweet(user_tweet) return "", 200 @app.route("/timeline/<int:user_id>", methods=["GET"]) def timeline(user_id): return jsonify(dict(user_id=user_id, timeline=get_timeline(user_id))) @app.route("/timeline", methods=["GET"]) @login_required def user_timeline(): user_id = g.user_id return jsonify({ "user_id": user_id, "timeline": get_timeline(user_id) }) @app.route("/follow", methods=["POST"]) @login_required def follow(): payload = request.json payload['id'] = g.user_id insert_follow(payload) return "", 200 @app.route("/unfollow", methods=["POST"]) @login_required def unfollow(): payload = request.json payload['id'] = g.user_id insert_unfollow(payload) return "", 200 return app # Flask instance를 return
from flask import Flask, render_template, redirect, url_for, request, session, flash, g from functools import wraps import sqlite3 app = Flask(__name__) # configuration variable app.secret_key = 'my password' app.database = "sample.db" # login required decorator def login_required(f): @wraps(f) def wrap(*args, **kwargs): if 'logged_in' in session: return f(*args, **kwargs) else: flash('You need to login first.') return redirect(url_for('login')) return wrap # set up first route with a decorator @app.route('/') @login_required def home(): #return "Hello world" # g is specific to flask to store a temporary task g.db = connect_db() # this creates the connection object cur = g.db.execute('select * from posts')
from flask import Flask, render_template, g #Import SQLlite for database import sqlite3 app = Flask(__name__) #Setup Database app.database = "M2MWebsite/sample.db" @app.route('/') def index(): return render_template('index.html') @app.route('/team/') def team(): return render_template('team.html') @app.route('/prototype/') def prototype(): return render_template('prototype.html') @app.route('/users/') def users(): #Create temporary connection object g.db = connect_db() #query the database cur = g.db.execute('select * from users') #Cast data to dictionary users = [dict(id=row[0],cardID=row[1],name=row[2],credit=row[3],bottles=row[4]) for row in cur.fetchall()] #Close database connection g.db.close()
from flask import Flask, render_template, url_for, g import sqlite3 app = Flask(__name__) app.database = "familjen.db" def connect_db(): return sqlite3.connect(app.database) @app.route('/') def home(): return render_template('home.html') @app.route('/members') def members(): g.db = connect_db() cur = g.db.execute('select * from members') members = [dict(imageref=row[0], name=row[1], about=row[2], joined=row[3]) for row in cur.fetchall()] g.db.close() return render_template('members.html', members = members) @app.route('/info') def info(): return render_template('info.html') @app.route('/activities') def activities(): g.db = connect_db() cur = g.db.execute('select * from parties')
from flask import Flask, render_template, redirect, url_for, request, session, flash, g from functools import wraps import sqlite3 app = Flask(__name__) app.secret_key = "my precious" app.database = "flask.db" def login_required(test): @wraps(test) def wrap(*args, **kwargs): if 'logged_in' in session: return test(*args, **kwargs) else: flash('You need to login first.') return redirect(url_for('login')) return wrap @app.route('/') @login_required def home(): g.db = connect_db() query = g.db.execute('SELECT * FROM posts') posts = [dict(title=row[0], description=row[1]) for row in query.fetchall()] g.db.close() return render_template('index.html',posts=posts) @app.route('/welcome')
from mapping_model import Property, Image from sqlalchemy.orm import scoped_session, sessionmaker, Query from sqlalchemy.orm import relationship, backref from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import join app = Flask(__name__) #Next was the original database #app.database = "realstate.db" #Next is the database created with flask admin app.database = "propertyRS.db" app.secret_key = "xcFtjs3Ji896Ghm" #Next lines are for SQL Alchemy use engine = create_engine("sqlite:////tmp/propertyRS.db") Base = declarative_base() Base.metadata.reflect(engine) @app.route('/', methods=['GET', 'POST']) def home(): if request.method == 'POST': if request.form['state'] != "" : stateValue = request.form['state']
#!/usr/bin/env python # -*- coding: utf-8 -*- from flask import Flask, render_template, redirect, url_for, request, session, flash, g from functools import wraps import sqlite3 app = Flask(__name__) app.secret_key = 'a secret key' app.database = 'blog.db' def login_required(f): @wraps(f) def wrap(*args, **kwargs): if 'logged_in' in session: return f(*args, **kwargs) else: flash('Enter username and password.') return redirect(url_for('login')) return wrap @app.route('/') @login_required def home(): g.db = connect_db() cur = g.db.execute('select * from posts') posts = [dict(title=row[0], description=row[1]) for row in cur.fetchall()] g.db.close() return render_template('index.html', posts=posts)
from flask import Flask, request, render_template, g import sqlite3 as sl import os from twilio.rest import TwilioRestClient app = Flask(__name__) sec_k = os.urandom(24) app.secret_key = sec_k app.database = "reg.db" @app.route('/') def index(): return render_template('index.html') @app.route('/subscribe') def subscribe(): return render_template('subscribe.html') @app.route('/request_handler', methods=['GET', 'POST']) def request_handler(): name = request.form['yourname'] email = request.form['youremail'] num = request.form['yournum'] g.db = connect_db() params = (str(name), str(email), str(num)) curr = g.db.cursor() curr.execute("INSERT INTO registrations VALUES (?, ?, ?)", params) cur = g.db.execute('SELECT * FROM registrations') regs = [dict(name=row[0], email=row[1], phone=row[2]) for row in cur.fetchall()]
def create_app(test_config=None): app = Flask(__name__) app.debug = True if test_config is None: app.config.from_pyfile("config.py") else: print(f"test config == {test_config}") app.config.update(test_config) database = create_engine(app.config['DB_URL'], encoding='utf-8', max_overflow=0) app.database = database CORS(app) @app.route('/ping', methods=['GET']) def ping(): return jsonify('{"name" : "pong"}') @app.route('/users', methods=['GET']) @login_required @vip_required def all_users(): rows = database.execute( text(""" SELECT u.id, u.name, u.email, accnt.account_type FROM users as u JOIN accounts accnt ON u.account_id = accnt.id """)).fetchall() if rows is None: return '', 404 return jsonify([{ 'id': row['id'], 'name': row['name'], 'email': row['email'], 'account_type': row['account_type'] } for row in rows]) @app.route('/user/<int:id>', methods=['GET']) ## /user/1 def get_user(id): sql = text(""" SELECT u.id, u.name, u.email, accnt.account_type FROM users as u JOIN accounts accnt ON u.account_id = accnt.id WHERE u.id = :id """) parameters = {'id': id} row = database.execute(sql, parameters).fetchone() return jsonify({ 'id': row['id'], 'name': row['name'], 'email': row['email'], 'account_type': row['account_type'] }) if row else ('', 404) @app.route('/login', methods=['POST']) def login(): credential = request.json email = credential['email'] password = credential['password'] row = database.execute( text(""" SELECT id, hashed_password FROM users WHERE email = :email """), { 'email': email }).fetchone() if row and bcrypt.checkpw(password.encode('UTF-8'), row['hashed_password'].encode('UTF-8')): user_id = row['id'] payload = { 'user_id': user_id, 'exp': datetime.utcnow() + timedelta(seconds=app.config['JWT_EXP_DELTA_SECONDS']) } token = jwt.encode(payload, app.config['JWT_SECRET_KEY'], 'HS256') return jsonify({'access_token': token.decode('UTF-8')}) else: return '', 401 @app.route('/user', methods=['POST']) def create_user(): new_user = request.json new_user['password'] = bcrypt.hashpw( new_user['password'].encode('UTF-8'), bcrypt.gensalt()) print(f"new user ==> {new_user}") rowcount = database.execute( text(""" INSERT INTO users ( name, email, hashed_password, account_id ) SELECT :name, :email, :password, accnt.id FROM accounts as accnt WHERE accnt.account_type = :account_type """), new_user).rowcount print(f"row count == {rowcount}") return ('', 200) if rowcount == 1 else ('', 500) return app
from flask import Flask, render_template, redirect, url_for, request, session, flash, g, Blueprint, abort from jinja2 import TemplateNotFound from flask.json import jsonify from functools import wraps from flask.ext.sqlalchemy import SQLAlchemy import sqlite3 from views.header import header app = Flask(__name__) app.register_blueprint(header.header) app.secret_key = "my precious" app.database = 'testjwz.db' app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///posts.db' #app.config.from_object(os.environ['APP_SETTINGS']) from models import * db = SQLAlchemy(app) def login_required(f): @wraps(f) def wrap(*args, **kwargs): if 'logged_in' in session: return f(*args, **kwargs) else: flash('You need to login first.') return redirect(url_for('login')) return wrap @app.route('/', methods=['GET', 'POST'])
from flask import Flask, g, session, render_template, jsonify, request, redirect, url_for import databaseservice from users import Users, confirmed_password_valid from gamebuilder import GameBuilder from gameengine import GameEngine from gameconfigurations import save_internet_game app = Flask(__name__) app.config.from_object(__name__) app.secret_key = \ '\xd1\xd1\xb9H\xb6\x0e\x0f\xc3*\xb7\xef\xe7\x02GZ\xd1\xeb\xe4\xcd\xa1\x86c2k' app.database = 'adventure_game.db' def connect_database(): """ Connect to app.database and return the connection object. """ return databaseservice.connect_database(app.database) def initialize_database(): """ Initialize the database. """ with app.open_resource('schema.sql') as schema: databaseservice.initialize_database(app.database, schema) @app.before_request def before_request(): """ open dictionary/db connection""" database_connection = connect_database() database_cursor = database_connection.cursor() g.database_service = databaseservice.DatabaseService( \ database_connection, database_cursor)
str = unicode psycopg2.extensions.register_type(psycopg2.extensions.UNICODE) psycopg2.extensions.register_type(psycopg2.extensions.UNICODEARRAY) app = Flask(__name__) app.config.from_object(os.environ['SDV_APP_SETTINGS'].strip('"')) recaptcha = ReCaptcha(app=app) app.secret_key = app.config['SECRET_KEY'] app.jinja_env.trim_blocks = True app.jinja_env.lstrip_blocks = True app.wsgi_app = ProxyFix(app.wsgi_app) if app.config['USE_SQLITE'] == True: app.database = app.config['DB_SQLITE'] app.sqlesc = '?' def connect_db(): return sqlite3.connect(app.database) else: app.database = 'dbname='+app.config['DB_NAME']+' user='******'DB_USER']+' password='******'DB_PASSWORD'] app.sqlesc = '%s' def connect_db(): return psycopg2.connect(app.database) def md5(md5file): h = hashlib.md5() if type(md5file) == io.BytesIO: h.update(md5file.getvalue()) else: for chunk in iter(lambda: md5file.read(4096), b""):
#!/usr/bin/env python # -*- Coding: Utf-8 -*- """ IS211 Assignment 13: Flask web dev part II """ import sqlite3 from flask import Flask, render_template, request, redirect, url_for, g app = Flask(__name__) app.database = 'hw13.db' @app.route('/') def start(): """ First page """ return redirect('/login') @app.route('/login', methods=['GET', 'POST']) def login(): """ Login form processing On success: go to /dashboard On fail: Go to /login with error """
def init(uri=None, db="trackeame"): app = Flask(__name__) app.config["MONGO_URI"] = os.environ.get("MONGOLAB_URI", uri) mongo = MongoClient(app.config["MONGO_URI"]) app.mongo = mongo app.database = mongo[db] @app.route("/") def root_page(): return render_template("index.html") @app.route("/api/users") def get_users(): output = [] users = app.database.users.find() for user in users: output.append({"name": user["name"], "lastname": user["lastname"], "sex": user["sex"]}) return jsonify(output) @app.route("/api/users", methods=['POST']) def add_user(): users = app.database.users name = request.json["name"] lastname = request.json["lastname"] sex = request.json["sex"] id = users.insert({"name": name, "lastname": lastname, "sex": sex}) user = users.find_one({'_id': id}) result = {"name": user["name"], "lastname": user["lastname"], "sex": user["sex"]} return jsonify(result) @app.route("/api/locations", methods=['DELETE']) def clear_locations(): locations = app.database.locations try: locations.delete_many({}) except KeyError: abort(403) result = {"ok": 1} return jsonify(result) @app.route("/api/locations", methods=['POST']) def add_locations(): locations = app.database.locations cuadrantes = {"N": 1, "S":-1, "W":-1, "E": 1} try: posiciones = request.json["posiciones"] posiciones_parseadas = [] ultima_posicion = None for posicion in posiciones.split("\n"): if posicion is not '': nueva_posicion = {} print(posicion) try: tipo, hora_gcm, validez, latitud, polo, longitud, hemisferio, dato1, dato2, fecha, dato3, dato4, dato5 = posicion.split(",") if latitud is not '' and longitud is not '': tiempo_hora = datetime( int(fecha[4:6]), int(fecha[2:4]), int(fecha[0:2]), int(hora_gcm[0:2]), int(hora_gcm[2:4]), int(hora_gcm[4:6])) nueva_posicion["timestamp"] = datetime.timestamp(tiempo_hora) nueva_posicion["latitud"] = (int(latitud[0:2]) + (float(latitud[2:9]) / 60)) * cuadrantes[polo] nueva_posicion["longitud"] = (int(longitud[0:3]) + (float(longitud[3:10]) / 60)) * cuadrantes[hemisferio] nueva_posicion["tiempo_de_parada"] = 0 if tipo == "$PARADA" and ultima_posicion is not None: ultima_posicion["tiempo_de_parada"] = nueva_posicion["timestamp"] - ultima_posicion["timestamp"] posiciones_parseadas.append(nueva_posicion) ultima_posicion = nueva_posicion except Exception: pass if len(posiciones_parseadas) > 0: locations.insert_many(posiciones_parseadas) except KeyError: abort(403) resultado = {"ok": 1} return jsonify(resultado) @app.route("/api/locations") def get_locations(): output = [] locations = app.database.locations.find() for location in locations: output.append({"posicion": { "timestamp": location["timestamp"], "latitud": location["latitud"], "longitud": location["longitud"], "tiempoDeParada": location["tiempo_de_parada"] }}) return jsonify(output) return app
import sqlite3 import string import urllib2 from math import floor from sqlite3 import OperationalError from urlparse import urlparse from BeautifulSoup import BeautifulSoup from flask import Flask, request, render_template, redirect, flash host = 'http://localhost:5000/' app = Flask(__name__) app.database = 'example.db' app.secret_key = 'super secret key' def createTable(): create_table = '''CREATE TABLE IF NOT EXISTS WEB_URL ( id INTEGER PRIMARY KEY AUTOINCREMENT, url string NOT NULL UNIQUE, short string, hits INT, t TIMESTAMP DEFAULT CURRENT_TIMESTAMP, title string ); ''' with sqlite3.connect('example.db') as conn: cursor = conn.cursor() try:
from flask import Flask, flash, redirect, render_template, g, request, url_for import sqlite3 app = Flask(__name__) app.database = "blog_posts.db" app.secret_key = 'super spooky secret key' # A list of words and their corresponding translations for our app # words = {"Bonjour": "hello", "Jambon": "ham", "Fromage": "cheese"} @app.route('/') def index(): return render_template("index.html") @app.route('/france', methods=['GET', 'POST']) def france(): g.db = connect_db() cur = g.db.execute("select * from words where language= ?", ("French",)) words = [dict(word=row[0], translation=row[1]) for row in cur.fetchall()] g.db.close() print(words) points = 0 if request.method == "POST": for word, translation in words.items(): if request.form[word] == translation: points += 1 flash(str(points)) return redirect(url_for('france')) return render_template("france.html", words=words)
import time from flask import Flask, redirect, url_for, request, jsonify from functools import wraps import json app = Flask(__name__) app.database = './messages.db' app.secret_key = 'CucumberSec' from views import * if __name__ == "__main__": app.run(debug=True)
from flask import Flask app = Flask(__name__) app.database = 'WODTracker.db' app.debug = True app.secret_key = 'dev' # Setup database app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///WODTracker.db' import WODTracker.views from views import * app.add_url_rule('/', view_func=Index.as_view('index'), methods=['GET','POST']) app.add_url_rule('/newuser', view_func=NewUser.as_view('new_user'), methods=['GET','POST']) app.add_url_rule('/recordworkout', view_func=WorkoutView.as_view('workout'), methods=['GET','POST']) app.add_url_rule('/newexercise', view_func=ExerciseView.as_view('new_exercise'), methods=['GET','POST']) app.add_url_rule('/weighin', view_func=WeighInView.as_view('weighin'), methods=['GET','POST']) app.add_url_rule('/calendar', view_func=CalendarView.as_view('calendar'), methods=['GET'])
date : 10/24/15 project : Independent """ # import the modules we need import os import sqlite3 from flask import Flask, render_template, request, g # Create the recipesnremedieslication object recipesnremedies = Flask(__name__) # recipesnremedies.debug = True # Add in a configuration variable for the database, assign recipesnremedies.database = "cookbook.db" # use decorators to link the function to a url @recipesnremedies.route('/', methods=['GET', 'POST']) def home(): """ Function for flask interaction with the html webpage - homepage or index""" try: # g is a temp object specific to flask and it stores the database # connection in this case # this value is reset after each request use it to connect and store # the db object g.db = connect_db() cur= g.db.execute('SELECT * FROM recipes') # cast the data to a dictionary
# import the Flask class from the flask module from flask import Flask, render_template, redirect, url_for, request, session, flash, g, Markup from pymongo import MongoClient from textblob import TextBlob import plotly.plotly as py import numpy as np import plotly.graph_objs as go from plotly import tools import plotly.tools as tls py.sign_in('nashc', '3nzdm0kuzk') # create the application object app = Flask(__name__) app.database = 'press' app.collection = 'mini1' def textblob_sentiment(text): ''' Use TextBlog package to get sentiment values for each press release text INPUT: - text: release text string OUTPUT: - (polarity, subjectivity): tuple containing the sentiment values ''' #create TextBlog object and use inherent methods to get polarity and subjectivity blob = TextBlob(text) polarity = blob.sentiment.polarity
from flask import Flask, render_template, redirect, url_for, request, g import sqlite3 app = Flask(__name__) app.database = "toplist.db" @app.route('/') def home(): return render_template('index.html') @app.route('/result') def result(): g.db = connect_db() cur = g.db.execute('select * from listing') listing = [dict(Year=row[0], Week=row[1], Artist=row[2], Title=row[3], SpotUrl=row[4], SpotID=row[5], Image=row[6]) for row in cur.fetchall()] g.db.close() return render_template('result.html', listing=listing) def connect_db(): return sqlite3.connect(app.database)
FILE_URI = os.path.join(THIS_DIR, 'target/scores.yml') DATABASE_URI = 'mongodb://<dbuser>:<dbpassword>@<instance>.mlab.com:<port>/<dbname>_test' if 'TEST_DATABASE_URI' in os.environ: DATABASE_URI = os.environ['TEST_DATABASE_URI'] app = Flask(__name__) app.config.from_object(Config) # used by flask-login app.secret_key = 'idontwanttobeinthepubliccode' login_manager = flask_login.LoginManager() login_manager.init_app(app) login_manager.login_view = "login" app.database = None def get_db(): """Return the Database :rtype: database.Database""" if app.database is None: print('connecting to %s' % app.config['DATABASE_URI']) app.database = database.Database(app.config['DATABASE_URI']) return app.database @login_manager.user_loader def user_loader(login): # retrieve user from database print('user_loader')
# import the Flask class from the flask module from flask import Flask, render_template, redirect, url_for, request, session, flash from functools import wraps import sqlite3 from Classes import * from pony.orm import * import bcrypt # create the application object app = Flask(__name__) app.secret_key = "tomato" app.database = "notice_db.db" def login_required(f): @wraps(f) def wrap(*args, **kwargs): if 'logged_in' in session: return f(*args, **kwargs) else: flash('Access denied: You must login first.') return redirect(url_for('login')) return wrap # use decorators to link the function to a url @app.route('/', methods=['GET', 'POST']) @db_session def login():
from flask import Flask, request, session, g, redirect, url_for, abort, render_template, flash from apscheduler.schedulers.background import BackgroundScheduler import sqlite3 as lite from webCrawler import getAllFoods from contextlib import closing from flask_mail import Mail, Message app = Flask(__name__) app.config.from_object(__name__) app.config["DEBUG"] = True app.database = "WhatsCookin\'.db" app.config.update( DEBUG = True, MAIL_SERVER = 'smtp.gmail.com', MAIL_PORT=465, MAIL_USE_SSL=True, MAIL_USERNAME = '******', MAIL_PASSWORD = '******' ) #Create mail object mail = Mail(app) app.config.from_object(__name__) #Create the database------------------------------------------------------------ def connect_db(): return lite.connect(app.database) #Creates the database if it doesnt exist
from functools import wraps import sqlite3 import os from config import Config # import the Config class from module config # # create the application object app = Flask(__name__) # app.config.from_object(os.environ['APP_SETTINGS']) # application configuration app.config.from_object('config') app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///posts.db' app.database = "posts.db" app.secret_key = "This-is-confidential" # create the app with security default login being profile route # app.config['SECURITY_POST_LOGIN'] = '******' # create and config the database object db = SQLAlchemy(app) from models import * # gthub oauth configuration # client_id = app.config['GITHUB_CLIENT_ID'] # client_secret = app.config['GITHUB_CLIENT_SECRET']
from flask import Flask, jsonify, render_template, request, g, redirect, request import sqlite3, json app = Flask(__name__) app.database = "chart_data.db" entries = "" def connect_db(): return sqlite3.connect(app.database) @app.route('/', methods=['POST']) def index(): #getdata() g.db = connect_db() #g.db.execute('insert into ghosts (title, description) values (?, ?)',[request.form['title'], request.form['description']]) g.db.execute('insert into chart_table (name,test_value) values ("Shreyas","23")') cur = g.db.execute('select * from chart_table') entries = [dict(test_value=row[1],name=row[0]) for row in cur.fetchall()] g.db.close() #print entries with open("static\chartson.json","w") as outfile: json.dump( entries,outfile) # return render_template('index.html', entries=entries) if __name__ == '__main__': app.run(debug=True)
import re import time # labels: list # data list from multiprocessing import Process # Private - utils is the regex, redditBot is the bot class, redditDatabase is the actually storing and extracting from database from scripts import utils, redditBot, redditDatabase # create application object app = Flask(__name__) # change database name later app.database = { 'database': 'reddit_data', 'user': '******', 'password': '******', 'host': 'localhost' } # secret key for cookies *MUST CHANGE FOR SECURITY* app.secret_key = b'\xd0\x10\x0b$\x0fk\xbe%\xc6\x1b\xe4\xd1\xf0\xe0\xd4\x0210\xc5R\x80X\x98+' # landing page with text field # route() decorator to tell Flask what URL should trigger our function. @app.route('/', methods=['GET', 'POST']) def home(): error = None if request.method == 'POST': session['url'] = request.form['url'] #storing this information while the user is browsing session['isBotOn'] = False #bot isn't on yet if (utils.getPostID(session['url']) == False): error = "You're tripping! Enter a reddit post URL!"
from flask import Flask, render_template, request, g app = Flask(__name__) import inspect, os app.database = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) + '/propcalc.db' import sqlite3 def connect_to_database(): return sqlite3.connect(app.database) @app.route("/") def main(): g.db = connect_to_database() current = g.db.execute('select * from subjects') subjects = current.fetchall() return render_template('my_properties.html', subjects=subjects) import ast @app.route("/edit_property/<subject>") def edit_property(subject): subject = ast.literal_eval(subject) return render_template('edit_property.html', subject=subject) from lib.prop_calc import * @app.route('/sales_approach/<subject>', methods=['GET', 'POST']) @app.route('/sales_approach/', defaults={'subject': None}, methods=['GET', 'POST']) def sales_approach(subject): if request.method == 'POST': subject = {} for field in request.form: subject[field] = request.form[field] subject['address'] = subject['street'] + ' ' + subject['city'] + ', ' + subject['state'] + ' ' + subject['zipcode']
from functools import wraps import sqlite3 import os app = Flask(__name__) def login_required(f): @wraps(f) def wrap(*args, **kwargs): if 'logged_in' in session: return f(*args, **kwargs) else: flash('You need to login first.') return redirect(url_for('login')) return wrap app.secret_key = os.urandom(24) app.database='sample.db' conn=sqlite3.connect('sample.db') @app.route('/welcome') @login_required def welcome(): return render_template('welcome.html') @app.route('/home') @login_required def home(): return render_template('home.html') @app.route('/sef') def sef():
from flask import Flask, render_template, redirect, url_for, request, session,flash, g from functools import wraps import random import sqlite3 app = Flask(__name__) app.secret_key = "f0a9fja09fjaf0aif90afi0a9fi90aif90aif09aif90aif09aifajf09ajf09ajf09ajf09ajf0a" app.database = "hangman.db" def login_required(f): @wraps(f) def wrap(*args, **kwargs): if 'logged_in' in session: return f(*args, **kwargs) else: flash('Please Log In') return redirect(url_for('login')) return wrap @app.route('/') @login_required def start(): #return app.send_static_file('index.html') return render_template('index.html') def getTypes(type): g.db = connect_db() if type is None: qu = g.db.execute('select * from type') else:
from flask import Flask, g, render_template, redirect, request, url_for, session, flash from functools import wraps import sqlite3 from datetime import datetime import urllib app = Flask(__name__) app.secret_key = "not a good secret" app.database = "blog.db" app.config['DEBUG'] = True def connect_db(): return sqlite3.connect(app.database) def login_required(f): @wraps(f) def wrap(*args, **kwargs): if 'logged_in' in session: return f(*args, **kwargs) else: return redirect(url_for('login')) return wrap @app.route('/') @app.route('/index') def index(): g.db = connect_db() cur = g.db.execute('SELECT * FROM posts WHERE pub_status="published" ORDER BY `date_posted` DESC')
import os import torch import pickle from flask import Flask, jsonify, request from sqlalchemy import create_engine, text from model.net import SenCNN from model.split import split_morphs from model.utils import Tokenizer, PadSequence app = Flask(__name__) app.config.from_pyfile("config.py") app.database = create_engine(app.config["DB_URL"], encoding="utf-8", max_overflow=0) # preprocessor & model num_classes = app.config["MODEL"]["num_classes"] max_length = app.config["MODEL"]["length"] with open("model/checkpoint/vocab.pkl", mode="rb") as io: vocab = pickle.load(io) pad_sequence = PadSequence(length=max_length, pad_val=vocab.to_indices(vocab.padding_token)) tokenizer = Tokenizer(vocab=vocab, split_fn=split_morphs, pad_fn=pad_sequence) model = SenCNN(num_classes=app.config["MODEL"]["num_classes"], vocab=vocab) ckpt = torch.load("model/checkpoint/best.tar", map_location=torch.device("cpu")) model.load_state_dict(ckpt["model_state_dict"]) model.eval()
from flask import Flask, flash, g, session, \ redirect, render_template, request, url_for import sqlite3 app = Flask(__name__) app.secret_key = "secret" app.database = "database.db" @app.route('/') def index(): g.db = connect_db() cur = g.db.execute('SELECT * FROM posts') posts = [dict(title=row[0], description=row[1]) for row in cur.fetchall()] g.db.close() return render_template('index.html', posts=posts) @app.route('/login/', methods = ["GET", "POST"]) def login(): error = None if request.method == "POST": lg = request.form['username'] pw = request.form['password'] g.db = connect_db() cur = g.db.execute('SELECT * FROM users') users_dict = [dict(login=row[0], password=row[1]) for row in cur.fetchall()] g.db.close()
from flask import Flask, render_template, url_for, request, redirect, session, flash, g, json, jsonify from functools import wraps from requests.auth import HTTPBasicAuth import sqlite3 from rauth import OAuth2Service app = Flask(__name__) app.database = "DeltaDB1.db" app.secret_key = "oh baby" import requests from flask_bcrypt import Bcrypt bcrypt = Bcrypt(app) @app.route('/') def welcome(): return render_template('login.html') @app.route('/login', methods=['POST']) def login(): username = request.form['username'] password = request.form['password'] g.db = connect_db() user1 = g.db.execute("SELECT * FROM Flyers WHERE username=?", (username, )) print user1 user = [ dict(first_name=row[1], last_name=row[2], username=row[5], password=row[4], uuid=row[0],
from flask import Flask, render_template, redirect, url_for, request, session, flash, g, Markup from functools import wraps from subprocess import check_output from hashlib import sha256 from uuid import uuid4 import sqlite3 app = Flask(__name__) app.config.from_object('config') app.database = app.config['DATABASE'] app.script = app.config['SCRIPT'] app.secret_key = app.config['SECRET_KEY'] ###################################### NON-PAGE FUNCTIONS ################################### ## # Login Required Decorator def login_required(f): @wraps(f) def wrap(*args, **kwargs): if 'logged_in' in session: return f(*args, **kwargs) else: flash('You must be logged in to view this page.') return redirect(url_for('login')) return wrap ## # Admin Required Decorator