def sqlalchemy_provider(app):
oauth = OAuth2Provider(app)
bind_sqlalchemy(oauth, db.session, user=User, token=Token,
client=Client, grant=Grant, current_user=current_user)
return oauth
def __init__(self,
secret_key=settings.SECRET_KEY,
host='127.0.0.1',
port=None,
ssl=None):
app_node = Node(__file__).dir
super(Application, self).__init__(
__name__,
static_folder=settings.STATIC_FOLDER_PATH,
template_folder=settings.HTML_TEMPLATE_PATH,
static_url_path=settings.STATIC_URL_PREFIX,
)
self.scheme = ssl is None and 'http' or 'https'
self.host = host
self.port = int(port or get_free_tcp_port())
self.ssl = ssl
self.config.from_object('oldspeak.settings')
self.app_node = app_node
self.secret_key = os.environ.get('SECRET_KEY')
self.oauth = OAuth2Provider(self)
self.secret_key = secret_key
components = get_server_components()
if not components:
raise RuntimeError('no components found')
for bp in components:
logger.info('registering component {}'.format(bp))
self.register_blueprint(bp)
def default_provider(app):
oauth = OAuth2Provider(app)
@app.before_request
def load_current_user():
# TODO: Find a better way to get userID
user_id = session.user.userId if session else os.getenv(
'ASK_AUTH_USER_ID')
g.user = next(AlexaUser.query(user_id))
@oauth.clientgetter
def get_client(client_id):
logger.debug('get client - client_id: {}\n'.format(client_id))
return next(Client.query(client_id))
@oauth.grantgetter
def get_grant(client_id, code):
logger.debug('get grant - client_id: {} code: {}\n'.format(
client_id, code))
return next(Grant.query(client_id, code))
@oauth.tokengetter
def get_token(access_token=None, refresh_token=None):
if access_token:
logger.debug('get token - access_token: {}\n'.format(access_token))
return next(Token.query(access_token=access_token))
if refresh_token:
return next(Token.query(refresh_token=refresh_token))
return None
@oauth.grantsetter
def set_grant(client_id, code, request, *args, **kwargs):
expires = datetime.utcnow() + timedelta(seconds=120000)
redirect_params = {'code': code['code'], 'state': request.state}
logger.debug('set grant - redirect_params: {}\n'.format(
json.dumps(redirect_params)))
redirect_uri = '{}?{}'.format(request.redirect_uri,
urllib.urlencode(redirect_params))
grant = Grant(
client_id=client_id,
code=code['code'],
redirect_uri=redirect_uri,
scope=' '.join(request.scopes),
userId=g.user.userId,
expires=expires,
)
logger.debug('grant', grant.__dict__)
grant.save()
return grant
@oauth.tokensetter
def set_token(token, request, *args, **kwargs):
logger.debug('set token - user: {}\n'.format(request.user.userId))
tok = Token(**token)
tok.userId = request.user.userId
tok.client_id = request.client.client_id
tok.save()
return tok
return oauth
def cache_provider(app):
oauth = OAuth2Provider(app)
bind_sqlalchemy(oauth, db.session, user=User, token=Token, client=Client)
app.config.update({'OAUTH2_CACHE_TYPE': 'simple'})
bind_cache_grant(app, oauth, current_user)
return oauth
def default_provider(app):
print('default_provider')
oauth = OAuth2Provider(app)
@oauth.clientgetter
def get_client(client_id):
print('get_client')
return Client.query.filter_by(client_id=client_id).first()
@oauth.grantgetter
def get_grant(client_id, code):
print('get_grant')
return Grant.query.filter_by(client_id=client_id, code=code).first()
@oauth.tokengetter
def get_token(access_token=None, refresh_token=None):
print('get_token')
if access_token:
return Token.query.filter_by(access_token=access_token).first()
if refresh_token:
return Token.query.filter_by(refresh_token=refresh_token).first()
return None
@oauth.grantsetter
def set_grant(client_id, code, request, *args, **kwargs):
print('set_grant')
expires = datetime.utcnow() + timedelta(seconds=100)
grant = Grant(
client_id=client_id,
code=code['code'],
redirect_uri=request.redirect_uri,
scope=' '.join(request.scopes),
user_id=g.user.id,
expires=expires,
)
db.session.add(grant)
db.session.commit()
@oauth.tokensetter
def set_token(token, request, *args, **kwargs):
print('set_token')
# In real project, a token is unique bound to user and client.
# Which means, you don't need to create a token every time.
tok = Token(**token)
tok.user_id = request.user.id
tok.client_id = request.client.client_id
db.session.add(tok)
db.session.commit()
@oauth.usergetter
def get_user(username, password, *args, **kwargs):
print('get_user')
# This is optional, if you don't need password credential
# there is no need to implement this method
return User.query.filter_by(username=username).first()
return oauth
def app():
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app_ = Flask(__name__, instance_path=instance_path)
app_.config.update(
CELERY_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND='memory',
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND='cache',
JSONSCHEMAS_URL_SCHEME='http',
SECRET_KEY='CHANGE_ME',
SECURITY_PASSWORD_SALT='CHANGE_ME_ALSO',
SQLALCHEMY_DATABASE_URI=os.environ.get('SQLALCHEMY_DATABASE_URI',
'sqlite:///test.db'),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_ECHO=False,
TESTING=True,
WTF_CSRF_ENABLED=False,
DEPOSIT_SEARCH_API='/api/search',
SECURITY_PASSWORD_HASH='plaintext',
SECURITY_PASSWORD_SCHEMES=['plaintext'],
SECURITY_DEPRECATED_PASSWORD_SCHEMES=[],
OAUTHLIB_INSECURE_TRANSPORT=True,
OAUTH2_CACHE_TYPE='simple',
)
app_.url_map.converters['pid'] = PIDConverter
FlaskCLI(app_)
Babel(app_)
FlaskCeleryExt(app_)
InvenioDB(app_)
Breadcrumbs(app_)
InvenioAccounts(app_)
InvenioAccess(app_)
app_.register_blueprint(accounts_blueprint)
InvenioAssets(app_)
InvenioJSONSchemas(app_)
InvenioSearch(app_)
InvenioRecords(app_)
app_.url_map.converters['pid'] = PIDConverter
InvenioRecordsREST(app_)
InvenioPIDStore(app_)
InvenioIndexer(app_)
InvenioDeposit(app_)
InvenioSearchUI(app_)
InvenioRecordsUI(app_)
InvenioFilesREST(app_)
OAuth2Provider(app_)
InvenioOAuth2Server(app_)
InvenioOAuth2ServerREST(app_)
app_.register_blueprint(oauth2server_settings_blueprint)
InvenioDepositREST(app_)
with app_.app_context():
yield app_
shutil.rmtree(instance_path)
def default_provider(app):
oauth = OAuth2Provider(app)
@oauth.clientgetter
def get_client(client_id):
return Client.query.filter_by(client_id=client_id).first()
@oauth.grantgetter
def get_grant(client_id, code):
return Grant.query.filter_by(client_id=client_id, code=code).first()
@oauth.grantsetter
def set_grant(client_id, code, request, *args, **kwargs):
expires = datetime.utcnow() + timedelta(seconds=100)
grant = Grant(client_id=client_id,
code=code['code'],
redirect_uri=request.redirect_uri,
scope=' '.join(request.scopes),
user_id=g.user,
expires=expires)
db.session.add(grant)
db.session.commit()
@oauth.tokengetter
def get_token(access_token=None, refresh_token=None):
if access_token:
return Token.query.filter_by(access_token=access_token).first()
if refresh_token:
return Token.query.filter_by(refresh_token=refresh_token).first()
return None
@oauth.tokensetter
def set_token(token, request, *args, **kwargs):
expires_in = token.get('expires_in')
expires = datetime.utcnow() + timedelta(seconds=expires_in)
tok = Token(
access_token=token['access_token'],
refresh_token=token['refresh_token'],
token_type=token['token_type'],
scope=token['scope'],
expires=expires,
client_id=request.client.client_id,
user_id=request.user.id,
)
db.session.add(tok)
db.session.commit()
@oauth.usergetter
def get_user(email, password, *args, **kwargs):
user = User.query.filter_by(email=str(email)).first()
if user is not None and user.check_password(password):
# if int(args[1].body['role']) in [role.role_id for role in user.roles]:
return user
return None
return oauth
def create_provider(app):
oauth = OAuth2Provider(app)
@oauth.clientgetter
def get_client(client_id):
return Client.objects(client_id=client_id).first()
@oauth.grantgetter
def get_grant(client_id, code):
return Grant.objects(client_id=client_id, code=code).first()
@oauth.tokengetter
def get_token(access_token=None, refresh_token=None):
if access_token:
return Token.objects(access_token=access_token).first()
if refresh_token:
return Token.objects(refresh_token=refresh_token).first()
return None
@oauth.grantsetter
def set_grant(client_id, code, request, *args, **kwargs):
expires = datetime.utcnow() + timedelta(seconds=100)
grant = Grant(
client_id=client_id,
code=code['code'],
redirect_uri=request.redirect_uri,
scopes=request.scopes,
expires=expires,
)
grant.save()
@oauth.tokensetter
def set_token(token, request, *args, **kwargs):
test = token
print()
tok = Token(access_token=token.get('access_token'),
refresh_token=token.get('refresh_token'),
client_id=request.client.client_id,
scopes=token.scopes,
expires=datetime.utcnow() +
timedelta(seconds=token.get('expires_in')))
tok.save()
@oauth.usergetter
def get_user(username, password, *args, **kwargs):
return User.objects.filter_by(username=username).first()
return oauth
def setup_app(app):
config = MockConfig()
app.config.from_object(config)
db = app.extensions.get('mongoengine')
if not db:
db = MongoEngine(app)
mail = app.extensions.get('mail')
if not mail:
mail = Mail(app)
oauth = app.extensions.get('oauthlib.provider.oauth2')
if not oauth:
oauth = OAuth2Provider(app)
public.app = app
public.db = db
public.mail = mail
public.oauth = oauth
def default_provider(app):
oauth = OAuth2Provider(app)
@oauth.clientgetter
def get_client(client_id):
return Client.query.filter_by(client_id=client_id).first()
@oauth.grantgetter
def get_grant(client_id, code):
return Grant.query.filter_by(client_id=client_id, code=code).first()
@oauth.tokengetter
def get_token(access_token=None):
if access_token:
return Token.query.filter_by(access_token=access_token).first()
return None
@oauth.grantsetter
def set_grant(client_id, code, request, *args, **kwargs):
expires = datetime.utcnow() + timedelta(seconds=GRANT_TOKEN_EXPIRE)
grant = Grant(client_id=client_id,
code=code['code'],
redirect_uri=request.redirect_uri,
_scopes=' '.join(request.scopes),
user_id=g.user.id,
expires=expires)
db.session.add(grant)
db.session.commit()
return grant
@oauth.tokensetter
def set_token(token, request, *args, **kwargs):
expires_in = token.get('expires_in')
expires = datetime.utcnow() + timedelta(seconds=expires_in)
t = Token(access_token=token['access_token'],
refresh_token=token['refresh_token'],
token_type=token['token_type'],
_scopes=token['scope'],
expires=expires,
client_id=request.client.client_id,
user_id=request.user.id)
db.session.add(t)
db.session.commit()
return t
return oauth
def default_provider(app):
oauth = OAuth2Provider(app)
@oauth.clientgetter
def get_client(client_id):
return Client.query.filter_by(client_id=client_id).first()
@oauth.grantgetter
def get_grant(client_id, code):
return Grant.query.filter_by(client_id=client_id, code=code).first()
@oauth.tokengetter
def get_token(access_token=None, refresh_token=None):
if access_token:
return Token.query.filter_by(access_token=access_token).first()
if refresh_token:
return Token.query.filter_by(refresh_token=refresh_token).first()
return None
@oauth.grantsetter
def set_grant(client_id, code, request, *args, **kwargs):
pseudonym = load_current_pseudonym()
expires = datetime.utcnow() + timedelta(seconds=100)
grant = Grant(client_id=client_id,
code=code['code'],
redirect_uri=request.redirect_uri,
scope=' '.join(request.scopes),
user_id=pseudonym.id,
expires=expires)
db.session.add(grant)
db.session.commit()
@oauth.tokensetter
def set_token(token, request, *args, **kwargs):
toks = Token.query.filter_by(client_id=request.client.client_id,
user_id=request.user.id)
# make sure that every client has only one token connected to a user
for t in toks:
db.session.delete(t)
tok = Token(**token)
tok.user_id = request.user.id
tok.client_id = request.client.client_id
db.session.add(tok)
db.session.commit()
return oauth
def init_app(app_):
app_.config.update(
CELERY_ALWAYS_EAGER=False,
CELERY_CACHE_BACKEND="memory",
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND="cache",
JSONSCHEMAS_URL_SCHEME="http",
SECRET_KEY="CHANGE_ME",
SECURITY_PASSWORD_SALT="CHANGE_ME_ALSO",
SQLALCHEMY_DATABASE_URI=os.environ.get("SQLALCHEMY_DATABASE_URI",
"sqlite:///test.db"),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_ECHO=False,
TESTING=True,
WTF_CSRF_ENABLED=False,
DEPOSIT_SEARCH_API="/api/search",
SECURITY_PASSWORD_HASH="plaintext",
SECURITY_PASSWORD_SCHEMES=["plaintext"],
SECURITY_DEPRECATED_PASSWORD_SCHEMES=[],
THEME_SITENAME="Test Site",
OAUTHLIB_INSECURE_TRANSPORT=True,
OAUTH2_CACHE_TYPE="simple",
ACCOUNTS_JWT_ENABLE=False,
# This allows access to files across all of invenio-files-rest
FILES_REST_PERMISSION_FACTORY=lambda *a, **kw: type(
"Allow", (object, ), {"can": lambda self: True})(),
FILES_REST_MULTIPART_CHUNKSIZE_MIN=10,
)
Babel(app_)
FlaskCeleryExt(app_)
Breadcrumbs(app_)
OAuth2Provider(app_)
InvenioDB(app_)
InvenioAccounts(app_)
InvenioAccess(app_)
InvenioIndexer(app_)
InvenioJSONSchemas(app_)
InvenioOAuth2Server(app_)
InvenioPIDStore(app_)
InvenioRecords(app_)
search = InvenioSearch(app_)
search.register_mappings("deposits", "invenio_deposit.mappings")
def init_app(app_):
app_.config.update(
CELERY_ALWAYS_EAGER=True,
CELERY_CACHE_BACKEND='memory',
CELERY_EAGER_PROPAGATES_EXCEPTIONS=True,
CELERY_RESULT_BACKEND='cache',
JSONSCHEMAS_URL_SCHEME='http',
SECRET_KEY='CHANGE_ME',
SECURITY_PASSWORD_SALT='CHANGE_ME_ALSO',
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
SQLALCHEMY_ECHO=False,
TESTING=True,
WTF_CSRF_ENABLED=False,
DEPOSIT_SEARCH_API='/api/search',
SECURITY_PASSWORD_HASH='plaintext',
SECURITY_PASSWORD_SCHEMES=['plaintext'],
SECURITY_DEPRECATED_PASSWORD_SCHEMES=[],
OAUTHLIB_INSECURE_TRANSPORT=True,
OAUTH2_CACHE_TYPE='simple',
ACCOUNTS_JWT_ENABLE=False,
)
Babel(app_)
FlaskCeleryExt(app_)
Breadcrumbs(app_)
OAuth2Provider(app_)
InvenioDB(app_)
InvenioAccounts(app_)
InvenioAccess(app_)
InvenioIndexer(app_)
InvenioJSONSchemas(app_)
InvenioOAuth2Server(app_)
InvenioFilesREST(app_)
InvenioPIDStore(app_)
InvenioRecords(app_)
search = InvenioSearch(app_)
search.register_mappings('deposits', 'invenio_deposit.mappings')
from datetime import datetime, timedelta
from flask import render_template, redirect, jsonify, request, session, url_for
from flask_api.decorators import set_renderers
from flask_api.renderers import HTMLRenderer, BrowsableAPIRenderer
from werkzeug.security import gen_salt
from flask_oauthlib.provider import OAuth2Provider
from fhir_server.configs import db
from . import api_auth, Fhiruser, Client, Grant, Token, current_user
oauth = OAuth2Provider(api_auth)
@api_auth.route("/signup/", methods=("GET", "POST"))
@set_renderers(HTMLRenderer, BrowsableAPIRenderer)
def signup():
if request.method == "POST":
username = request.form.get("username")
secret = request.form.get("password")
confirm_secret = request.form.get("password_confirm")
fname = request.form.get("fname")
lname = request.form.get("lname")
email = request.form.get("email")
user = Fhiruser.query.filter_by(username=username).first()
if user:
msg = "Username is already registered"
return render_template("register.html", msg=msg)
elif secret != confirm_secret:
msg = "Passwords do not match"
def __init__(self, root_path, template_folders, **kwargs):
"""
work with Flask constructor args
"""
AdminIndexView = kwargs.get('admin_index_view', None)
try:
del kwargs['admin_index_view']
except:
pass
"""
app
"""
Flask.__init__(self, __name__, **kwargs)
base.app = self
base.app.root_path = root_path
self.config.from_envvar('SETTINGS')
self.secret_key = 'super secret key'
"""
set custom jinja loader
"""
tfs = [base.app.jinja_loader]
for tf in template_folders:
tfs.append(jinja2.FileSystemLoader(tf))
loader = jinja2.ChoiceLoader(tfs)
base.app.jinja_loader = loader
"""
cors
"""
CORS(self,
resources={
r"/v2/*": {
"origins": "*"
},
r"/api/*": {
"origins": "*"
},
r"/spec": {
"origins": "*"
},
})
"""
collect
"""
Collect(base.app)
"""
sqlalchemy
"""
base.db = SQLAlchemy(base.app)
"""
migrate
"""
Migrate(base.app, base.db)
"""
DebugToolbar
"""
if base.app.config.get('DEBUG', False):
DebugToolbarExtension(base.app)
"""
admin
"""
if not AdminIndexView:
from .admin_index_view import AdminIndexView
base_url = self.config.get('FLASK_ADMIN_URL', '/admin')
base.admin = Admin(
self,
url=base_url,
name=self.config.get('APPNAME', 'flask app'),
template_mode='bootstrap3',
base_template='admin/base_.html',
index_view=AdminIndexView(url=base_url),
)
"""
swagger
"""
from .swagger import get_swaggerui_blueprint
from flask_swagger import swagger
SWAGGER_URL = self.config.get('SWAGGER_URL', '/api/docs')
API_URL = '/spec'
swaggerui_blueprint = get_swaggerui_blueprint(
SWAGGER_URL,
API_URL,
config={ # Swagger UI config overrides
'app_name': '%s API' % self.config.get('APPNAME', 'flask app'),
},
oauth_config={
'clientId': "swagger",
}
)
self.register_blueprint(swaggerui_blueprint, url_prefix=SWAGGER_URL)
@self.route("/spec")
def spec():
swag = swagger(self)
swag_from_file = yaml.load(open('./swagger/spec.yaml'))
swag.update(swag_from_file)
return jsonify(swag)
"""
internal blueprint
"""
base.internal_bp = Blueprint('internal', 'internal_bp')
"""
oauth
"""
from flask_oauthlib.provider import OAuth2Provider
base.oauth = OAuth2Provider(self)
from . import oauth
"""
flask login
"""
from .models import session, User, Role
user_datastore = SQLAlchemySessionUserDatastore(session, User, Role)
security = Security(self, user_datastore)
"""
modules
"""
from . import views, admins
self.register_blueprint(base.internal_bp,
url_prefix=base.app.config.get(
'CANTEEN_URL_PREFIX', ''))
from flask_weixinapi import WeixinAPI
from flask_yixin import Yixin
from flask_zslib import ZhongshanSecurities
from flask_zwlib import Zhiwang
from flask_xmlib import XinMi
from flask_sxblib import Sxb
from raven.contrib.flask import Sentry
from yxpay.ext.flask import YixinPay
from zslib.signals import debug_message_sent
from .compat.weixin_oauth import fixup_weixin_oauth
sentry = Sentry()
mako = MakoTemplates()
oauth = OAuth()
oauth_provider = OAuth2Provider()
limiter = Limiter()
seasurf = SeaSurf()
yixin = Yixin()
yxpay = YixinPay()
zslib = ZhongshanSecurities()
zhiwang = Zhiwang()
xinmi = XinMi()
sxb = Sxb()
weixin_api = WeixinAPI()
weixin = oauth.remote_app(
'weixin',
app_key='WEIXIN',
request_token_params={'scope': 'snsapi_base'},
base_url='https://api.weixin.qq.com',
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_oauthlib.provider import OAuth2Provider
from .confs import Core
db = SQLAlchemy()
oauth = OAuth2Provider()
def create_app():
print("Creating App")
app = Flask(__name__)
app.config.from_object(Core)
db.init_app(app)
oauth.init_app(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .api import api as api_blueprint
app.register_blueprint(api_blueprint)
return app
def create_server(app):
app = prepare_app(app)
oauth = OAuth2Provider(app)
@oauth.clientgetter
def get_client(client_id):
return Client.query.filter_by(client_id=client_id).first()
@oauth.grantgetter
def get_grant(client_id, code):
return Grant.query.filter_by(client_id=client_id, code=code).first()
@oauth.tokengetter
def get_token(access_token=None, refresh_token=None):
if access_token:
return Token.query.filter_by(access_token=access_token).first()
if refresh_token:
return Token.query.filter_by(refresh_token=refresh_token).first()
return None
@oauth.grantsetter
def set_grant(client_id, code, request, *args, **kwargs):
expires = datetime.datetime.utcnow() + datetime.timedelta(seconds=100)
grant = Grant(
client_id=client_id,
code=code['code'],
redirect_uri=request.redirect_uri,
scope=' '.join(request.scopes),
user_id=g.user.id,
expires=expires,
)
db.session.add(grant)
db.session.commit()
@oauth.tokensetter
def set_token(token, request, *args, **kwargs):
# In real project, a token is unique bound to user and client.
# Which means, you don't need to create a token every time.
tok = Token(**token)
tok.user_id = request.user.id
tok.client_id = request.client.client_id
db.session.add(tok)
db.session.commit()
@oauth.usergetter
def get_user(username, password, *args, **kwargs):
# This is optional, if you don't need password credential
# there is no need to implement this method
return User.query.get(1)
@app.before_request
def load_current_user():
user = User.query.get(1)
g.user = user
@app.route('/home')
def home():
return render_template('home.html')
@app.route('/oauth/authorize', methods=['GET', 'POST'])
@oauth.authorize_handler
def authorize(*args, **kwargs):
# NOTICE: for real project, you need to require login
if request.method == 'GET':
# render a page for user to confirm the authorization
return render_template('confirm.html')
confirm = request.form.get('confirm', 'no')
return confirm == 'yes'
@app.route('/oauth/access_token')
@oauth.access_token_handler
def access_token():
return {}
@app.route('/oauth/refresh_token')
@oauth.refresh_token_handler
def refresh_token():
return {}
@app.route('/api/email')
@oauth.require_oauth(['email'])
def email(data):
return jsonify(email='*****@*****.**', username=data.user.username)
@app.route('/api/address')
@oauth.require_oauth(['address'])
def address(data):
return jsonify(address='earth', username=data.user.username)
return app
from flask_oauthlib.provider import OAuth2Provider from flask import current_app oauth = OAuth2Provider(current_app)
'sqlite:///example.db'),
I18N_LANGUAGES=[
('de', 'German'),
('es', 'Spanish'),
('fr', 'French'),
('it', 'Italian'),
],
)
InvenioAssets(app)
InvenioTheme(app)
InvenioI18N(app)
Breadcrumbs(app)
InvenioDB(app)
InvenioAdmin(app)
InvenioAccess(app)
OAuth2Provider(app)
InvenioOAuth2ServerREST(app)
accounts = InvenioAccountsUI(app)
InvenioAccountsREST(app)
app.register_blueprint(blueprint_account)
InvenioOAuth2Server(app)
# Register blueprints
app.register_blueprint(settings_blueprint)
app.register_blueprint(server_blueprint)
app.register_blueprint(blueprint_admin_ui)
with app.app_context():
# Register a test scope
from flask import Blueprint
from flask_oauthlib.provider import OAuth2Provider
oauth = Blueprint('oauth',
__name__,
template_folder='templates',
static_folder='static')
"""OAuth2 provider blueprint."""
provider = OAuth2Provider()
"""OAuth2 provider."""
from . import views # nopep8
# coding: utf-8 from flask import Flask from flask_oauthlib.provider import OAuth2Provider oauth_provider = Flask(__name__, template_folder='templates') oauth = OAuth2Provider(oauth_provider)
lstm_ner_model = load_lstm_model(model_dir=os.path.join(
os.path.dirname(__file__),
os.path.join("LSTMExec", "models", "i2b2_fh_50_newlines")))
crf_ner_model = joblib.load(
os.path.join(
os.path.dirname(__file__),
os.path.join("NERResources", "Models",
"model-test_problem_treatment_.pk1")))
models = {
"crf_ner": crf_ner_model,
"lstm_ner": lstm_ner_model,
"spacy": spacy_model
}
app = Flask(__name__)
oauth = OAuth2Provider(app)
#################
### Endpoints ###
#################
@app.route('/ner/<string:alg_type>', methods=['GET'])
def ner_pipeline(alg_type):
documents = request.json
if documents:
json_response = ner.main(documents, alg_type, models)
return json_response.encode('utf-8')
else:
return make_response(jsonify({'error': 'No data provided'}), 400)
def __init__(self):
self._activeModel = None
_apiEndpoints = Blueprint(__name__, 'api')
self._apiEndpoints = _apiEndpoints
oauth = OAuth2Provider(self._apiEndpoints)
@_apiEndpoints.route(
'/api/recommendation/<int:userId>/<int:numberOfItem>',
methods=['GET'])
def getProductRecommendationForUser(userId, numberOfItem):
# Call model & feed the recommendation here
global activeModel
return jsonify(activeModel.predictForUser(userId, numberOfItem))
@_apiEndpoints.route('/api/users', methods=['GET'])
@require_oauth('manager')
def getUsers():
# Call model & feed the recommendation here
global activeModel
return jsonify(activeModel.getPredictableUsers())
@_apiEndpoints.route('/api/models', methods=['GET'])
@require_oauth('manager')
def getSupportedModels():
# Call model & feed the recommendation here
return str('NeuMFModel, NCFModel')
# operation in [train, active...]
# model in [NeuFM, MF...]
@_apiEndpoints.route('/api/models/<operation>/<model>',
methods=['POST'])
@require_oauth('manager')
def operateOnModel(operation, model):
# Call model & feed the recommendation here
data = request.json
global activeModel
if operation == 'active':
activeModel = getModelByName(model)
activeModel.restoreFromLatestCheckPoint()
return {'result': 'ok', 'active model': model}
elif operation == 'train':
trainingModel = getModelByName(model)
if not trainingModel.readyToTrain():
return {
'result': 'error',
'message': 'model not ready to train'
}
return trainingModel.train(data['path'], data['rowLimit'], {})
return 'Triggered operation {} on {} model without specific return value'.format(
operation, model)
def getModelByName(model: str) -> RModel:
if model == 'NeuMFModel':
return NeuMFModel()
if model == 'NCFModel':
return NCFModel()
return None
