def requests():
"""
Get requests or create a new request.
"""
if request.method == 'GET':
# retrieve all requests
requests = map(format_request, query_db(g.db, 'SELECT * FROM request'))
return json.jsonify(list(requests))
# check if we need to create a session
input_data = request.get_json()
if 'session_id' in input_data:
# retrieve the existing session
session_id = input_data['session_id']
session = query_db(g.db,
'SELECT * FROM session WHERE id = ?',
(session_id, ),
single=True)
if session is None:
# need to use a session id for an existing session
abort(400)
if session['status'] != 'open':
# need to use an open session
abort(400)
else:
# create a new session
session_id = insert_db(g.db, 'INSERT INTO session (status) VALUES (?)',
('open', ))
# create the request in the database
request_id = insert_db(
g.db,
'INSERT INTO request (session_id, status, input) VALUES (?, ?, ?)',
(session_id, 'created', input_data['text']))
g.db.commit()
# create the background job and update the request
job = g.queue.enqueue(process_request, request_id)
g.db.execute(
'UPDATE request SET status = \'queued\', job_id = ? WHERE id = ?',
(job.id, request_id))
g.db.commit()
# return the initial request data
return json.jsonify({
'id': request_id,
'job_id': job.id,
'session_id': session_id,
'status': job.get_status(),
'input': {
'text': input_data['text']
},
'output': None
})
def delete_module(mod_id):
"""
Delete a module.
"""
# retrieve the module
module = query_db(g.db,
'SELECT * FROM module WHERE id = ?', (mod_id, ),
single=True)
if module is None:
# module not found
abort(404)
# create a cursor so we can group multiple statements into a transaction
cursor = g.db.cursor()
# remove the module from any requests
cursor.execute('UPDATE request SET module_id = NULL WHERE module_id = ?',
(mod_id, ))
# delete the module
cursor.execute('DELETE FROM module WHERE id = ?', (mod_id, ))
# commit the transaction
g.db.commit()
# return an empty response
return '', 204
def sessions():
"""
Get sessions.
"""
# retrieve all modules
sessions = map(dict, query_db(g.db, 'SELECT * FROM session'))
return json.jsonify(list(sessions))
def get_module(mod_id):
"""
Get a module.
"""
# retrieve the module
module = query_db(g.db,
'SELECT * FROM module WHERE id = ?', (mod_id, ),
single=True)
if module is None:
# module not found
abort(404)
# return the module data
return json.jsonify(dict(module))
def get_request(req_id):
"""
Get a request.
"""
# retrieve the request
request = query_db(g.db,
'SELECT * FROM request WHERE id = ?', (req_id, ),
single=True)
if request is None:
# request not found
abort(404)
# return the request data
return json.jsonify(format_request(request))
def get_session(session_id):
"""
Get a session.
"""
# retrieve the session
session = query_db(
g.db,
'SELECT * FROM session WHERE id = ?',
(session_id, ),
single=True)
if session is None:
# session not found
abort(404)
# return the module data
return json.jsonify(dict(session))
def modules():
"""
Get configured modules.
"""
if request.method == 'GET':
# retrieve all modules
modules = map(dict, query_db(g.db, 'SELECT * FROM module'))
return json.jsonify(list(modules))
# create the module in the database
input_data = request.get_json()
module_id = insert_db(g.db, 'INSERT INTO module (name, url) VALUES (?, ?)',
(input_data['name'], input_data['url']))
g.db.commit()
# return the module data
return json.jsonify({
'id': module_id,
'name': input_data['name'],
'url': input_data['url']
})