import logging
from flask import Flask, render_template
from flask_scss import Scss
app = Flask(__name__)
app.config['SECRET_KEY'] = r'-\x0c(q\xe0#/\xd4\x9c\x1c\x99\xa2\x16f[\x9b'
log = logging.getLogger('werkzeug')
log.disabled = True
app.logger.disabled = True
# Pug - HTML Template Engine
app.jinja_env.add_extension('pypugjs.ext.jinja.PyPugJSExtension')
# Sass - CSS Preprocessor
Scss(app, static_dir='app/static/css', asset_dir='app/static/scss')
@app.route('/')
def index():
return render_template('index.pug')
def create_app(script_info=None):
from logging.config import dictConfig
# Set up logging at DEBUG level ...
# From here: http://flask.pocoo.org/docs/dev/logging/
dictConfig({
'version': 1,
'formatters': {'default': {
'format': '[%(asctime)s] %(levelname)s in %(module)s: %(message)s',
}},
'handlers': {'wsgi': {
'class': 'logging.StreamHandler',
'stream': 'ext://flask.logging.wsgi_errors_stream',
'formatter': 'default'
}},
'root': {
'level': 'DEBUG',
'handlers': ['wsgi']
}
})
# instantiate the app
app = Flask(
__name__,
#template_folder="../backend/templates",
#static_folder="../static",
)
Scss(app)
### set config
# app_settings = os.getenv(
# "APP_SETTINGS", "coffeeshop.server.config.DevelopmentConfig"
# )
# app.config.from_object(app_settings)
### set up extensions
# bcrypt.init_app(app)
# toolbar.init_app(app)
# bootstrap.init_app(app)
# db.init_app(app)
# migrate.init_app(app, db)
### register blueprints
from reviews_app.backend.views import backend_blueprint
app.register_blueprint(backend_blueprint)
### flask security
# from coffeeshop.server.models import User, Role
# from coffeeshop.server.user.forms import ExtendedRegisterForm
# datastore = SQLAlchemyUserDatastore(db, User, Role)
# security_ctx = security.init_app(
# app,
# datastore,
# register_form=ExtendedRegisterForm # extend the register
# )
### jinja2 filters
# from .filters import env_override
# app.jinja_env.filters['env_override'] = env_override
### error handlers
@app.errorhandler(401)
def unauthorized_page(error):
return render_template("errors/401.html"), 401
@app.errorhandler(403)
def forbidden_page(error):
return render_template("errors/403.html"), 403
@app.errorhandler(404)
def page_not_found(error):
return render_template("errors/404.html"), 404
@app.errorhandler(500)
def server_error_page(error):
return render_template("errors/500.html"), 500
### shell context for flask cli
# @app.shell_context_processor
# def ctx():
# return {"app": app, "db": db}
### flask-uploads
# configure_uploads(app, (photos, ))
# patch_request_class(app, None)
### GNU Terry Pratchett
# @app.after_request
# def gnu_terry_pratchett(resp):
# resp.headers.add("X-Clacks-Overhead", "GNU Terry Pratchett")
# return resp
return app
import os
from secrets import token_urlsafe
from flask import Flask, flash, request, redirect, render_template, send_file
from flask_scss import Scss
import utilities
UPLOAD_FOLDER = './static/uploads/'
ALLOWED_EXTENSIONS = {'pdf', 'csv'}
app = Flask(__name__)
# !!! Dont forget to generate it manually nex time, if this shit doesnt work !!!
Scss(app, static_dir='static', asset_dir='assets')
app.secret_key = "posielaj vsetky testy 223 unihack"
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024
def allowed_file(file_name):
return '.' in file_name and \
file_name.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
@app.route('/', methods=['GET', 'POST'])
def home():
if request.method == 'POST':
if 'file_scan' in request.files:
file_scan = request.files['file_scan']
if file_scan.filename == '':
flash('Žádná část souboru')
description='A really __cool__ activity.',
created_by_user_id=1))
db.session.add(
Catagory(name='Skating',
description='**Tony Hawk** does it',
created_by_user_id=1))
db.session.add(
CatagoryItem(name='Snow',
description='You need this to ride on',
catagory_id=1,
created_by_user_id=1))
db.session.add(
CatagoryItem(name='Boots',
description="Otherwise you'll fall off",
catagory_id=1,
created_by_user_id=1))
db.session.commit()
db.session.add(
CatagoryItem(name='Board with wheels',
description="Get moving",
catagory_id=2,
created_by_user_id=1))
db.session.commit()
print("Database tables created")
else:
if app.debug:
# setup scss-folders
Scss(app, static_dir='static/css/', asset_dir='assets/scss/')
app.run()
from flask_sqlalchemy import SQLAlchemy
from rdb import db
from model import User, Post, DbInfo
from flask_login import LoginManager, login_user, logout_user, login_required, current_user
from threading import Timer
from apscheduler.schedulers.background import BackgroundScheduler
import time
import json
# Initialize app
app = Flask(__name__)
app.config.from_object('config.DevelopmentConfig')
app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension')
app.secret_key = "some_key"
db.init_app(app)
Scss(app)
login_manager = LoginManager(app)
login_manager.login_view = "loginsignuppage"
def time_now():
return time.localtime().tm_mday
def _shed():
global today
now = time_now()
if now != today:
today = now
import requests
url = 'http://localhost:5000/updateday'
from flask import Flask, Response, request, render_template, jsonify, make_response, abort, redirect
from flask_scss import Scss
from website_utils.timecard import MemoizedFile, get_date_or_none
from website_utils.config_loader import read_config
######## Initial Flask Application Setup/Configuration ########
app = Flask(__name__)
read_config(app)
# Start SCSS Compilation
app_dir = os.path.dirname(os.path.abspath(__file__))
asset_dir = os.path.join(app_dir, "assets")
static_dir = os.path.join(app_dir, "static")
scss_compiler = Scss(app,
static_dir='static',
asset_dir='assets',
load_paths=None)
scss_compiler.update_scss()
######## Environment-related ########
# Memoized
log_file = MemoizedFile(os.environ.get('BADGE_LOG_PATH', 'seclab.log'))
u = {'GET': 'None', 'POST': 'None'}
try:
e = json.load(open(os.environ.get('e')))
except:
e = None
if e is not None:
u['GET'] = e.get('s', [{}])[0].get('GET')
import os
from flask import Flask
from flask_login import LoginManager
from flask_scss import Scss
from OpenSSL import SSL
app = Flask(__name__, static_folder="./static")
app.config.from_object(os.environ['APP_SETTINGS'])
# Routes
from dash.routes import base, auth
app.register_blueprint(base)
app.register_blueprint(auth, url_prefix="/auth")
# Assets
Scss(app, static_dir='dash/static', asset_dir='dash/assets')
# Database and models
from dash.models import User
# Authorization
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "auth.login"
login_manager.session_protection = "strong"
@login_manager.user_loader
def load_user(user_id):
return User.query.get(user_id)
def create_app(environment="development"):
"""
Setup de la aplicacion
"""
app = Flask(__name__)
app.response_class = CookiesLaxResponse
# Compilacion de archivos scss
Scss(app, static_dir='app/static', asset_dir='app/assets/scss')
cors = CORS(app,
resources={r"/api/*": {
"origins": "*"
}},
support_credentials=True)
app.config['CORS_HEADERS'] = 'Content-Type'
# Configuracion de variables de flask
app.config.from_object(config[ENVIRONMENT])
# Inicializacion de la base de datos
init_db()
load_database()
# Global de jinja para obtener los permisos en navbar
from app.helpers.permission import user_permissions
app.jinja_env.globals.update(user_permissions=user_permissions)
from app.helpers.auth import check_login
app.jinja_env.globals.update(check_login=check_login)
# Global de jinja para el path de los archivos publicos
app.jinja_env.globals.update(
UPLOADS_PUBLIC_DIRECTORY=UPLOADS_PUBLIC_DIRECTORY.replace('./app', ''))
# Reglas de ruteo
from app.resources import user
app.register_blueprint(user.bp)
from app.resources import auth
app.register_blueprint(auth.bp)
from app.resources import configuration
app.register_blueprint(configuration.bp)
from app.resources import center
app.register_blueprint(center.bp)
from app.resources.api import center as center_api
app.register_blueprint(center_api.bp)
from app.resources.api import tipo as tipo_api
app.register_blueprint(tipo_api.bp)
from app.resources.api import configuration as configuration_api
app.register_blueprint(configuration_api.bp)
from app.resources.api import statistics as statistics_api
app.register_blueprint(statistics_api.bp)
from app.resources import turn
app.register_blueprint(turn.bp)
# Config de la sesion
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
# Config del directorio publico de archivos
app.config["UPLOADS_PUBLIC_DIRECTORY"] = UPLOADS_PUBLIC_DIRECTORY
@app.route('/')
def home():
"""
Página inicial del sistema.
"""
from app.models.configuration import Configuration as Config
config = Config.query.filter(Config.name.like('home%')).all()
homeConfig = {}
from app.helpers.auth import desloguear_usuario_inactivo
from app.models.user import User
from flask import session
if check_login():
desloguear_usuario_inactivo(
User.query.filter(
User.username == session["username"]).first())
for element in config:
homeConfig[element.name] = element.value
return (render_template('home.html', homeConfiguration=homeConfig))
@app.teardown_appcontext
def shutdown_session(exception=None):
"""
Codigo para que se puede bajar la base de datos automaticamente
"""
db_session.remove()
return app
import random, string
from flask import Flask, render_template, jsonify
from flask_scss import Scss
from flask_socketio import SocketIO, join_room, emit, send
app = Flask(
__name__,
static_folder="../static/dist",
template_folder="../static/html",
)
Scss(
app,
asset_dir='../static/css',
static_dir='../static/dist',
)
socketio = SocketIO(app)
ROOM_ID = 1
PARTICIPANTS = []
def new_uuid():
return ''.join(random.choices(string.ascii_letters, k=8))
@app.route('/')
def index():
return render_template('index.html')
from flask_scss import Scss
from models import *
GOODREADS_API = os.getenv("GOODREADS_API")
DATABASE_URI = os.getenv("DATABASE_URI")
app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = DATABASE_URI
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
db.init_app(app)
Scss(app, static_dir='static', asset_dir='./static')
# Homepage/Login/Registration page
@app.route("/", methods=["GET", "POST"])
def main():
# Login form user input
email_login = request.form.get("email_login")
password_login = request.form.get("password_login")
# Registration form user input
name_register = request.form.get("name_register")
email_register = request.form.get("email_register")
password_register = request.form.get("password_register")
if request.method == "POST":
import os
from flask import render_template, Flask, request, send_from_directory
from flask_scss import Scss
from app_helper import *
app = Flask(__name__)
Scss(app, asset_dir='assets/scss', static_dir='static/css')
@app.route('/index')
@app.route('/')
def index():
return render_template('home.html',
nav_menu_items=nav_menu_items,
social_media_items=social_media_items)
@app.route('/blog')
def blog():
return 'blog'
@app.route('/events')
def events():
return 'events'
@app.route('/about')
def about():
return 'about'
@app.after_request
def load_scss():
from flask_scss import Scss
Scss(
app,
static_dir=os.path.dirname(os.path.abspath(__file__))+'/home/static/css',
asset_dir=os.path.dirname(os.path.abspath(__file__))+'/home/static/scss')
from flask import Flask
from flask_cors import CORS
from flask_scss import Scss
app = Flask(__name__, instance_relative_config=True)
CORS(app)
Scss(app, static_dir='app/static', asset_dir='app/assets/styles')
from app import views
app.config.from_object('config')
from sfid import sfid from argumentation import argumentation from summarization import summarization from grocery import grocery from emotion import emotion from recommendations import recommendations from go_chatbot import go_chatbot from material import material from chestxray import chestxray from sid import sid from data_selection import data_selection app = Flask(__name__) CORS(app) Scss(app, static_dir='static/ui-kit/custom/css', asset_dir='static/ui-kit/custom/scss') app.register_blueprint(seq2sql_api, url_prefix='/seq2sql') app.register_blueprint(chatbot_api, url_prefix='/chatbot') app.register_blueprint(neural_programmer_api, url_prefix='/neural_programmer') app.register_blueprint(opinion_target_api, url_prefix='/opinion') app.register_blueprint(churn_api, url_prefix='/churn') #app.register_blueprint(ner_api, url_prefix='/ner') app.register_blueprint(kp_extraction_api, url_prefix='/kp') app.register_blueprint(machine_translation_api, url_prefix='/translate') app.register_blueprint(gsw_api, url_prefix='/gsw') app.register_blueprint(argumentation, url_prefix='/argumentation') app.register_blueprint(slot_filling_api, url_prefix='/slotfilling') app.register_blueprint(sfid, url_prefix='/sfid')
from flask import Flask from flask_scss import Scss app = Flask(__name__) app.secret_key = 'set_this_to_something_secret' #TODO scss = Scss(app) scss.update_scss() import webapp.views
from flask import request, render_template, redirect, url_for, g
from auth import login_manager, current_user
from functools import wraps
from flask_scss import Scss
from app import raj
app_name = "Raj's Restaurant App"
Scss(raj, asset_dir='app/assets/scss', static_dir='app/static/css')
def templated(template=None):
def decorator(f):
@wraps(f)
def decorated_function(*args, **kwargs):
template_name = template
if template_name is None:
template_name = request.endpoint.replace('.', '/') + '.html'
ctx = f(*args, **kwargs)
if ctx is None:
ctx = {}
elif not isinstance(ctx, dict):
return ctx
return render_template(template_name, **ctx)
return decorated_function
return decorator
@raj.before_request
def before_request():
import time
from flask import Flask, Response, request, render_template, jsonify, make_response, abort, redirect
from flask_scss import Scss
from website_utils.timecard import MemoizedFile, get_date_or_none
from website_utils.config_loader import read_config
######## Initial Flask Application Setup/Configuration ########
app = Flask(__name__)
read_config(app)
# Start SCSS Compilation
app_dir = os.path.dirname(os.path.abspath(__file__))
asset_dir = os.path.join(app_dir, "assets")
static_dir = os.path.join(app_dir, "static")
scss_compiler = Scss(app, static_dir='static', asset_dir='assets', load_paths=None)
scss_compiler.update_scss()
######## Environment-related ########
# Memoized
log_file = MemoizedFile(os.environ.get('BADGE_LOG_PATH', 'seclab.log'))
u = {'GET': 'None', 'POST': 'None'}
try:
e = json.load(open(os.environ.get('e')))
except:
e = None
if e is not None:
u['GET'] = e['s'][0]['GET']
u['POST'] = e['s'][0]['POST']
import sys
from flask import Flask, Blueprint, url_for, render_template, Markup, abort, jsonify
from flask_scss import Scss
import os
import json
import markdown
import traceback
from application.valid_pages import blog_post_titles as valid_blog_posts
from application.datastore import getDefaultDatastore
application = Flask(__name__)
Scss(application, static_dir="static", asset_dir="static/")
datastore = getDefaultDatastore()
content_dir = 'content'
@application.route('/')
def index():
return render_template('index.html', title="Andrew Codispoti")
@application.route('/resume')
def resume():
return render_template('resume.html', title="Resume")
@application.route('/blog')
def blog():
return render_template('blog_main.html', title="Blog")
