import logging import os import sys import subprocess import shutil from logging.handlers import RotatingFileHandler from flask import Flask, current_app from config import Config, load_config_file from flask_sqlalchemy import SQLAlchemy from flask_restful import Api, request from flask_jwt_simple import JWTManager from datetime import datetime db = SQLAlchemy() api = None jwt = JWTManager() def create_app(config_name): global api, jwt app = Flask(__name__) app.config.from_object(Config()) load_config_file(app.config, config_name) with app.app_context(): db.init_app(app) db.app = app jwt.init_app(app) api = Api(app) current_app = app
from flask import Flask, abort, jsonify, request, current_app from flask_jwt_simple import JWTManager, jwt_required, create_jwt, get_jwt, get_jwt_identity from psycopg2.pool import ThreadedConnectionPool import config import database application = Flask(__name__) application.config['JWT_SECRET_KEY'] = config.JWT_SECRET_KEY application.config['JWT_ALGORITHM'] = config.JWT_ALGORITHM application.config['JWT_HEADER_NAME'] = config.JWT_HEADER_NAME application.config['JWT_HEADER_TYPE'] = config.JWT_HEADER_TYPE jwt = JWTManager(application) dbPool = ThreadedConnectionPool(0, 5, config.DB_CONNECTION_URL) @application.route('/') def root(): abort(404) @application.route('/api/ping') @jwt_required def ping(): return jsonify(message='pong') @application.route('/api/stations/id/<int:stationId>') @jwt_required def findStationId(stationId):
from datetime import datetime from flask import Flask, request, jsonify, url_for from flask import Flask, jsonify, request from flask_jwt_simple import JWTManager, jwt_required, create_jwt, get_jwt_identity from flask_migrate import Migrate from flask_swagger import swagger from flask_cors import CORS from utils import APIException, generate_sitemap from admin import setup_admin from models import db, User, Medicalstaff, Treatment, Patient, Diagnostic #from models import Person app = Flask(__name__) app.config['JWT_SECRET_KEY'] = 'carenow' jwt = JWTManager(app) app.url_map.strict_slashes = False app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DB_CONNECTION_STRING') app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False MIGRATE = Migrate(app, db) db.init_app(app) CORS(app) setup_admin(app) # Handle/serialize errors like a JSON object @app.errorhandler(APIException) def handle_invalid_usage(error): return jsonify(error.to_dict()), error.status_code
if not os.path.exists(defines.DATA_SAMPLE): os.mkdir(defines.DATA_SAMPLE) db_connection = DbConnection(defines.MONGO_HOST, defines.MONGO_USER, defines.MONGO_PASS, defines.MONGO_DB, defines.MONGO_PORT) params_api = {'upload_folder': 'data', 'db_connection': db_connection} app = Flask(__name__) initialize_directory_data() CORS(app) api = Api(app) app.config["JSON_SORT_KEYS"] = False app.config['JWT_SECRET_KEY'] = defines.SECRET_KEY JWTManager(app) api.add_resource(ResourceChrompack, '/chrompack', methods=['POST'], resource_class_kwargs=params_api) api.add_resource(ResourceHealth, '/health', methods=['GET']) app.run(host=defines.BIOPROCESS_HOST, port=defines.BIOPROCESS_PORT, debug=True)
def create_app( agent, cors_origins: Optional[Union[Text, List[Text]]] = None, auth_token: Optional[Text] = None, jwt_secret: Optional[Text] = None, jwt_method: Optional[Text] = "HS256", ): """Class representing a Rasa Core HTTP server.""" app = Flask(__name__) CORS(app, resources={r"/*": {"origins": "*"}}) cors_origins = cors_origins or [] # Setup the Flask-JWT-Simple extension if jwt_secret and jwt_method: # since we only want to check signatures, we don't actually care # about the JWT method and set the passed secret as either symmetric # or asymmetric key. jwt lib will choose the right one based on method app.config['JWT_SECRET_KEY'] = jwt_secret app.config['JWT_PUBLIC_KEY'] = jwt_secret app.config['JWT_ALGORITHM'] = jwt_method JWTManager(app) if not agent.is_ready(): logger.info("The loaded agent is not ready to be used yet " "(e.g. only the NLU interpreter is configured, " "but no Core model is loaded). This is NOT AN ISSUE " "some endpoints are not available until the agent " "is ready though.") @app.route("/", methods=['GET', 'OPTIONS']) @cross_origin(origins=cors_origins) def hello(): """Check if the server is running and responds with the version.""" return "hello from Rasa Core: " + __version__ @app.route("/version", methods=['GET', 'OPTIONS']) @cross_origin(origins=cors_origins) def version(): """respond with the version number of the installed rasa core.""" return jsonify({ "version": __version__, "minimum_compatible_version": constants.MINIMUM_COMPATIBLE_VERSION }) # <sender_id> can be be 'default' if there's only 1 client @app.route("/conversations/<sender_id>/execute", methods=['POST', 'OPTIONS']) @cross_origin(origins=cors_origins) @requires_auth(app, auth_token) @ensure_loaded_agent(agent) def execute_action(sender_id): request_params = request.get_json(force=True) # we'll accept both parameters to specify the actions name action_to_execute = (request_params.get("name") or request_params.get("action")) policy = request_params.get("policy", None) confidence = request_params.get("confidence", None) verbosity = event_verbosity_parameter(EventVerbosity.AFTER_RESTART) try: out = CollectingOutputChannel() agent.execute_action(sender_id, action_to_execute, out, policy, confidence) # retrieve tracker and set to requested state tracker = agent.tracker_store.get_or_create_tracker(sender_id) state = tracker.current_state(verbosity) return jsonify({"tracker": state, "messages": out.messages}) except ValueError as e: return error(400, "ValueError", e) except Exception as e: logger.error("Encountered an exception while running action '{}'. " "Bot will continue, but the actions events are lost. " "Make sure to fix the exception in your custom " "code.".format(action_to_execute)) logger.debug(e, exc_info=True) return error(500, "ValueError", "Server failure. Error: {}".format(e)) @app.route("/conversations/<sender_id>/tracker/events", methods=['POST', 'OPTIONS']) @cross_origin(origins=cors_origins) @requires_auth(app, auth_token) @ensure_loaded_agent(agent) def append_event(sender_id): """Append a list of events to the state of a conversation""" request_params = request.get_json(force=True) evt = Event.from_parameters(request_params) tracker = agent.tracker_store.get_or_create_tracker(sender_id) verbosity = event_verbosity_parameter(EventVerbosity.AFTER_RESTART) if evt: tracker.update(evt) agent.tracker_store.save(tracker) return jsonify(tracker.current_state(verbosity)) else: logger.warning( "Append event called, but could not extract a " "valid event. Request JSON: {}".format(request_params)) return error( 400, "InvalidParameter", "Couldn't extract a proper event from the request " "body.", { "parameter": "", "in": "body" }) @app.route("/conversations/<sender_id>/tracker/events", methods=['PUT']) @cross_origin(origins=cors_origins) @requires_auth(app, auth_token) @ensure_loaded_agent(agent) def replace_events(sender_id): """Use a list of events to set a conversations tracker to a state.""" request_params = request.get_json(force=True) verbosity = event_verbosity_parameter(EventVerbosity.AFTER_RESTART) tracker = DialogueStateTracker.from_dict(sender_id, request_params, agent.domain.slots) # will override an existing tracker with the same id! agent.tracker_store.save(tracker) return jsonify(tracker.current_state(verbosity)) @app.route("/conversations", methods=['GET', 'OPTIONS']) @cross_origin(origins=cors_origins) @requires_auth(app, auth_token) def list_trackers(): if agent.tracker_store: return jsonify(list(agent.tracker_store.keys())) else: return jsonify([]) @app.route("/conversations/<sender_id>/tracker", methods=['GET', 'OPTIONS']) @cross_origin(origins=cors_origins) @requires_auth(app, auth_token) def retrieve_tracker(sender_id): """Get a dump of a conversations tracker including its events.""" if not agent.tracker_store: return error( 503, "NoTrackerStore", "No tracker store available. Make sure to configure " "a tracker store when starting the server.") # parameters default_verbosity = EventVerbosity.AFTER_RESTART # this is for backwards compatibility if "ignore_restarts" in request.args: ignore_restarts = utils.bool_arg('ignore_restarts', default=False) if ignore_restarts: default_verbosity = EventVerbosity.ALL if "events" in request.args: include_events = utils.bool_arg('events', default=True) if not include_events: default_verbosity = EventVerbosity.NONE verbosity = event_verbosity_parameter(default_verbosity) # retrieve tracker and set to requested state tracker = agent.tracker_store.get_or_create_tracker(sender_id) if not tracker: return error( 503, "NoDomain", "Could not retrieve tracker. Most likely " "because there is no domain set on the agent.") until_time = utils.float_arg('until') if until_time is not None: tracker = tracker.travel_back_in_time(until_time) # dump and return tracker state = tracker.current_state(verbosity) return jsonify(state) @app.route("/conversations/<sender_id>/story", methods=['GET', 'OPTIONS']) @cross_origin(origins=cors_origins) @requires_auth(app, auth_token) def retrieve_story(sender_id): """Get an end-to-end story corresponding to this conversation.""" if not agent.tracker_store: return error( 503, "NoTrackerStore", "No tracker store available. Make sure to configure " "a tracker store when starting the server.") # retrieve tracker and set to requested state tracker = agent.tracker_store.get_or_create_tracker(sender_id) if not tracker: return error( 503, "NoDomain", "Could not retrieve tracker. Most likely " "because there is no domain set on the agent.") until_time = utils.float_arg('until') if until_time is not None: tracker = tracker.travel_back_in_time(until_time) # dump and return tracker state = tracker.export_stories(e2e=True) return state @app.route("/conversations/<sender_id>/respond", methods=['GET', 'POST', 'OPTIONS']) @cross_origin(origins=cors_origins) @requires_auth(app, auth_token) @ensure_loaded_agent(agent) def respond(sender_id): request_params = request_parameters() if 'query' in request_params: message = request_params.pop('query') elif 'q' in request_params: message = request_params.pop('q') else: return error(400, "InvalidParameter", "Missing the message parameter.", { "parameter": "query", "in": "query" }) try: # Set the output channel out = CollectingOutputChannel() # Fetches the appropriate bot response in a json format responses = agent.handle_text(message, output_channel=out, sender_id=sender_id) return jsonify(responses) except Exception as e: logger.exception("Caught an exception during respond.") return error(500, "ActionException", "Server failure. Error: {}".format(e)) @app.route("/conversations/<sender_id>/predict", methods=['POST', 'OPTIONS']) @cross_origin(origins=cors_origins) @requires_auth(app, auth_token) @ensure_loaded_agent(agent) def predict(sender_id): try: # Fetches the appropriate bot response in a json format responses = agent.predict_next(sender_id) responses['scores'] = sorted(responses['scores'], key=lambda k: (-k['score'], k['action'])) return jsonify(responses) except Exception as e: logger.exception("Caught an exception during prediction.") return error(500, "PredictionException", "Server failure. Error: {}".format(e)) @app.route("/conversations/<sender_id>/messages", methods=['POST', 'OPTIONS']) @cross_origin(origins=cors_origins) @requires_auth(app, auth_token) @ensure_loaded_agent(agent) def log_message(sender_id): request_params = request.get_json(force=True) try: message = request_params["message"] except KeyError: message = request_params.get("text") sender = request_params.get("sender") parse_data = request_params.get("parse_data") verbosity = event_verbosity_parameter(EventVerbosity.AFTER_RESTART) # TODO: implement properly for agent / bot if sender != "user": return error( 500, "NotSupported", "Currently, only user messages can be passed " "to this endpoint. Messages of sender '{}' " "can not be handled. ".format(sender), { "parameter": "sender", "in": "body" }) try: usermsg = UserMessage(message, None, sender_id, parse_data) tracker = agent.log_message(usermsg) return jsonify(tracker.current_state(verbosity)) except Exception as e: logger.exception("Caught an exception while logging message.") return error(500, "MessageException", "Server failure. Error: {}".format(e)) @app.route("/model", methods=['POST', 'OPTIONS']) @requires_auth(app, auth_token) @cross_origin(origins=cors_origins) def load_model(): """Loads a zipped model, replacing the existing one.""" if 'model' not in request.files: # model file is missing return error( 400, "InvalidParameter", "You did not supply a model as part of your request.", { "parameter": "model", "in": "body" }) model_file = request.files['model'] logger.info("Received new model through REST interface.") zipped_path = tempfile.NamedTemporaryFile(delete=False, suffix=".zip") zipped_path.close() model_directory = tempfile.mkdtemp() model_file.save(zipped_path.name) logger.debug("Downloaded model to {}".format(zipped_path.name)) zip_ref = zipfile.ZipFile(zipped_path.name, 'r') zip_ref.extractall(model_directory) zip_ref.close() logger.debug("Unzipped model to {}".format( os.path.abspath(model_directory))) domain_path = os.path.join(os.path.abspath(model_directory), "domain.yml") domain = Domain.load(domain_path) ensemble = PolicyEnsemble.load(model_directory) agent.update_model(domain, ensemble, None) logger.debug("Finished loading new agent.") return '', 204 @app.route("/evaluate", methods=['POST', 'OPTIONS']) @requires_auth(app, auth_token) @cross_origin(origins=cors_origins) def evaluate_stories(): import rasa_nlu """Evaluate stories against the currently loaded model.""" tmp_file = rasa_nlu.utils.create_temporary_file(request.get_data(), mode='w+b') use_e2e = utils.bool_arg('e2e', default=False) try: evaluation = test(tmp_file, agent, use_e2e=use_e2e) return jsonify(evaluation) except ValueError as e: return error( 400, "FailedEvaluation", "Evaluation could not be created. Error: {}" "".format(e)) @app.route("/domain", methods=['GET', 'OPTIONS']) @cross_origin(origins=cors_origins) @requires_auth(app, auth_token) @ensure_loaded_agent(agent) def get_domain(): """Get current domain in yaml or json format.""" accepts = request.headers.get("Accept", default="application/json") if accepts.endswith("json"): domain = agent.domain.as_dict() return jsonify(domain) elif accepts.endswith("yml"): domain_yaml = agent.domain.as_yaml() return Response(domain_yaml, status=200, content_type="application/x-yml") else: return error( 406, "InvalidHeader", """Invalid accept header. Domain can be provided as json ("Accept: application/json") or yml ("Accept: application/x-yml"). Make sure you've set the appropriate Accept header.""") @app.route("/finetune", methods=['POST', 'OPTIONS']) @cross_origin(origins=cors_origins) @requires_auth(app, auth_token) @ensure_loaded_agent(agent) def continue_training(): request.headers.get("Accept") epochs = request.args.get("epochs", 30) batch_size = request.args.get("batch_size", 5) request_params = request.get_json(force=True) sender_id = UserMessage.DEFAULT_SENDER_ID try: tracker = DialogueStateTracker.from_dict(sender_id, request_params, agent.domain.slots) except Exception as e: return error(400, "InvalidParameter", "Supplied events are not valid. {}".format(e), { "parameter": "", "in": "body" }) try: # Fetches the appropriate bot response in a json format agent.continue_training([tracker], epochs=epochs, batch_size=batch_size) return '', 204 except Exception as e: logger.exception("Caught an exception during prediction.") return error(500, "TrainingException", "Server failure. Error: {}".format(e)) @app.route("/status", methods=['GET', 'OPTIONS']) @cross_origin(origins=cors_origins) @requires_auth(app, auth_token) def status(): return jsonify({ "model_fingerprint": agent.fingerprint, "is_ready": agent.is_ready() }) @app.route("/predict", methods=['POST', 'OPTIONS']) @requires_auth(app, auth_token) @cross_origin(origins=cors_origins) @ensure_loaded_agent(agent) def tracker_predict(): """ Given a list of events, predicts the next action""" sender_id = UserMessage.DEFAULT_SENDER_ID request_params = request.get_json(force=True) verbosity = event_verbosity_parameter(EventVerbosity.AFTER_RESTART) try: tracker = DialogueStateTracker.from_dict(sender_id, request_params, agent.domain.slots) except Exception as e: return error(400, "InvalidParameter", "Supplied events are not valid. {}".format(e), { "parameter": "", "in": "body" }) policy_ensemble = agent.policy_ensemble probabilities, policy = \ policy_ensemble.probabilities_using_best_policy(tracker, agent.domain) scores = [{ "action": a, "score": p } for a, p in zip(agent.domain.action_names, probabilities)] return jsonify({ "scores": scores, "policy": policy, "tracker": tracker.current_state(verbosity) }) @app.route("/parse", methods=['POST', 'OPTIONS']) @requires_auth(app, auth_token) @cross_origin(origins=cors_origins) @ensure_loaded_agent(agent) def parse(): request_params = request.get_json(force=True) parse_data = agent.interpreter.parse(request_params.get("q")) return jsonify(parse_data) return app
def create_app(testing=False): app = Flask(__name__) app.url_map.strict_slashes = False if testing: app.config['JWT_SECRET_KEY'] = 'dev_asdasd' app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://sample.sqlite' app.config['TESTING'] = True else: app.secret_key = os.environ.get('FLASK_KEY') app.config['JWT_SECRET_KEY'] = os.environ.get('JWT_SECRET_KEY') app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL') app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False MIGRATE = Migrate(app, db) db.init_app(app) CORS(app) jwt = JWTManager(app) SetupAdmin(app) @app.errorhandler(APIException) def handle_invalid_usage(error): return jsonify(error.to_dict()), error.status_code ###################################################################### # Takes in a dictionary with id, role and expiration date in minutes # create_jwt({ 'id': 100, 'role': 'admin', 'exp': 15 }) ###################################################################### @jwt.jwt_data_loader def add_claims_to_access_token(kwargs={}): now = datetime.utcnow() kwargs = kwargs if isinstance(kwargs, dict) else {} id = kwargs.get('id') role = kwargs.get('role', 'invalid') exp = kwargs.get('exp', 15) return { 'exp': now + timedelta(minutes=exp), 'iat': now, 'nbf': now, 'sub': id, 'role': role } # @app.route('/results/tournament/<int:id>') # def get_results(id): # trmnt = Tournaments.query.get( id ) # results = Results.query.filter_by( tournament_id=id ) \ # .order_by( Results.place.asc() ) # template_data = {} # if trmnt: # template_data['trmnt_name'] = trmnt.name # if trmnt.casino: # template_data['casino'] = trmnt.casino.name # if results.count() == 0: # results = False # else: # obj = [] # for x in results: # obj.append({ # 'place': x.place, # 'full_name': x.full_name, # 'winnings': x.winnings, # 'nationality': x.nationality # }) # results = json.dumps(obj) # return render_template('results_table.html', # **template_data, # results = json.dumps(obj) # ) app = sample_methods.attach(app) app = player_methods.attach(app) app = public_methods.attach(app) app = admin_methods.attach(app) return app