def create_app(test_config=None):
# create and configure the app
app = Flask(__name__, instance_relative_config=True)
app.config.from_mapping(SECRET_KEY='dev', JSON_AS_ASCII=False)
#app.config.update(RESTFUL_JSON=dict(ensure_ascii=False))
if test_config is None:
# load the instance config, if it exists, when not testing
app.config.from_pyfile('config.py', silent=True)
else:
# load the test config if passed in
app.config.from_mapping(test_config)
# ensure the instance folder exists
try:
os.makedirs(app.instance_path)
except OSError:
pass
CORS(app)
from marketinfo import StockNB
app.register_blueprint(StockNB.bp)
# a simple page that says hello
@app.route('/hello')
def hello():
return 'Hello, World!'
return app
def client() -> FlaskClient:
app = Flask(__name__)
ctx = app.app_context()
ctx.push()
app.register_blueprint(bp)
client = app.test_client()
return client
def create_app(config_object):
app = Flask(__name__)
app.config.from_object(config_object)
db.init_app(app)
app.register_blueprint(main_blueprint)
return app
def create_app(config_name):
# 配置日志,并且传入配置名字，获取指定配置所对应的日志等级
setup_log(config_name)
# 创建Flask对象
app = Flask(__name__)
# 加载配置
app.config.from_object(config[config_name])
# 通过app初始化
db.init_app(app)
# 初始化 redis 存储对象
global redis_store
redis_store = StrictRedis(host=config[config_name].REDIS_HOST,
port=config[config_name].REDIS_PORT,
decode_responses=True)
# 开启当前项目 CSRF 保护，只做服务器验证功能
CSRFProtect(app)
@app.after_request
def after_request(response):
# 调用函数生成 csrf_token
csrf_token = generate_csrf()
# 通过 cookie 将值传给前端
response.set_cookie("csrf_token", csrf_token)
return response
# 设置session保存指定位置
Session(app)
@app.errorhandler(404)
@user_login_data
def page_not_found(_):
user = g.user
data = {"user": user.to_dict() if user else None}
return render_template('news/404.html', data=data)
# 注册蓝图
from .modules.index import index_blu
app.register_blueprint(index_blu)
from .modules.passport import passport_blu
app.register_blueprint(passport_blu)
from .modules.news import news_blu
app.register_blueprint(news_blu)
from .modules.profile import profile_blu
app.register_blueprint(profile_blu)
from .modules.admin import admin_blu
app.register_blueprint(admin_blu)
# 注册自定义过滤器
from info.utils.common import do_index_class
app.add_template_filter(do_index_class, "indexClass")
return app
def create_app():
app = Flask(__name__)
app.config.from_object(run_config())
db.init_app(app)
migrate.init_app(app, db)
app.permanent_session_lifetime = timedelta(minutes=20)
app.register_blueprint(create_db)
app.register_blueprint(name_bp)
return app
def create_app():
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URL'] = "sqlite:///flaskdatabase.db"
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
CORS(app)
db.init_app(app)
app.register_blueprint(blogs)
app.config['JWT_SECRET_KEY'] = 'YOUR_SECRET_KEY'
jwt = JWTManager(app)
return app
def register_api(app, routers):
"""
注册蓝图和自定义MethodView
"""
for router in routers:
if isinstance(router, Blueprint):
app.register_blueprint(router)
else:
try:
endpoint = router.__name__
view_func = router.as_view(endpoint)
url = "/{}/".format(router.__name__.lower())
if "GET" in router.__methods__:
app.add_url_rule(
url,
defaults={"key": None},
view_func=view_func,
methods=[
"GET",
],
)
app.add_url_rule(
"{}<string:key>".format(url),
view_func=view_func,
methods=[
"GET",
],
)
if "POST" in router.__methods__:
app.add_url_rule(url,
view_func=view_func,
methods=[
"POST",
])
if "PUT" in router.__methods__:
app.add_url_rule(
"{}<string:key>".format(url),
view_func=view_func,
methods=[
"PUT",
],
)
if "DELETE" in router.__methods__:
app.add_url_rule(
"{}<string:key>".format(url),
view_func=view_func,
methods=[
"DELETE",
],
)
except Exception as e:
raise ValueError(e)
def create_app():
app = Flask(__name__)
app.config["SECRET_KEY"] = "fgsfsggsgfssfs"
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///pybo.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db.init_app(app)
app.config.from_object(config)
# ORM
migrate.init_app(app, db)
if app.config['SQLALCHEMY_DATABASE_URI'].startswith("sqlite"):
migrate.init_app(app, db, render_as_batch=True)
else:
migrate.init_app(app, db)
from . import models
# 블루프린트
# --------------------------------------------------------------------------- #
from .views import main_views, auth_views, question_views, answer_views
app.register_blueprint(main_views.bp)
app.register_blueprint(auth_views.bp)
app.register_blueprint(question_views.bp)
app.register_blueprint(answer_views.bp)
from .filter import format_datetime
app.jinja_env.filters['datetime'] = format_datetime
return app
def create_app(config_name):
app = Flask(__name__)
class_name = config_map.get(config_name)
app.config.from_object(class_name)
# 配置数据库
# global db
# db = SQLAlchemy(app)
db.init_app(app) #将db初始化，并将db设置为全局变量
global redis_store
redis_store = redis.StrictRedis(host=class_name.REDIS_HOST,
port=class_name.REDIS_PORT,
decode_responses=True)
Session(app)
CSRFProtect(app)
from info.utils.common import user_login_data
@app.errorhandler(404)
@user_login_data
def not_found(e):
user = g.user
data = {"user_info": user.to_dict() if user else None}
return render_template("news/404.html", data=data)
@app.after_request
def after_request(response):
# 调用函数生成 csrf_token
csrf_token = generate_csrf()
# 通过 cookie 将值传给前端
response.set_cookie("csrf_token", csrf_token)
return response
from .index import index_blue
app.register_blueprint(index_blue)
from .passport import passport_bule
app.register_blueprint(passport_bule)
from .news import news_blue
app.register_blueprint(news_blue)
from .user import user_blue
app.register_blueprint(user_blue)
from .admin import admin_blue
app.register_blueprint(admin_blue)
#添加过滤器
from info.utils.common import do_index_class
app.add_template_filter(do_index_class, "index_class")
return app
def create_app():
"""Create and configure an instance of the Flask application."""
app = Flask(__name__, instance_relative_config=True)
app.config["SESSION_TYPE"] = "filesystem"
app.secret_key = os.urandom(24).__str__()
app.debug = True
sess.init_app(app)
load_dotenv()
logging.basicConfig(level=logging.DEBUG)
with app.app_context():
app.register_blueprint(bp)
return app
def create_app(config_name):
"""创建app的方法，工厂方法"""
# 0、记录日志
setup_log(config_name)
# 1、创建app对象
app = Flask(__name__)
# development -->DevelopmentConfig 开发模式的配置类
# production --->ProductionConfig线上模式的配置类
configClass = config_dict[config_name]
# 将配置类注册到app上 根据不同配置类，赋予了不同模式的app
app.config.from_object(configClass)
# 2、创建数据库对象
# 懒加载思想，延迟加载
db.init_app(app)
# 3、创建redis数据库对象(懒加载思想）
# decode_response=True 能够二进制数据decode成字符串返回
global redis_store
redis_store = StrictRedis(host=configClass.REDIS_HOST,
port=configClass.REDIS_POST,
db=configClass.REDIS_NUM,
decode_responses=True)
"""
# 4、开启csrf保护机制
1、自动获取cookie中打csrf_token,
2、自动获取ajax请求头中的csrf_token
3、自己校验这两个值
"""
# csrf = CSRFProtect(app)
# 5、创建Session对象，将session的存储方法进行调整（flask后端内存--->redis数据库）
Session(app)
# 6、注册蓝图
# 真正用到蓝图对象的时候才导入，延迟导入（只有函数被调用才会来导入），解决循环导入的问题
from info.moduls.index import index_bp
# 注册首页的蓝图对象
app.register_blueprint(index_bp)
# 注册、登录模块蓝图
from info.moduls.passport import passport_bp
app.register_blueprint(passport_bp)
# 返回不同模式下的app对象
return app
def make_app(
verbose,
host,
port,
password,
root_toolbox_directory,
root_user_directory,
config_path,
use_debugger=False,
use_reloader=False,
) -> Flask:
app = Flask(
__name__,
static_url_path="/assets",
static_folder=str(root_toolbox_directory / "toolbox" / "server" /
"assets"),
)
app.config["ROOT_TOOLBOX_DIRECTORY"] = root_toolbox_directory
app.config["ROOT_USER_DIRECTORY"] = root_user_directory
app.config["CONFIG_PATH"] = config_path
app.config["TEMPLATES_AUTO_RELOAD"] = use_reloader
app.config["HAS_UPLOADS_ENABLED"] = password is not None
secret_key = secrets.token_bytes(32)
app.secret_key = secret_key
csrf.init_app(app)
if password:
credentials = Credentials(username="",
password=generate_password_hash(password))
else:
credentials = None
@auth.verify_password
def verify_password(username, password) -> bool:
if credentials is None:
return False
return check_password_hash(credentials.password, password)
# TODO: Add middleware logging for IP, time, user agent details, highlighting on 404s etc.
# log = logging.getLogger("werkzeug")
# log.disabled = True
app.logger.setLevel(logging.INFO)
app.register_blueprint(server)
validate_app(app)
return app
def create_app(u_selected_config):
app = Flask(__name__)
set_up_log(u_selected_config)
app.config.from_object(seleceted_config[u_selected_config])
app.add_template_filter(do_index_class, "indexClass")
@app.after_request
def after_request(response):
# 调用函数生成 csrf_token
csrf_token = generate_csrf()
# 通过 cookie 将值传给前端
response.set_cookie("csrf_token", csrf_token)
return response
CSRFProtect(app)
Session(app)
db.init_app(app)
# db = SQLAlchemy(app)
# @app.errorhandler(404)
# @check_user
# def page_notfound(e):
# user=g.user
# data={
# 'user':user.to_dict()
# }
# return render_template('others/404.html',data=data)
global redis_store
redis_store = redis.StrictRedis(host=My_config.REDIS_HOST,
port=My_config.REDIS_PORT)
from info.moduls.index import index_
from info.moduls.passport import passport_
from info.moduls.news import news_blu
from info.moduls.profile import profile_blu
from info.moduls.admin import admin_blu
app.register_blueprint(profile_blu)
app.register_blueprint(index_)
app.register_blueprint(passport_)
app.register_blueprint(news_blu)
app.register_blueprint(admin_blu)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config_options[config_name])
bootstrap.init_app(app)
db.init_app(app)
login_manager.init_app(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .requests import configure_request
configure_request(app)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/authenticate')
return app
def create_app(settings): app = Flask(__name__) app.config.from_object(config[settings]) config[settings].init_app(app) bootstrap.init_app(app) mail.init_app(app) moment.init_app(app) db.init_app(app) login_manager.init_app(app) from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/auth') return app
def create_app(test_config=None):
# create and configure the app
app = Flask(__name__)
app.config.from_pyfile("config.py")
@app.before_request
def make_session_permanent():
if session.get("id") == None:
session["id"] = helpers.generateRandomString(20)
session.permanent = True
from . import db, model
db.init_app(app)
model.init_app(app)
from . import predict
app.register_blueprint(predict.bp)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
db.app = app
db.init_app(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
#prevent Jobs get scheduled twice: https://github.com/viniciuschiele/flask-apscheduler/issues/58
if not app.debug or os.environ.get("WERKZEUG_RUN_MAIN") == "true":
scheduler = APScheduler()
scheduler.init_app(app)
scheduler.start()
return app
def create_app(config_name):
app = Flask(__name__,
template_folder='../templates',
static_folder='../static')
app.config.from_object(config[config_name])
config[config_name].init_app(app)
app.register_blueprint(
user_bp) # Create a blueprint and bond the blueprint object
app.register_blueprint(
article_bp) # Create a blueprint and bond the blueprint object
bootstrap.init_app(app)
db.init_app(app)
pagedown.init_app(app)
login.init_app(app)
moment = Moment(app)
login_manager.login_view = 'user.user_login'
login.login_message_category = 'info'
register_commands(app)
register_template_context(app)
print("\n================================\n\n", app.url_map, "\n")
return app
def create_app(config_name):
# Initializing application
app = Flask(__name__, instance_relative_config=True)
# creating app configurations
app.config.from_object(config_options[config_name])
# Initializing flask extensions
bootstrap.init_app(app)
# Registering the blueprint
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
# setting config
from .requests import configure_request
configure_request(app)
# Will add the views and forms
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
pagedown.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
sslify = SSLify(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
import_models()
return app
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(Config)
pagedown.init_app(app)
markown.init_app(app)
db.init_app(app)
migrate.init_app(app, db)
bcrypt.init_app(app)
login_manager.init_app(app)
from app.contribution.routes import contribution
from app.factsheet.routes import factsheet
from app.main.routes import main
from app.users.routes import users
app.register_blueprint(contribution)
app.register_blueprint(factsheet)
app.register_blueprint(main)
app.register_blueprint(users)
return app
def create_current_app(config_class=Config):
app = Flask(__name__)
if config_class:
app.config.from_object(config_class)
app.redis = Redis.from_url(Config.redis_server)
app.task_queue = rq.Queue('flaskgram-tasks', connection=app.redis)
cache.init_app(app)
db.init_app(app)
migrate.init_app(app, db)
login_manager.init_app(app)
mail.init_app(app)
bootstrap.init_app(app)
moment.init_app(app)
babel.init_app(app)
share.init_app(app)
bcrypt.init_app(app)
discussion.init_app(app)
turbolinks(app)
app.elasticsearch = Elasticsearch(
connect_to_bonsai_search()) if Config.ELASTIC_SEARCH_URL else None
from srcode.errors import bp as errors_bp
app.register_blueprint(errors_bp)
from srcode.auth import bp as auth_bp
app.register_blueprint(auth_bp, url_prefix='/auth')
from srcode.user import bp as user_bp
app.register_blueprint(user_bp)
from srcode.community import community as community_bp
app.register_blueprint(community_bp)
from srcode.auth.oauth import google_blueprint as google_bp
app.register_blueprint(google_bp)
from srcode.auth.oauth import facebook_blueprint as facebook_bp
app.register_blueprint(facebook_bp)
from srcode.auth.oauth import github_blueprint as github_bp
app.register_blueprint(github_bp)
from srcode.auth.oauth import twitter_blueprint as twitter_bp
app.register_blueprint(twitter_bp)
with app.app_context():
db.create_all()
if db.engine.url.drivername == 'sqlite':
migrate.init_app(app, db, render_as_batch=True)
else:
migrate.init_app(app, db)
if not app.debug and not app.testing:
if not os.path.exists('logs'):
os.mkdir('logs')
file_handler = RotatingFileHandler('logs/srcode.log',
maxBytes=10240,
backupCount=10)
file_handler.setFormatter(
logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'
))
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
app.logger.setLevel(logging.INFO)
app.logger.info('Flaskgram startup')
return app
from flask_migrate import Migrate from flask_sqlalchemy import SQLAlchemy import config db = SQLAlchemy() migrate = Migrate() # --------------------------------------------------------------------------- # app = Flask(__name__) # SQLAlchemy 설정 app.config.from_object(config) db.init_app(app) migrate.init_app(app, db) # --------------------------------- [edit] ---------------------------------- # from . import models # --------------------------------------------------------------------------- # # 블루프린트 # --------------------------------------------------------------------------- # from .views import main_views, question_views, answer_views, auth_views, naver_views, movie_views app.register_blueprint(main_views.bp) app.register_blueprint(question_views.bp) app.register_blueprint(answer_views.bp) app.register_blueprint(auth_views.bp) app.register_blueprint(naver_views.bp) app.register_blueprint(movie_views.bp) from .filter import format_datetime app.jinja_env.filters['datetime'] = format_datetime
mongo = PyMongo(app)
login_manager = LoginManager()
login_manager.setup_app(app)
admin = Admin(name='Flaskr')
admin.add_view(UserView(name='Users'))
admin.init_app(app)
@login_manager.user_loader
def load_user(userid):
db_user = mongo.db.users.find_one({ '_id': ObjectId(str(userid)) })
user = User(db_user)
return user
app.register_blueprint(entries)
@app.before_request
def before_request():
g.mongo = mongo.db
@app.route('/login', methods=['GET', 'POST'])
def login():
error = None
if request.method == 'POST':
db_user = g.mongo.users.find_one({
'username': request.form['username'],
})
if db_user:
user = User(db_user)
else:
app = Flask(__name__)
app.config.from_object(
config) #config 파일에 작성한 항목을 app.config환경 변수로 부르기 위해 이 코드를 추가헀다
#ORM flask db init하기전에 'export FLASK_APP=pybo/__init__.py' 해야 파일 잡음
#모델을 추가하거나 변경할떄는 flask db migrate(모델을 새로 생성하거나 변결할 때 사용) 명령이나 flask db upgrade(모델의 변경 내용을 실제 데이터베이스에 적용할 떄 사용) 명령만을 사용한다.
db.init_app(app)
migrate.init_app(app, db)
if app.config['SQLALCHEMY_DATABASE_URI'].startswith("sqlite"):
migrate.init_app(app, db, render_as_batch=True)
else:
migrate.init_app(app, db)
from . import models
from .views import main_views, question_views, answer_views, auth_views, comment_views, vote_views
app.register_blueprint(main_views.bp)
app.register_blueprint(question_views.bp)
app.register_blueprint(answer_views.bp)
app.register_blueprint(auth_views.bp)
app.register_blueprint(comment_views.bp)
app.register_blueprint(vote_views.bp)
from .filter import format_datetime
app.jinja_env.filters['datetime'] = format_datetime
if __name__ == '__main__':
app.run(debug=True)
def create_app(settings_override=None, config_settings=Config):
app = Flask(__name__, instance_relative_config=True)
app.config.from_object(config_settings)
if settings_override:
app.config.update(settings_override)
stripe.api_key = app.config.get('STRIPE_SECRET_KEY')
stripe.api_version = app.config.get('STRIPE_API_VERSION')
app.logger.setLevel(app.config["LOG_LEVEL"])
app.register_blueprint(page)
app.register_blueprint(user)
app.register_blueprint(contact)
app.register_blueprint(admin_blu)
app.register_blueprint(billing)
app.register_blueprint(test)
#app.register_blueprint(stripe_webhooks_com)
middleware(app)
errortemplates(app)
extensions(app)
return app
login_manager = LoginManager()
login_manager.setup_app(app)
admin = Admin(name='Flaskr')
admin.add_view(UserView(name='Users'))
admin.init_app(app)
@login_manager.user_loader
def load_user(userid):
db_user = mongo.db.users.find_one({'_id': ObjectId(str(userid))})
user = User(db_user)
return user
app.register_blueprint(entries)
@app.before_request
def before_request():
g.mongo = mongo.db
@app.route('/login', methods=['GET', 'POST'])
def login():
error = None
if request.method == 'POST':
db_user = g.mongo.users.find_one({
'username': request.form['username'],
})
if db_user:
app.logger.critical('ERROR: exiting application due to error: %s', str(e))
os._exit(0)
""" Global function that allows streaming with context used in order to render results of playbook line by line live, used by /run view function. """
def stream_template(template_name, **context):
app.update_template_context(context)
t = app.jinja_env.get_template(template_name)
rv = t.stream(context)
rv.disable_buffering()
return rv
""" Expire sessions after an hour """
@app.before_request
def make_session_permanent():
session.permanent = True
app.permanent_session_lifetime = timedelta(minutes=60)
""" Import and register Blueprints. """
from app.ui.views import ui_blueprint
from app.admin.views import admin_blueprint
from app.restapi.views import restapi_blueprint
app.register_blueprint(ui_blueprint)
app.register_blueprint(admin_blueprint, url_prefix='/admin')
app.register_blueprint(restapi_blueprint)
from flask import Flask
from flask import render_template
from flask import app
from flask import request
from flask import url_for
from flask import Blueprint
from elifozer_operations.useroperations import useroperations, user_is_authenticated
from elifozer_operations.playeroperations import playeroperations
from elifozer_operations.careeroperations import careeroperations
from elifozer_utilities.currentconfig import CurrentConfig
from azizakasenova_matches.initdb import make_structure
from azizakasenova_stadiums.stadium import stadiumapp
app = Flask(__name__)
app.register_blueprint(useroperations)
app.register_blueprint(playeroperations)
app.register_blueprint(careeroperations)
app.register_blueprint(stadiumapp)
def get_elephantsql_dsn(vcap_services):
"""Returns the data source name for ElephantSQL."""
parsed = json.loads(vcap_services)
uri = parsed["elephantsql"][0]["credentials"]["uri"]
match = re.match('postgres://(.*?):(.*?)@(.*?)(:(\d+))?/(.*)', uri)
user, password, host, _, port, dbname = match.groups()
dsn = """user='******' password='******' host='{}' port={}
dbname='{}'""".format(user, password, host, port, dbname)
return dsn
from .users.users import users from flask import app app.register_blueprint(users)
def init_upload(app):
app.register_blueprint(upload_blue, url_prefix='/upload')
Returns:
bool -- Whether or not the user has admin access.
"""
return bool(is_logged_in()
and 'admin' in get_current_access(get_username()))
app.jinja_env.globals.update(check_if_admin=check_if_admin)
# __ __ _
# \ \ / /__| | ___ ___ _ __ ___ ___
# \ \ /\ / / _ \ |/ __/ _ \| '_ ` _ \ / _ \
# \ V V / __/ | (_| (_) | | | | | | __/
# \_/\_/ \___|_|\___\___/|_| |_| |_|\___|
app.register_blueprint(welcome)
# _ _
# / \ ___ ___ _ _ _ __ | |_ ___
# / _ \ / __/ _ \| | | | '_ \| __/ __|
# / ___ \ (_| (_) | |_| | | | | |_\__ \
# /_/ \_\___\___/ \__,_|_| |_|\__|___/
app.register_blueprint(accounts)
# __ ___ _
# \ \ / (_) __| | ___ ___ ___
# \ \ / /| |/ _` |/ _ \/ _ \/ __|
# \ V / | | (_| | __/ (_) \__ \
# \_/ |_|\__,_|\___|\___/|___/
app.register_blueprint(videos)
def main():
db_session.global_init("mars_explorer.sqlite")
app.register_blueprint(jobs_api.blueprint)
port = int(os.environ.get("PORT", 5000))
app.run(host='0.0.0.0', port=port)
from flask import Flask, render_template, redirect, url_for, request, app
from easteregg import easteregg_bp
app.register_blueprint(easteregg_bp, url_prefix='/easteregg')
@easteregg_bp.route('/easteregg')
def easteregg():
return render_template("easteregg.html")
if __name__ == "__main__":
app.run(debug=True)
from flask.ext.triangle.widgets.standard import TextInput
from datetime import timedelta
from flask import session, app
import os
import pusher
import getPost
from flask import Blueprint
settings_local.initParse()
app = Flask(__name__)
Triangle(app)
app.config['UPLOAD_FOLDER'] = 'uploads/'
Hackathon = Blueprint('Hackathon', __name__,
template_folder='templates',subdomain="hack404")
app.register_blueprint(Hackathon)
@app.before_request
def make_session_permanent():
session.permanent = True
app.permanent_session_lifetime = timedelta(minutes=46440)
@app.route('/',methods=['GET', 'POST'])
def index():
# settings_local.initParse()
# if request.method == 'POST' and request.form["what"]== 'Login':
# try:
# print request.form["password"]
# u = User.login(request.form["username"],request.form["password"])
# session['session_token'] = u.sessionToken
