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