from .db.BingoPostgresAdapter import BingoPostgresAdapter from .db.models import LibraryMeta, User as Usermodel from .db.database import db_session from .common.util import item_to_sdf_chunk, merge_dicts, api_route from .celery_app import celery from .validation import LibrarySchema, SearcherSchema, UserSchema libraries_api = Blueprint('libraries_api', __name__) if not os.path.exists(config.__dict__['UPLOAD_FOLDER']): os.makedirs(config.__dict__['UPLOAD_FOLDER']) libraries_api.indigo = Indigo() libraries_api.renderer = IndigoRenderer(libraries_api.indigo) libraries_api.indigo_inchi = IndigoInchi(libraries_api.indigo) libraries_api.config = config.__dict__ libraries_api.adapter = BingoPostgresAdapter(libraries_api.config, libraries_api.indigo, libraries_api.indigo_inchi) libraries_api.redis = redis.StrictRedis(host='localhost', port=6379, db=0) libraries_api_app = flask_restful.Api(libraries_api) libraries_api_logger = logging.getLogger('libraries') #libraries_api_logger.addHandler(logging.FileHandler('/srv/api/app.log')) auth = HTTPBasicAuth() libraries_api_app.route = types.MethodType(api_route, libraries_api_app) @auth.verify_password def verify_password(email, password): user = Usermodel.query.filter(Usermodel.email == email).first() if not user or not user.check_password(password):
from flask import Blueprint, jsonify, request, url_for from flask_login import current_user import flask_restful as restful from flask_restful import reqparse, fields, marshal_with from flask_restful.representations.json import output_json from server.autograder import submit_continous from server.constants import STAFF_ROLES, VALID_ROLES from server.controllers import files from server.extensions import cache import server.models as models from server.utils import encode_id, decode_id endpoints = Blueprint('api', __name__) endpoints.config = {} @endpoints.record def record_params(setup_state): """ Load used app configs into local config on registration from server/__init__.py """ app = setup_state.app endpoints.config['tz'] = app.config.get('TIMEZONE', 'utc') # sample config endpoints.config['debug'] = app.debug api = restful.Api(endpoints) API_VERSION = 'v3'
import requests from urllib.request import urlopen from werkzeug import wsgi from flask import Flask, abort, Blueprint, jsonify, render_template, Response, request from flask import redirect, url_for, send_file, current_app from flask.ext.login import login_required, login_user, current_user from flask_wtf import CsrfProtect from rdfframework import RdfProperty, get_framework as rdfw from rdfframework.utilities import render_without_request, code_timer, \ remove_null, pp, clean_iri, uid_to_repo_uri, cbool, make_list from rdfframework.forms import rdf_framework_form_factory from rdfframework.api import rdf_framework_api_factory, Api from rdfframework.security import User base_site = Blueprint("base_site", __name__, template_folder="templates") base_site.config = {} '''@base_site.before_request def before_request(): if request.url.startswith('http://'): url = request.url.replace('http://', 'https://', 1) code = 301 return redirect(url, code=code)''' @base_site.route("/") def home(): print("Current user is {}".format(current_user)) return render_template("index.html") @base_site.route("/tester.html")
from flask_negotiate import produces from flask.ext.login import login_required, login_user, current_user from flask_wtf import CsrfProtect from . import new_badge_class, issue_badge from rdfframework import RdfProperty, get_framework as rdfw from rdfframework.utilities import render_without_request, code_timer, \ remove_null, pp, clean_iri, uid_to_repo_uri, cbool, make_list from rdfframework.forms import rdf_framework_form_factory from rdfframework.api import rdf_framework_api_factory, Api from rdfframework.security import User DEBUG = True open_badge = Blueprint("open_badge", __name__, template_folder="templates") open_badge.config = {} @open_badge.record def record_params(setup_state): """Function takes the setup_state and updates configuration from the active application. Args: setup_state -- Setup state of the application. """ app = setup_state.app open_badge.config = dict( [(key, value) for (key, value) in app.config.items()] )
from flask import abort, Blueprint, flash, jsonify, Markup, redirect, render_template, request, url_for from flask.ext.login import current_user, login_required from .forms import ProjectForm from .models import Project from rndapp.data import query_to_list import config application = Blueprint("application", __name__) application.config = config.ANALYTICS #@application.route("/") #@application.route("/home") #def index(): # return render_template("index.html") @application.route("/") @application.route("/home") def index(): return render_template("comingsoon.html", surpress_rcontent=True) @application.route('/about') def about(): return render_template("about.html") @application.route('/events') def events(): return render_template("events.html") @application.route('/news')
# -*- coding: utf-8 -*- import logging from flask import Blueprint from cassandra.cluster import Cluster from cassandra.cqlengine import connection from cassandra.cqlengine.management import create_keyspace_simple logger = logging.getLogger() db = Blueprint('db', __name__) db.config = {} cluster = None session = None @db.record def record_params(setup_state): app = setup_state.app db.config = dict([(key,value) for (key,value) in app.config.iteritems()]) def init_db_blueprint(): global cluster cluster = Cluster( db.config['CASSANDRA_CONTACT_POINTS'] ) global session
from flask import Blueprint from fhir_server.configs import DefaultConfig api_auth = Blueprint("api_auth", __name__, url_prefix="") api_auth.config = DefaultConfig.OAUTH2_CONFIG from .models import * # noqa from .urls import * # noqa
from flask import render_template, request from .controllers import ChartDisplayController, ChartCreateController, ChartEditController from flask import Blueprint charts = Blueprint('charts', __name__) charts.config = {} @charts.record def record_config(setup_state): config = setup_state.app.config charts.config = config @charts.route('/home') def index(): return render_template("charts/home.html", controller=None) @charts.route('/preview') def preview(): controller = ChartDisplayController() controller.load_demo_plot() return render_template("charts/preview.html", controller=controller) @charts.route('/create', methods=['GET', 'POST']) def create():
import json from flask import jsonify, Blueprint, request, current_app from db.postgres import db from flask_cors import cross_origin from sqlalchemy import Sequence from flask_json_schema import JsonSchema from models.department import Department from models.location import Location from models.category import Category import pdb department_api = Blueprint('department_api', __name__) department_api.config = {} schema = JsonSchema(department_api) @department_api.route("/api/v1/department", methods=['POST']) @cross_origin("*") def create(): try: input_json_data = request.get_json() db.create_all() db.session.commit() if not input_json_data: return {"message": "No input data provided"}, 400 new_category = input_json_data['category'] new_department = input_json_data['department'] department_results = Department.query.filter( Department.department == new_department) # validation of department details
from flask import Blueprint, render_template blueprint = Blueprint('electrostatic', __name__, template_folder='templates', static_folder='static') from instruments import app blueprint.config = app.config['ELECTROSTATIC'] import electrostatic.core LABEL = 'Electrostatic' ICON = 'pencil' def get_admin_panel(): return render_template('electrostatic_admin_panel.html')
from flask import Blueprint from flask_restplus import Resource, Api, reqparse auth_bp = Blueprint('auth', __name__) auth_bp.config = {} auth_api = Api(auth_bp) parser = reqparse.RequestParser() class LoginApi(Resource): def post(self): print('hello') parser.add_argument('email',type=str) parser.add_argument('pasword',type=str) args = parser.parse_args() email = args.get('email',None) password = args.get('password',None) if not email: return {'status': 'success', 'message': 'missing email'}, 200 if not password: return {'status': 'success', 'message': 'missing password'}, 200 def get(self): print('hello') parser.add_argument('email',type=str) parser.add_argument('pasword',type=str) args = parser.parse_args() email = args.get('email',None) password = args.get('password',None)
from flask import request, session, redirect, url_for, \ render_template, flash, Blueprint, g import sqlite3 mainui = Blueprint('mainui', __name__) mainui.config = {} ## Overide to allow access to configuration values @mainui.record def record_params(setup_state): app = setup_state.app mainui.config = dict([(key, value) for (key, value) in app.config.iteritems()]) # Pages @mainui.route('/') def index(): channels = query_db("SELECT * FROM channel_with_category") scenes = query_db("SELECT * FROM scene_with_category") stacks = query_db("SELECT * FROM stack_with_category") bpm = query_db("SELECT value FROM settings WHERE name='bpm'")[0]["value"] fadetime = query_db( "SELECT value FROM settings WHERE name='fadetime'")[0]["value"] return render_template('index.html', channels=channels, scenes=scenes, stacks=stacks, fadetime=fadetime,
"""__init__.py index/ """ from flask import Blueprint index_blueprint = Blueprint( "index", __name__, static_url_path="", static_folder="web/static", template_folder="web/templates", ) index_blueprint.config = {} @index_blueprint.record def record_params(setup_state): app = setup_state.app index_blueprint.config = dict([(key, value) for key, value in app.config.items()]) from . import routes
from flask import Blueprint api = Blueprint('api', 'api', url_prefix='', static_folder='../../instance/dist/static') api.config = {} @api.record def record_params(setup_state): app = setup_state.app api.config = dict([(key, value) for (key, value) in app.config.items()]) from .dataset_api import * from .document_api import * from .project_api import * from .user_api import * from .summary_api import *
try: from flask import Blueprint from flask_sqlalchemy import SQLAlchemy from flask_praetorian import Praetorian from flask_cors import CORS from flask_migrate import Migrate import flask_login except ImportError as IE: print(f"Error importing Models Blueprint: {IE}") # Initializes (routes) blueprint model = Blueprint('model', __name__, None) model.config = {} # Sets DB Terms db = SQLAlchemy() guard = Praetorian() cors = CORS() login_manager = flask_login.LoginManager() try: # Imports model Classes from .user import User from .post import Post from .room import Room from .comment import Comment except Exception as e: print(f"Error loading models: {e}") @model.record
-> app creates interactive message -> 0-n people vote using interactive message buttons -> Votes are closed, scores shown -> * """ import json from urllib.parse import urlparse, parse_qs from pprint import pprint from itertools import islice import slack from flask import Blueprint, current_app, request, g, jsonify bp = Blueprint("poker", __name__, template_folder='templates') bp.config = {} class SlackError(Exception): status_code = 400 def __init__(self, message, status_code=None, payload=None): Exception.__init__(self) self.message = message if status_code is not None: self.status_code = status_code self.payload = payload def to_dict(self): rv = dict(self.payload or ()) rv['message'] = self.message
""" Initialize Flask Blueprint for admin api. """ from flask import Blueprint from flask_restful import Api from .resource.fluency import DatasetsResource, FluencyResource from .resource.clarity import ClarityResource from .resource.fluencylist import FluencyListResource from .resource.claritylist import ClarityListResource from .resource.user import UserResource admin_api = Blueprint('admin_api', __name__, static_folder='../../instance/dist/static') admin_api.config = {} api = Api() api.init_app(admin_api) api.add_resource(DatasetsResource, '/dataset') api.add_resource(FluencyResource, '/fluency', '/fluency/<int:project_id>') api.add_resource(ClarityResource, '/clarity', '/clarity/<int:project_id>') api.add_resource(FluencyListResource, '/fluencylist') api.add_resource(ClarityListResource, '/claritylist') api.add_resource(UserResource, '/login') @admin_api.record def record_params(setup_state): """ Copy flask app config into the api config """ app = setup_state.app
from flask_login import (LoginManager, login_user, logout_user, login_required, current_user) import requests import datetime as dt import logging from server import utils from server.models import db, User, Enrollment, Client, Token, Grant from server.extensions import csrf, oauth_provider, cache logger = logging.getLogger(__name__) auth = Blueprint('auth', __name__) auth.config = {} @auth.record def record_params(setup_state): """ Load used app configs into local config on registration from server/__init__.py """ app = setup_state.app oauth.init_app(app) oauth = OAuth() google_auth = oauth.remote_app( 'google', app_key='GOOGLE', request_token_params={
from threading import Thread import slack from flask import Blueprint, current_app events = Blueprint("events", __name__, template_folder='templates') events.config = {} @events.record def record_slack_config(setup_state): '''make a copy of relevant config upon blueprint register so we don't need to reference current_app''' events.config = { k: v for k, v in setup_state.app.config.get_namespace('COMPUTER_').items() } from computer.slack.route import default_handler, register, EVENT_TYPES def bg_slack(method=None, token=None, **kwargs): print( f'backgrounding task: method={method}, token={"<redacted>" if token else token}, kwargs={kwargs}' ) if not token: token = events.config['slack_oauth_access_token'] def send_slack(token, **kwargs): slackclient = slack.WebClient(token=token) fun = getattr(slackclient, method)
# @Time : 2019/10/23 17:03 # @Author : Wind # @Des : 在蓝图中读取config.py配置信息 # @Des : 蓝图中url_for取函数名时,需要加".",比如url_for('.login'),url_for('.index') # @Software: PyCharm from flask import Blueprint, render_template, redirect, request, session, url_for, g, flash import sqlite3 import config mytest_bp = Blueprint('mytest', __name__, url_prefix='/mytest', template_folder='templates', static_folder='static') mytest_bp.config = config @mytest_bp.before_request def before_request(): g.db = sqlite3.connect(mytest_bp.config.DATABASE) @mytest_bp.teardown_request def teardown_request(exception): db = getattr(g, 'db', None) if db is not None: db.close() @mytest_bp.route('/')
#-*-encoding:utf-8-*- from flask import Flask, request from flask import Blueprint from flask.ext import restful from flask.ext.restful.utils import cors from database import db api = restful.Api() blueprint = Blueprint('hello_blueprint', __name__) api.init_app(blueprint) blueprint.config = {} api.decorators = [cors.crossdomain(origin='*', headers=["Authorization", "Content-Type"])] class UserModule: def __init__(self, *args, **kwargs): if len(args) > 0: url_prefix = kwargs.get('url_prefix', '/api') self.init_app(args[0], url_prefix=url_prefix) def init_app(self, app, url_prefix='/api'): db.init_app(app) app.register_blueprint(blueprint, url_prefix=url_prefix) # Declaração das Rotas da API from users import ListUsersRest
import json from flask import jsonify, Blueprint, request, current_app from db.postgres import db from flask_cors import cross_origin from sqlalchemy import Sequence from flask_json_schema import JsonSchema from models.department import Department from models.location import Location from models.category import Category from models.sub_category import Subcategory import pdb category_api = Blueprint('category_api', __name__) category_api.config = {} schema = JsonSchema(category_api) @category_api.route("/api/v1/category", methods=['POST']) @cross_origin("*") def create(): try: input_json_data = request.get_json() db.create_all() db.session.commit() if not input_json_data: return {"message": "No input data provided"}, 400 new_category = input_json_data['category'] new_subcategory = input_json_data['subcategory'] category_results = Category.query.filter( Category.category == new_category)
# Hope we're not using a swift backend pass from .exceptions import Error, ObjectNotFoundError, \ ObjectAlreadyExistsError, FunctionalityOmittedError, UserError __author__ = "Brian Balsamo" __email__ = "*****@*****.**" __version__ = "0.1.2" BLUEPRINT = Blueprint('archstor', __name__) BLUEPRINT.config = { 'BUFF': 1024 * 1000 } API = Api(BLUEPRINT) log = logging.getLogger(__name__) @BLUEPRINT.errorhandler(Error) def handle_errors(error): response = jsonify(error.to_dict()) response.status_code = error.status_code return response def check_limit(x):
from .exceptions import Error from nothashes import crc32, adler32 import multihash # Add crc32 and adler32 to the multihash interface multihash.additional_hashers.add(crc32) multihash.additional_hashers.add(adler32) __author__ = "Brian Balsamo" __email__ = "*****@*****.**" __version__ = "0.2.2" BLUEPRINT = Blueprint('checksummit', __name__) BLUEPRINT.config = {} API = Api(BLUEPRINT) log = logging.getLogger(__name__) @BLUEPRINT.errorhandler(Error) def handle_errors(error): response = jsonify(error.to_dict()) response.status_code = error.status_code return response class Version(Resource): def get(self):
""" Initialize Flask Blueprint for user api. """ from flask import Blueprint from flask_restful import Api from .resource.fluency import FluencyResource from .resource.clarity import ClarityResource user_api = Blueprint('user_api', __name__, static_folder='../../../instance/dist/static') user_api.config = {} api = Api() api.init_app(user_api) api.add_resource(FluencyResource, '/fluency', '/fluency/<int:project_id>') api.add_resource(ClarityResource, '/clarity', '/clarity/<int:project_id>') @user_api.record def record_params(setup_state): """ Copy flask app config into the api config """ app = setup_state.app user_api.config = dict([(key, value) for (key, value) in app.config.items()])
current_user) import requests import datetime as dt import logging from server import utils from server.models import db, User, Enrollment, Client, Token, Grant from server.extensions import csrf, oauth_provider, cache from server.constants import GOOGLE, MICROSOFT logger = logging.getLogger(__name__) auth = Blueprint('auth', __name__) auth.config = {} provider_auth = None provider_name = None oauth = None @auth.record def record_params(setup_state): """ Load used app configs into local config on registration from server/__init__.py """ global provider_name global provider_auth global oauth oauth = OAuth() app = setup_state.app
from flask import Blueprint, render_template proposals = Blueprint('proposals', __name__, static_folder='../static', template_folder='templates') proposals.config = {} proposals.logger = None
__author__ = 'Administrator' from flask import Blueprint import sys sys.path.append("../..") dataExtract = Blueprint('dataExtract', __name__) dataExtract.config = {} from app_src.dataExtract import views
from urllib.request import urlopen from werkzeug import wsgi from flask import Flask, abort, Blueprint, jsonify, render_template, Response, request from flask import redirect, url_for, send_file, current_app from flask.ext.login import login_required, login_user, current_user from flask_wtf import CsrfProtect from rdfframework import RdfProperty, get_framework as rdfw from rdfframework.utilities import render_without_request, code_timer, \ remove_null, pp, clean_iri, uid_to_repo_uri, cbool, make_list from rdfframework.forms import rdf_framework_form_factory from rdfframework.api import rdf_framework_api_factory, Api from rdfframework.security import User base_site = Blueprint("base_site", __name__, template_folder="templates") base_site.config = {} '''@base_site.before_request def before_request(): if request.url.startswith('http://'): url = request.url.replace('http://', 'https://', 1) code = 301 return redirect(url, code=code)''' @base_site.route("/") def home(): print("Current user is {}".format(current_user)) return render_template( "index.html") @base_site.route("/tester.html")
from urllib.request import urlopen from werkzeug import wsgi from flask import Flask, abort, Blueprint, jsonify, render_template, Response,\ request, redirect, url_for, send_file, current_app from flask.ext.login import login_required, login_user, current_user, \ logout_user from flask_wtf import CsrfProtect from rdfframework import RdfProperty, get_framework as rdfw from rdfframework.utilities import render_without_request, code_timer, \ remove_null, pp, clean_iri, uid_to_repo_uri, cbool, make_list from rdfframework.forms import rdf_framework_form_factory from rdfframework.api import rdf_framework_api_factory, Api from rdfframework.security import User rdfw_core = Blueprint("rdfw_core", __name__, template_folder="templates") rdfw_core.config = {} @rdfw_core.record def record_params(setup_state): """Function takes the setup_state and updates configuration from the active application. Args: setup_state -- Setup state of the application. """ app = setup_state.app rdfw_core.config = dict([(key, value) for (key, value) in app.config.items()])
from flask import redirect, url_for, send_file, current_app from flask_negotiate import produces from flask.ext.login import login_required, login_user, current_user from flask_wtf import CsrfProtect from . import new_badge_class, issue_badge from rdfframework import RdfProperty, get_framework as rdfw from rdfframework.utilities import render_without_request, code_timer, \ remove_null, pp, clean_iri, uid_to_repo_uri, cbool, make_list from rdfframework.forms import rdf_framework_form_factory from rdfframework.api import rdf_framework_api_factory, Api from rdfframework.security import User DEBUG = True open_badge = Blueprint("open_badge", __name__, template_folder="templates") open_badge.config = {} @open_badge.record def record_params(setup_state): """Function takes the setup_state and updates configuration from the active application. Args: setup_state -- Setup state of the application. """ app = setup_state.app open_badge.config = dict([(key, value) for (key, value) in app.config.items()])
from pymongo import MongoClient, ASCENDING from gridfs import GridFS from pypremis.lib import PremisRecord from pypremis.nodes import Event, EventDetailInformation, EventIdentifier from pypremis.factories import LinkingObjectIdentifierFactory, \ LinkingEventIdentifierFactory BLUEPRINT = Blueprint('materialsuite_endpoint', __name__) BLUEPRINT.config = { 'MONGO_LTS_HOST': None, 'MONGO_PREMIS_HOST': None, 'MONGO_LTS_PORT': 27017, 'MONGO_PREMIS_PORT': 27017, 'MONGO_LTS_DB': 'lts', 'MONGO_PREMIS_DB': 'premis', '_LTS_FS': None, '_PREMIS_FS': None } API = Api(BLUEPRINT) log = logging.getLogger(__name__) def check_limit(x): if x > BLUEPRINT.config.get("MAX_LIMIT", 1000): return BLUEPRINT.config.get("MAX_LIMIT", 1000) return x
from flask import flash, redirect, url_for, make_response, current_app from flask.ext.mail import Mail, Message from jinja2 import TemplateNotFound from flask_login import login_required from hawkers.models import User, Hawker, CutOffTime, Food, Order, OrderItem, db from wtforms import form, fields, validators, ValidationError from wtforms_components import TimeField import re, os from werkzeug import secure_filename from werkzeug.security import check_password_hash, generate_password_hash from PIL import Image vendor_page = Blueprint('vendor_page', __name__, template_folder='vendor_templates') # Manage Configurations vendor_page.config = {} @vendor_page.record def record_app_settings(setup_state) : app = setup_state.app vendor_page.mail = Mail(app) vendor_page.config = dict([(key, value) for (key, value) in app.config.items()]) def allowed_file(filename) : ret = '.' in filename and filename.rsplit('.', 1)[1] in ('jpg') return ret # Forms class UserForm(form.Form) : login = fields.TextField('Login Name', [validators.InputRequired(), validators.Length(max=80)]) first_name = fields.TextField('First Name', [validators.InputRequired(), validators.Length(max=100)]) last_name = fields.TextField('Last Name', [validators.InputRequired(), validators.Length(max=100)])
from flask import Blueprint, request, session, redirect, url_for, \ abort, render_template, flash, send_from_directory from decorators import async, ad_login_req import MySQLdb from hashids import Hashids admin = Blueprint('admin', __name__) admin.config = {} ## Overide to allow access to configuration values @admin.record def record_params(setup_state): app = setup_state.app admin.config = dict([(key, value) for (key, value) in app.config.iteritems()]) @admin.route('/') @ad_login_req def admin_main(): return render_template('admin.html') @admin.route('/login', methods=['POST', 'GET']) def admin_login(): if request.method == "POST": username = request.form['username'] password = request.form['password'] if username == admin.config[ 'ADMIN_UNAME'] and password == admin.config['ADMIN_PWORD']:
import os import functools from flask import Blueprint, render_template, flash, redirect, url_for, request from flask.ext.login import current_user REDBERRY_ROOT = os.path.dirname(os.path.realpath(__file__)) cms = Blueprint('redberry', __name__, template_folder='templates', static_folder='static/redberry') cms.config = {'db': None, 'meta': {'title': None}} ############## # Jinja Filters ############### @cms.app_template_filter() def pretty_date(dttm): return dttm.strftime("%m/%d") @cms.app_template_filter() def date(dttm): return dttm.strftime('%Y-%m-%d') ######## # Config ######## # Automatically called once when the Blueprint is registered on the app.
from flask import Blueprint, request # from cerberus import Validator # from admin.exception import BadRequest, YMException main = Blueprint("main", __name__) main.config = {} # @main.record # def record_params(setup_state): # apps = setup_state.apps # main.config = dict([(key, value) for (key, value) in apps.config.items()]) from . import login
import json from flask import jsonify, Blueprint, request, current_app from models.location import Location from db.postgres import db from flask_json_schema import JsonSchema from flask_cors import cross_origin from sqlalchemy import Sequence import pdb location_api = Blueprint('location_api', __name__) location_api.config = {} schema = JsonSchema(location_api) @location_api.route("/api/v1/location", methods=['POST']) @cross_origin("*") def create(): try: input_json_data = request.get_json() if not input_json_data: return {"message": "No input data provided"}, 400 new_location = input_json_data['location'] new_department = input_json_data['department'] location_results = Location.query.filter( Location.location == new_location) # validation of location for temp in location_results: string_val = temp.serialize() if (new_location == string_val.get('location') and new_department == string_val.get('department')):
from functools import wraps from flask import Blueprint, jsonify, request, url_for from flask_login import current_user import flask_restful as restful from flask_restful import reqparse, fields, marshal_with from flask_restful.representations.json import output_json from server.extensions import cache from server.utils import encode_id, decode_id import server.models as models from server.autograder import submit_continous from server.constants import STAFF_ROLES endpoints = Blueprint('api', __name__) endpoints.config = {} @endpoints.record def record_params(setup_state): """ Load used app configs into local config on registration from server/__init__.py """ app = setup_state.app endpoints.config['tz'] = app.config.get('TIMEZONE', 'utc') # sample config endpoints.config['debug'] = app.debug api = restful.Api(endpoints) API_VERSION = 'v3'
from werkzeug import wsgi from flask import Flask, abort, Blueprint, jsonify, render_template, Response,\ request, redirect, url_for, send_file, current_app from flask.ext.login import login_required, login_user, current_user, \ logout_user from flask_wtf import CsrfProtect from rdfframework import RdfProperty, get_framework as rdfw from rdfframework.utilities import render_without_request, code_timer, \ remove_null, pp, clean_iri, uid_to_repo_uri, cbool, make_list from rdfframework.forms import rdf_framework_form_factory from rdfframework.api import rdf_framework_api_factory, Api from rdfframework.security import User rdfw_core = Blueprint("rdfw_core", __name__, template_folder="templates") rdfw_core.config = {} @rdfw_core.record def record_params(setup_state): """Function takes the setup_state and updates configuration from the active application. Args: setup_state -- Setup state of the application. """ app = setup_state.app rdfw_core.config = dict( [(key, value) for (key, value) in app.config.items()] ) DEBUG = True