def create_app(debug=False):
# -----------------------------
# Create App
# -----------------------------
# instantiate the Flask app, __name__ tells Flask what belongs to the application
app = Flask(__name__, static_url_path='/static')
app.debug = debug
# I make it so you can build URLs in javascript using Flask's url_for
# rather than having to hardcode anything.
# http://stewartjpark.com/Flask-JSGlue/
jsglue = JSGlue(app)
# -----------------------------------
# Set up a Logger for your application
# -----------------------------------
# log = standard Pythong logging thing you create here -- then add it to the Flask handler
# app.logger.addHandler(log)
# use your logger with app.logger.info('this is info'), don't use print statements inside Flask
# ----------------------------------
# Load an appropriate Flask configuration file for a debug or production version
# ----------------------------------
if app.debug:
server_config_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'configuration', 'localhost.cfg')
else:
pass
# Load a configuration file for a production version of your app!
# server_config_file = /path/to/production/config/file
# app.logger.info('Loading config file: {0}'.format(server_config_file))
app.config.from_pyfile(server_config_file)
# ----------------------------
# Manually add any configuration parameters
# ----------------------------
app.config["UPLOAD_FOLDER"] = os.environ.get("MYAPP_DATA_DIR", None)
# ----------------------------
# Global Error Handlers
# ----------------------------
@app.errorhandler(404)
def this_is_the_wrong_page(e):
error = {}
error['title'] = 'MyApp | Page Not Found'
error['page'] = request.url
return render_template('errors/page_not_found.html', **error), 404
# ----------------------------------
# Web Route Registration - Import and register all your blueprints here
# ----------------------------------
from myapp.controllers.index import index_page
from myapp.controllers.examples import example_page
url_prefix = '/myapp' # I can prefix all routes with a name
app.register_blueprint(index_page, url_prefix=url_prefix)
app.register_blueprint(example_page, url_prefix=url_prefix)
# Register all custom Jinja filters in the file.
app.register_blueprint(jinjablue)
return app
from flask_session import Session
sess = Session()
from flask_cors import CORS # noqa
# from flask_apscheduler import APScheduler
# scheduler = APScheduler()
# from flask.ext.log import Logging
# flask_log = Logging()
from flask_wtf import CSRFProtect # noqa: E402
csrf = CSRFProtect()
from flask_jsglue import JSGlue # noqa: E402
jsglue = JSGlue()
from flask_mail import Mail # noqa: E402
mail = Mail()
import wtforms_json # noqa: E402
wtforms_json.init()
try:
from raven.contrib.flask import Sentry
sentry = Sentry()
except ImportError:
sentry = None
import flask_menu # noqa
def create_app(config_name):
global app
global log
#set up logging
LOG_FILENAME = os.path.join(sys.path[0],
app_config[config_name].STATIC_PATH,
'log/rr-log.txt')
try:
log_level = getattr(logging, app_config[config_name].LOG_LEVEL)
except:
log_level = getattr(logging, 'INFO')
log.setLevel(log_level)
log.addFilter(MyLogFilter())
log_handler = logging.handlers.RotatingFileHandler(LOG_FILENAME,
maxBytes=10 * 1024,
backupCount=5)
log_formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(username)s - %(message)s')
log_handler.setFormatter(log_formatter)
log.addHandler(log_handler)
log.info('start RR')
app.config.from_object(app_config[config_name])
app.config.from_pyfile('config.py')
app.jinja_env.filters['milliseconds_to_minutes_seconds'] = ms2m_s_ms
Bootstrap(app)
jsglue = JSGlue(app)
db.app = app # hack :-(
db.init_app(app)
excel.init_excel(app)
app.url_map.converters['int'] = IntegerConverter
random.seed()
if not config.DB_TOOLS:
login_manager.init_app(app)
login_manager.login_message = 'Je moet aangemeld zijn om deze pagina te zien!'
login_manager.login_view = 'auth.login'
migrate = Migrate(app, db)
from app import models
#create_admin(db) # Only once
#flask db migrate
#flask db upgrade
#uncheck when migrating database
#return app
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
from .settings import settings as settings_blueprint
app.register_blueprint(settings_blueprint)
from .user import user as user_blueprint
app.register_blueprint(user_blueprint)
from .registration import registration as registration_blueprint
app.register_blueprint(registration_blueprint)
@app.errorhandler(403)
def forbidden(error):
return render_template('errors/403.html', title='Forbidden'), 403
@app.errorhandler(404)
def page_not_found(error):
return render_template('errors/404.html',
title='Page Not Found'), 404
@app.errorhandler(500)
def internal_server_error(error):
return render_template('errors/500.html',
title='Server Error'), 500
@app.route('/500')
def error_500():
abort(500)
return app
from flask import Flask, request, render_template, redirect, jsonify, render_template_string
from flask_jsglue import JSGlue # this is use for url_for() working inside javascript which is help us to navigate the url
import util
import os
from werkzeug.utils import secure_filename
application = Flask(__name__)
application.debug = True
# JSGlue is use for url_for() working inside javascript which is help us to navigate the url
jsglue = JSGlue() # create a object of JsGlue
jsglue.init_app(application) # and assign the app as a init app to the instance of JsGlue
util.load_artifacts()
#home page
@application.route("/")
def home():
return render_template("home.html")
#classify plant
@application.route("/classifyPlant", methods = ["POST"])
def classifyPlant():
image_data = request.files["file"]
#save the image to upload
basepath = os.path.dirname(__file__)
image_path = os.path.join(basepath, "uploads", secure_filename(image_data.filename))
image_data.save(image_path)
predicted_value, details = util.classify_plant(image_path)
os.remove(image_path)
return jsonify(predicted_value=predicted_value, details=render_template_string(details))
def _setup_jsglue(app):
return JSGlue(app)
from flask_jsglue import JSGlue
from flask_cors import CORS, cross_origin
#----------------------------------------------------------------------------
# APPLICATION SETUP
# Flask
application = Flask(__name__)
# Flask Configuration
application.config.from_pyfile('config.py')
# Application database connection (for user management only)
application_db = flask_sqlalchemy.SQLAlchemy(application)
# Remote database (for operational data)
dynamo_db = Dynamo(application)
# Expose Flask Routes to client-side
jsglue = JSGlue(application)
# Enable CORS on select routes.
cors = CORS(application, resources={r"/api/*": {"origins": "*"}})
logging.getLogger('flask_cors').level = logging.ERROR
# application imports (these use the Flask "application" object, so get imported here)
from .admin import admin_blueprint
from .api import api_blueprint
from .api.db_interface import get_all_fishfries, get_one_fishfry, hide_one_fishfry, make_one_fishfry, update_one_fishfry, delete_one_fishfry
from .models import FishFryFeature, FishFryProperties, FishFryEvent, FishFryMenu, Feature
from .forms import FishFryForm, EventForm, postprocess_events
from .forms import postprocess_boolean as postbool
from .forms import preprocess_boolean as prebool
from .utils import sort_records, handle_utc
#----------------------------------------------------------------------------
def create_app(config_name):
global app
app.config.from_object(app_config[config_name])
app.config.from_pyfile('config.py')
# app.create_jinja_environment()
# app.jinja_options={'extensions':['jinja2.ext.i18n']}
# app.
Bootstrap(app)
jsglue = JSGlue(app)
db.app = app # hack :-(
db.init_app(app)
if not config.DB_TOOLS:
login_manager.init_app(app)
login_manager.login_message = 'You must be logged in to access this page'
login_manager.login_view = 'auth.login'
migrate = Migrate(app, db)
from app import models
#create_admin(db) # Only once
#flask db migrate
#flask db upgrade
#uncheck when migrating database
#return app
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
from .user import user as user_blueprint
app.register_blueprint(user_blueprint)
from .asset import asset as asset_blueprint
app.register_blueprint(asset_blueprint)
from .supplier import supplier as supplier_blueprint
app.register_blueprint(supplier_blueprint)
from .device import device as device_blueprint
app.register_blueprint(device_blueprint)
from .purchase import purchase as purchase_blueprint
app.register_blueprint(purchase_blueprint)
from .documents import init_documents
init_documents(app, 'commissioning')
init_documents(app, 'risk_analysis')
init_documents(app, 'photo')
init_documents(app, 'manual')
init_documents(app, 'safety_information')
@app.errorhandler(403)
def forbidden(error):
return render_template('errors/403.html', title='Forbidden'), 403
@app.errorhandler(404)
def page_not_found(error):
return render_template('errors/404.html',
title='Page Not Found'), 404
@app.errorhandler(500)
def internal_server_error(error):
return render_template('errors/500.html',
title='Server Error'), 500
@app.route('/500')
def error_500():
abort(500)
return app
def create_app(settings=None):
_log.info("Creating flask app")
app = Flask(__name__, static_folder='presentation/web/static', static_url_path='/metadome/static',
template_folder='presentation/web/templates')
app.config.from_object('metadome.default_settings')
if settings:
app.config.update(settings)
# Ignore Flask's built-in logging
# app.logger is accessed here so Flask tries to create it
app.logger_name = "nowhere"
app.logger
# Configure logging.
#
# It is somewhat dubious to get _log from the root package, but I can't see
# a better way. Having the email handler configured at the root means all
# child loggers inherit it.
from metadome import _log as metadom_logger
# Only log to the console during development and production, but not during
# testing.
if app.testing:
metadom_logger.setLevel(logging.DEBUG)
else:
ch = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s - %(levelname)s - %(message)s')
ch.setFormatter(formatter)
metadom_logger.addHandler(ch)
if app.debug:
metadom_logger.setLevel(logging.DEBUG)
else:
metadom_logger.setLevel(logging.INFO)
# Add mail instance
if not MAIL_SERVER is None:
mail.init_app(app)
else:
_log.warn('MAILSERVER is not set in default_settings.py')
# Initialize extensions
from metadome import toolbar
toolbar.init_app(app)
# Specify the Blueprints
from metadome.presentation.web.routes import bp as web_bp
from metadome.presentation.api.routes import bp as api_bp
# Register the Blueprints
app.register_blueprint(api_bp, url_prefix='/metadome/api')
app.register_blueprint(web_bp, url_prefix='/metadome')
# Database
from metadome.database import db
db.init_app(app)
with app.app_context():
db.create_all()
from flask_jsglue import JSGlue
flask_jsglue.JSGLUE_JS_PATH = '/metadome/static/js/JSGlue.js'
jsglue = JSGlue(app)
return app
# from sqlalchemy.orm import scoped_session, sessionmaker
from werkzeug.security import check_password_hash, generate_password_hash
from helpers import login_required
from flask_socketio import SocketIO, emit, join_room
from sqlalchemy.sql import func
from sqlalchemy import and_, or_
from flask_sqlalchemy import get_debug_queries
# Import table definitions
from models import *
"""Configure app"""
app = Flask(__name__)
# app.config["SECRET_KEY"] = os.getenv("SECRET_KEY")
socketio = SocketIO(app) # For chat
JSGlue(app) # For typeahead
# ensure responses aren't cached
if app.config["DEBUG"]:
@app.after_request
def after_request(response):
response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# Configure session to use filesystem
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
log.setLevel(log_level)
log.addFilter(MyLogFilter())
log_handler = logging.handlers.RotatingFileHandler(LOG_FILENAME,
maxBytes=10 * 1024,
backupCount=5)
log_formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(username)s - %(message)s')
log_handler.setFormatter(log_formatter)
log.addHandler(log_handler)
log.info('start SULCM')
flask_app.config.from_object(app_config[config_name])
flask_app.config.from_pyfile('config.py')
jsglue = JSGlue(flask_app)
db.app = flask_app # hack:-(
db.init_app(flask_app)
socketio = SocketIO(
flask_app,
async_mode=flask_app.config['SOCKETIO_ASYNC_MODE'],
ping_timeout=10,
ping_interval=5,
cors_allowed_origins=flask_app.config['SOCKETIO_CORS_ALLOWED_ORIGIN'])
flask_app.url_map.converters['int'] = IntegerConverter
login_manager.init_app(flask_app)
login_manager.login_message = 'Je moet aangemeld zijn om deze pagina te zien!'
login_manager.login_view = 'auth.login'
from flask import Flask, render_template, request
import test
from flask_jsglue import JSGlue
app = Flask(__name__)
jsglue = JSGlue() ## Jquery 및 ajax 연동하기 위해 설정
app = Flask(__name__)
jsglue.init_app(app)
@app.route("/")
def index():
print("시작 페이지 접속")
return render_template('index.html')
#background process happening without any refreshing
@app.route('/background_process_test',
methods=['GET', 'POST']) ## html에서 감지하고 감지한 데이터로 UID만 가져오기
def background_process_test():
print("러닝시작")
if request.method == "POST":
data = {}
data = request.json['uid']
if data == None:
return render_template('index.html')
uid = list(data.keys())[0]
name = test.getdata(uid) ## 파일 이름 가져오기
def create_app():
app = Flask(__name__,
static_folder='public/static',
static_url_path='/static')
Bootstrap(app)
mongo = PyMongo(app)
jsglue = JSGlue(app)
filter_keys = ['all', 'type', 'setname', 'buildname', 'jailname', 'server']
@app.template_filter('duration')
def duration_filter(s):
s = int(s)
hours, remainder = divmod(s, 3600)
minutes, seconds = divmod(remainder, 60)
return '%d:%02d:%02d' % (hours, minutes, seconds)
@app.template_filter('datetime')
def format_datetime(timestamp, format='%Y-%m-%d %H:%M'):
date = datetime.datetime.fromtimestamp(int(timestamp))
return time.strftime(format, time.gmtime(int(timestamp)))
def _get_builds(selector, projection=None):
return {
'filter':
selector,
'builds':
list(
mongo.db.builds.find(selector, projection).sort([
('started', pymongo.DESCENDING),
('setname', pymongo.ASCENDING),
('ptname', pymongo.ASCENDING),
('jailname', pymongo.ASCENDING),
('buildname', pymongo.ASCENDING),
]))
}
# Mongo does not allow '.' in keys due to dot-notation.
def fix_port_origins(ports):
if 'pkgnames' not in ports:
return
for origin in ports['pkgnames']:
if '%' in origin:
fixed_origin = origin.replace('%', '.')
ports['pkgnames'][fixed_origin] = ports['pkgnames'].pop(origin)
for field in ['built', 'failed', 'skipped', 'ignored']:
if field in ports and origin in ports[field]:
ports[field][fixed_origin] = ports[field].pop(origin)
def get_server_map():
return {
x["_id"]: x
for x in list(mongo.db.servers.find({}, {'masternames': 0}))
}
@app.route('/')
def index():
return builds()
@app.route('/servers.js')
def servers_js():
return make_response(
"var servers = %s;" % (json.dumps(get_server_map())), 200,
{'Content-Type': 'text/javascript'})
def _get_filter():
query = {'latest': True}
projection = {
'jobs': False,
'snap.now': False,
}
latest = True
if request.args is not None:
for key, value in request.args.iteritems():
if key in filter_keys:
query[key] = value
filter = query.copy()
if "setname" in query:
if query['setname'] == "default":
query['setname'] = ''
if "all" in query or "buildname" in query:
if "all" in query:
del (query['all'])
del (query['latest'])
latest = False
if "type" in query:
build_types = query['type'].split(',')
query['type'] = {'$in': build_types}
return (query, projection, filter)
def _builds():
query, projection, filter = _get_filter()
build_results = _get_builds(query, projection)
filter_qs_filter = filter.copy()
if 'type' in filter_qs_filter:
del filter_qs_filter['type']
filter_qs = urlencode(filter_qs_filter)
return {
'builds': build_results['builds'],
'filter': build_results['filter'],
'filter_qs': filter_qs
}
@app.route('/api/1/builds')
def api_builds():
results = _builds()
del results['filter_qs']
return jsonify(results)
@app.route('/builds')
def builds():
results = _builds()
results['servers'] = get_server_map()
return render_template('builds.html', **results)
def _build(buildid):
build = mongo.db.builds.find_one_or_404({'_id': buildid})
ports = mongo.db.ports.find_one({'_id': buildid})
if ports is not None:
fix_port_origins(ports)
return {'build': build, 'ports': ports}
@app.route('/api/1/builds/<buildid>')
def api_build(buildid):
results = _build(buildid)
return jsonify(results)
@app.route('/builds/<buildid>')
def build(buildid):
results = _build(buildid)
results['servers'] = get_server_map()
return render_template('build.html', **results)
return app
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',
DATABASE=os.path.join(app.instance_path, 'flaskr.sqlite'),
)
jsglue = JSGlue(app)
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
# a simple page that says hello
@app.route('/')
def hello():
title = "Input Preference"
print(os.getcwd(), file=sys.stderr)
return render_template('user_pref.html', title=title)
@app.route('/attractions', methods=['GET'])
def user_pref():
# print(request.args.get('pref'), file=sys.stderr)
pref = request.args.get('pref')
# print(pref, file=sys.stderr)
result = json.dumps(get_top_elements_from_db(pref))
country_count = get_country_count()
# print(country_count)
# print(result, file=sys.stderr)
return render_template('map.html',
result=result,
pref=pref,
country_count=country_count)
@app.route(
'/city_info', )
def city_info():
query = request.args.get('data')
query = json.loads(query)
# data = get_city_info(query)
# print(data[0], file=sys.stderr)
# get_country_count()
html = render_template('city_info.html',
data=query,
raw=json.dumps(query))
return jsonify({'results': html})
@app.route('/city_compare', methods=['POST'])
def city_compare():
content = request.get_json(silent=True)
print(content, file=sys.stderr)
# query = json.loads(query)
html = render_template('city_comparison.html', data=content)
return jsonify({'results': html})
@app.route('/country_info')
def country_info():
pref = request.args.get('pref')
country = request.args.get('country')
print(country, file=sys.stderr)
print(pref, file=sys.stderr)
result = json.dumps(get_cities_of_country(pref, country))
return jsonify({"result": result})
from . import db
db.init_app(app)
return app
from cs50 import SQL
from flask import Flask, flash, redirect, render_template, request, session, url_for, jsonify
from flask_session import Session
from passlib.apps import custom_app_context as pwd_context
from tempfile import gettempdir
import datetime, time
from helpers import *
from sqlalchemy import DATE, cast
from flask_jsglue import JSGlue
import os
import re
import json
# configure application
app = Flask(__name__)
JSGlue(app)
# ensure responses aren't cached
if app.config["DEBUG"]:
@app.after_request
def after_request(response):
response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# configure session to use filesystem (instead of signed cookies)
app.config["SESSION_FILE_DIR"] = gettempdir()
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
from flask import Flask, render_template, request, redirect, url_for, jsonify
from flask_login import login_required, LoginManager, UserMixin, login_user, logout_user, current_user
from flask_jsglue import JSGlue
from functools import wraps, update_wrapper
import hashlib
from .utils import make_hash, check_db, convert_datetime
from .db import DB
import json
import flask
from .types import UserClass
DB_FILE = r"/home/akanksha/flask/app/pythonsqlite.db"
db = DB(DB_FILE)
login_manager = LoginManager()
app = Flask(__name__)
fujs = JSGlue(app)
login_manager.init_app(app)
app.secret_key = b'_5#y2L"F4Q8z\n\xec]/'
@login_manager.user_loader
def load_user(user_id):
return check_db(user_id)
def my_decorator():
def decorator(function):
def wrapper(*args, **kwargs):
print("hello", function, kwargs)
if kwargs['name'] != current_user.get_name():
flask.abort(400)
import json
from pprint import pformat
from flask import Flask, Response, render_template, request, jsonify
from flask_jsglue import JSGlue
from movies import get_movies, get_movie_info
app = Flask(__name__)
jsglue = JSGlue(app)
movies_by_title = {r['movie_title'] for r in get_movies()}
movies_by_id = {r['id']: r for r in get_movies()}
@app.route('/autocomplete', methods=['GET'])
def autocomplete():
search = request.args.get('q')
filtered_movies = [
m for m in movies_by_title if search.lower() in m.lower()
]
return jsonify(matching_results=sorted(filtered_movies))
@app.route('/', methods=['GET', 'POST'])
def index():
return render_template("main.html")
@app.route('/movie/<int:movie_id>')
def show_movie(movie_id):
from flask import Flask, render_template, session
from flask_jsglue import JSGlue
from views.voters import vtr
from views.contacts import con
from views.groups import grp
from views.turfs import trf
server = Flask(__name__)
server.config["SEND_FILE_MAX_AGE_DEFAULT"] = 1 # disable caching
jsglue = JSGlue(server)
server.register_blueprint(vtr)
server.register_blueprint(con)
server.register_blueprint(grp)
server.register_blueprint(trf)
@server.route('/')
def homepage():
return render_template('home.html', title='Adlai says hello')
@server.route('/goodbye')
def goodbye():
return render_template('home.html', title='Adlai says goodbye')
@server.errorhandler(401)
def unauthorized_access():
return render_template('401.html'), 401