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
