def create_app(): app = Flask(__name__) app.config.from_object(Config) db_session = init_db(app) scheduler = BackgroundScheduler() scheduler.start() scheduler.add_job(processing_timeout, 'interval', seconds=60) scheduler.add_job(old_files_removals, 'interval', hours=24) Path(app.config['PROCESSED_REQUESTS_FOLDER']).mkdir(parents=True, exist_ok=True) Path(app.config['MODELS_FOLDER']).mkdir(parents=True, exist_ok=True) Path(app.config['UPLOAD_IMAGES_FOLDER']).mkdir(parents=True, exist_ok=True) Bootstrap(app) Dropzone(app) notification = db_session.query(Notification).first() if notification is not None: notification.last_notification = datetime.datetime(1970, 1, 1) else: notification = Notification(datetime.datetime(1970, 1, 1)) db_session.add(notification) db_session.commit() jsglue = JSGlue() jsglue.init_app(app) from app.main import bp as main_bp app.register_blueprint(main_bp) return app
def create_app() -> Flask: """ Factory pour la création de l'application Flask :return: L'application flask créé """ # Ici on peut rajouter une initialisation de la configuration par un fichier json, # Si l'on en veut un autre que celui par defaut # config_app.init_from_json_file(json_file) configuration_flask = ConfigurationFlask() current_app = Flask(__name__, static_folder=web_static_dir + '/', template_folder=web_templates_dir + '/') current_app.config.from_object(configuration_flask) current_app.app_context().push() # this does the binding blueprint_registrations(current_app) # So we can upload files # We need to do secret = secrets.token_urlsafe(32) current_app.secret_key = secret # Imperatif de faire l'init_db() après l'initialisation par le fichier de configuration # si l'on veut des valeurs autre que celles par défaut init_db() jsglue = JSGlue() jsglue.init_app(current_app) return current_app
def create_app(test_config=None, SECRET_KEY='dev', instance_path=''): # create and configure the app if not instance_path: app = Flask(__name__, instance_relative_config=True) else: app = Flask(__name__, instance_path=instance_path) app.config.from_mapping( SECRET_KEY=SECRET_KEY, DATABASE=os.path.join(app.instance_path, 'demosaurus.sqlite'), ) jsglue = JSGlue() jsglue.init_app(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 from . import db db.init_app(app) from . import publication app.register_blueprint(publication.bp) from . import link_thesaurus app.register_blueprint(link_thesaurus.bp) from . import subject_headings app.register_blueprint(subject_headings.bp) from . import contributor app.register_blueprint(contributor.bp) # a simple page that says hello @app.route('/hello') def hello(): return 'Hello, World!' @app.route('/favicon.ico') def favicon(): return send_from_directory(os.path.join(app.root_path, 'static'), 'favicon.ico', mimetype='image/vnd.microsoft.icon') @app.route('/') def index(): return render_template('/') return app
def register_extensions(app): """Register Flask extensions.""" assets.init_app(app) bcrypt.init_app(app) cache.init_app(app) db.init_app(app) csrf_protect.init_app(app) login_manager.init_app(app) debug_toolbar.init_app(app) migrate.init_app(app, db) jsglue = JSGlue() jsglue.init_app(app) return None
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) app.config[ 'SQLALCHEMY_DATABASE_URI'] = 'mysql://*****:*****@knowledgebase2018.cd3pupo3w3sq.ap-southeast-1.rds.amazonaws.com/knowledgebase' db.init_app(app) print("App created") csrf.init_app(app) from knowledge import knowledge as knowledge_blueprint # login_manager.session_protection = "strong" login_manager.init_app(app) login_manager.login_view = 'knowledge.login' app.register_blueprint(knowledge_blueprint) moment.init_app(app) misaka.init_app(app) bootstrap.init_app(app) jsglue = JSGlue(app) Markdown(app) return app
def create_app(test_config=None, debug=False): # create and configure the app app = Flask(__name__) app.debug = debug app.jinja_options = dict(autoescape=select_autoescape(default=True), trim_blocks=True) app.config.from_mapping( SECRET_KEY='dev', DATABASE=os.path.join(app.root_path, 'database/database.sqlite'), ) app.config['SECRET_KEY'] = 'ARTK' 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) db.init_app(app) app.register_blueprint(home.bp) app.register_blueprint(packer.bp) app.register_blueprint(docs.bp, url_prefix='/docs') app.register_blueprint(node.bp, url_prefix='/node') app.register_blueprint(projects.bp, url_prefix='/projects') app.register_blueprint(editor.bp, url_prefix='/edit') socketio.init_app(app) messages.init_sockets(socketio) editor.init_sockets(socketio) return app
def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(config_class) pages = FlatPages(app) freezer = Freezer(app) jsglue = JSGlue(app) bootstrap.init_app(app) from app.core import bp as core_bp app.register_blueprint(core_bp) if not app.debug: if not os.path.exists('logs'): os.mkdir('logs') file_handler = RotatingFileHandler('logs/endless_farming.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('Endless farming startup') return app, freezer, pages
def _prepare_app(): """ Setup the initial APP values and initialize various flask plugins. :returns: flask app instance """ # init JSGLUE. this is needed to query URLs in javascript _js_glue = JSGlue(APP) cfg_rdr = ConfigReader() APP.config['SECRET_KEY'] = cfg_rdr.get_attr('db_secret_key') APP.config['SQLALCHEMY_DATABASE_URI'] = cfg_rdr.get_attr('db_address') # needed because this functionality is already depricated APP.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # the salt is a workaround for a bug, as flask-security salts passwords # automatically but somehow it requires and uses this config value which # breaks the login if the salt is individually unique (as a salt should be) APP.config['SECURITY_PASSWORD_SALT'] = 'fake_salt' APP.config['SECURITY_TRACKABLE'] = True APP.config['SECURITY_REGISTERABLE'] = True APP.config['SECURITY_CONFIRMABLE'] = False APP.config['UPLOAD_FOLDER'] = 'config' # max upload size is 50 KB APP.config['MAX_CONTENT_LENGTH'] = 50 * 1024 path = os.path.join('.', os.path.dirname(__file__), 'static/js/sijax/') APP.config['SIJAX_STATIC_PATH'] = path APP.config['SIJAX_JSON_URI'] = '/static/js/sijax/json2.js' flask_sijax.Sijax(APP) APP.config['JWT_ALGORITHM'] = 'RS256' with open(cfg_rdr.get_attr('private_key_file_location'), 'rb') as file: APP.config['JWT_PRIVATE_KEY'] = file.read() JWT = JWTManager(APP) with APP.app_context(): DB.init_app(APP) user_datastore = SQLAlchemyUserDatastore(DB, User, Role) _security = Security(APP, user_datastore) setup(user_datastore) rs256_token = create_access_token(str(current_user), expires_delta=False) APP.config['access_headers'] = {'Authorization': 'Bearer {}' .format(rs256_token)} JSONService.init(APP.config['access_headers']) return APP
def setUp(self): self.app = Flask(__name__) self.jsglue = JSGlue(self.app) handler = lambda: "ok" self.app.add_url_rule('/', 'case0', handler) self.app.add_url_rule('/<a>', 'case1', handler) self.app.add_url_rule('/test/<a>', 'case2', handler) self.app.add_url_rule('/<int:a>/test', 'case3', handler) self.app.add_url_rule('/<int:a>/<int:b>', 'case4', handler) self.app.add_url_rule('/<a>/data', 'case5', handler) self.app.add_url_rule('/<b>/hello', 'case5', handler) self.app.add_url_rule('/<a>/data/<b>', 'case5', handler) self.client = self.app.test_client()
def create_app(config_name): # Create and initialize Flask app # config.py is locate with instance_relative_config app = Flask(__name__, instance_relative_config=True) app.config["SECRET_KEY"] = os.getenv( "SECRET_KEY") or "b'_5#y2LF4Q8znxec]/'" app.config.from_object(app_config[config_name]) app.config.from_pyfile('config.py') Bootstrap(app) jsglue = JSGlue(app) from .home import home as home_blueprint app.register_blueprint(home_blueprint) return app
def create_app(): app = Flask(__name__, instance_relative_config=True, static_folder=None) jsglue = JSGlue(app) # ensure the instance folder exists try: os.makedirs(app.instance_path) except OSError: pass # if running development load dev config, else load from instance file if 'ENV' in app.config and app.config['ENV'] == 'development': from .dev import config as dev_config app.config.from_mapping(dev_config) else: app.config.from_pyfile('prod.cfg') # open db and stuff from . import db db.init_app(app) # expand context from .utils.login import context_processor as login_context_processor, is_logged_in app.context_processor(login_context_processor) # routes from .controllers import auth from .controllers import membership from .controllers import expenses from .controllers import debts app.register_blueprint(auth.router, url_prefix='/auth') app.register_blueprint(membership.router, url_prefix='/member') app.register_blueprint(expenses.router, url_prefix='/expenses') app.register_blueprint(debts.router, url_prefix='/debts') @app.route("/", methods=["GET"]) def default(): if not is_logged_in(): return redirect(url_for('auth.ui_login'), code=302) else: return redirect(url_for('member.ui_home'), code=302) if 'ENV' in app.config and app.config['ENV'] == 'development': print('ENDPOINTS:') print(app.url_map) return app
def create_app(with_error=True, configfile=None): app = Flask(__name__) # Apply frameworks Bootstrap(app) JSGlue(app) HerokuConfig(app, configfile) # Register blueprints if with_error: app.register_blueprint(blueprints.err) app.register_blueprint(blueprints.api) app.register_blueprint(blueprints.frontend) app.register_blueprint(blueprints.frontend_user) app.register_blueprint(blueprints.dummy) app.register_blueprint(blueprints.static) # Configure app for flask-mail app.config['MAIL_SERVER'] = 'smtp.gmail.com' app.config['MAIL_PORT'] = 465 app.config['MAIL_USERNAME'] = os.environ["GM_EMAIL"] app.config['MAIL_PASSWORD'] = os.environ["GM_PASSWORD"] app.config['MAIL_USE_TLS'] = False app.config['MAIL_USE_SSL'] = True app.config['MAIL_DEFAULT_SENDER'] = os.environ["GM_EMAIL"] # Set jinja cache to unlimited app.jinja_env.cache = {} # Generate secret key for forms app.secret_key = bytes(os.environ.get("SECRET_KEY"), encoding='utf-8') # Configure app to for bootstrap to not use CDN app.config["BOOTSTRAP_SERVE_LOCAL"] = True # Configure mail instance mail = Mail(app) app.config["MAIL_INSTANCE"] = mail # Append nav bar to app blueprints.nav.init_app(app) return app
def create_app(test_config=None): # create and configure the app app = Flask(__name__) if test_config is None: # load the instance config, if it exists, when not testing from .config import Config app.config.from_object(Config) 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 # init database db.init_app(app) # init flask-security user_datastore = SQLAlchemyUserDatastore(db, User, Role) security = Security(app, user_datastore) init_data(app) # cleanup any leftover containers, networks or files before starting or exiting atexit.register(cleanup, app=app) cleanup(app) # register blueprints register_blueprints(app) # init jsglue jsglue = JSGlue(app) return app
import re from flask import Flask, jsonify, render_template, request, url_for from flask_jsglue import JSGlue from cs50 import SQL from helpers import lookup # 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 CS50 Library to use SQLite database db = SQL("sqlite:///mashup.db") @app.route("/") def index(): return render_template("index.html")
from boto.s3.connection import S3Connection import dna_assembler BASE_DIR = os.path.dirname(__file__) UPLOAD_FOLDER = os.path.normpath(os.path.join( BASE_DIR, 'data/upload')) # Local destination for storage of FASTQ files. DOWNLOAD_FOLDER = os.path.normpath(os.path.join( BASE_DIR, 'data/download')) # Local destination for storage of FASTA files. AWS_KEY = "" # Must include AWS Key ID. AWS_SECRET = "" # Must include AWS Secret Key. KEY_BASE_UPLOAD = "upload/" # AWS S3 destination for storage of FASTQ files. KEY_BASE_DOWNLOAD = "download/" # AWS S3 destination for storage of FASTA files. application = Flask(__name__) jsglue = JSGlue(application) application.config.from_object('config') # Access data in config.py application.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER application.config['DOWNLOAD_FOLDER'] = DOWNLOAD_FOLDER # ####### VIEWS ######### # ####################### @application.route('/') @application.route('/index') def index(): """ Flask microframework root endpoint. Redirects navigation to the fileinput endpoint. """
monkey.patch_all() from flask import Flask, g, url_for, render_template, request, redirect, flash, session, abort, Markup from oauth2client.client import flow_from_clientsecrets import httplib2 import json from apiclient.discovery import build from flask_jsglue import JSGlue from model.redis_model import RedisModel import lib.common as common from lib.mysocket import MySocket from flask_socketio import join_room jsglue = JSGlue() app = Flask(__name__) jsglue.init_app(app) app.config.from_object('config.config') app.config.from_envvar('PPOSTER_SETTINGS', silent=True) model = RedisModel(app.config) my_socket = MySocket(app, async_mode) socketio = my_socket.get_socketio() #socketio = SocketIO(app, async_mode=async_mode) thread = None RESERVED_ALIASES = ['login', 'register', 'google_auth', 'auth_return', 'logout', 'timelinejson', 'public', 'add_tweet', 're_tweet', 'remove_tweet', 'add_comment', 'notifications'] def is_reserved(alias):
def setup_extention(self): jsglue = JSGlue(self.app)
from ontology.sdk import Ontology from ontology.utils import utils from ontology.wallet.wallet_manager import WalletManager from werkzeug.utils import secure_filename # ipfs_daemon = subprocess.Popen("ipfs daemon", stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True) static_folder = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'static') template_folder = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'templates') app = Flask('IPAblum', static_folder=static_folder, template_folder=template_folder) app.config.from_object('default_settings') ImageFile.LOAD_TRUNCATED_IMAGES = True jsglue = JSGlue() jsglue.init_app(app) default_identity_account = None default_wallet_account = None try: ipfs = ipfsapi.connect(app.config['IPFS_HOST'], app.config['IPFS_PORT']) except Exception: print('Failed to establish a new connection to IPFS node...') exit(1) def remove_file_if_exists(path): if os.path.isfile(path): os.remove(path) return True
# 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)
from flask import Flask, render_template, jsonify, url_for, request from flask_jsglue import JSGlue import random from uuid import uuid1 app = Flask(__name__) jsglue = JSGlue() jsglue.init_app(app) # 让js文件中可以使用url_for方法 results = [] chars = 'ABCDEFGHIJKLMNOPQRSTUVWSYZ' results.append({'name': 'vue.js+flask+element-ui简易Demo', 'flag': 'true'}) results.append({ 'name': '代码请戳github', 'flag': 'true', 'url': 'https://github.com/qianbin01/Vue-flask' }) for i in range(5): results.append({'name': random.choice(chars), 'index': str(uuid1())}) @app.route('/') def index(): return render_template('index.html') @app.route('/get_data') def get_base_data(): return jsonify({'results': results}) @app.route('/add', methods=['POST'])
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 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 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(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
scraper_dependencies = dict(get=requests.get, BeautifulSoup=BeautifulSoup, re=re) scraper = ScheduleScraper(**scraper_dependencies) settings['SECRET_KEY'] = os.environ.get('SECRET_KEY', helpers.get_salt(25)) app = Flask(__name__) # required for datad url_for PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__)) STATIC_URL = '/static/' STATIC_ROOT = os.path.join(PROJECT_ROOT, 'static') app.static_path = STATIC_ROOT jsglue = JSGlue(app) app.jinja_env.add_extension('jinja2.ext.loopcontrols') app.config["SESSION_FILE_DIR"] = mkdtemp() app.config["SESSION_PERMANENT"] = False app.config["SESSION_TYPE"] = "filesystem" app.config['TEMPLATES_AUTO_RELOAD'] = True app.config.update( {'SECRET_KEY': os.environ.get('SECRET_KEY', settings.get('SECRET_KEY'))}) if app.config["DEBUG"]: @app.after_request def after_request(response): response.headers["Cache-Control"] = ("no-cache, no-store," +
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'
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
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)
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
would automatically have a __tablename__ value of 'my_model' :return: """ return to_snake_case(cls.__name__) def __init__(self, **kwargs): for attr_name, attr_value in kwargs.items(): setattr(self, attr_name, attr_value) def __repr__(self: DeclarativeMeta): column_names = (c.name for c in self.__mapper__.columns) kwargs = ', '.join(f'{n}={getattr(self, n)!r}' for n in column_names) return f'{self.__class__.__name__}({kwargs})' def as_dict(self: DeclarativeMeta): column_names = (c.name for c in self.__mapper__.columns) return {n: getattr(self, n) for n in column_names} @property def session(self): instance_state = inspect(self) return instance_state.session or db.session db = SQLAlchemy(model_class=ModelBase) debug_toolbar = DebugToolbarExtension() jsglue = JSGlue() mail = Mail() csrf = CSRFProtect() login_manager = LoginManager()
def _setup_jsglue(app): return JSGlue(app)