2408

pending completion

Build # 2408

Build Type

Pull #806

travis-ci-com

Committed by

web-flow

Commit Message

Merge df6dcbc61 into 5ada1275a

Pull Request Pull Request #806: Wip/translation api

Run Details

10160 of 20584 branches covered (49.36%)

Branch coverage included in aggregate %.

13 of 62 new or added lines in 5 files covered. (20.97%)

2 existing lines in 1 file now uncovered.

24328 of 40788 relevant lines covered (59.64%)

377924.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

17.83

/tool/server.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of Genie
//
// Copyright 2020 The Board of Trustees of the Leland Stanford Junior University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>

import * as argparse from 'argparse';
import express from 'express';
import bodyParser from 'body-parser';
// FIXME
//import logger from 'morgan';
import errorhandler from 'errorhandler';
import * as qv from 'query-validation';
import * as Tp from 'thingpedia';
import * as ThingTalk from 'thingtalk';

import * as Utils from '../lib/utils/misc-utils';
import { EntityMap } from '../lib/utils/entity-utils';
import LocalParserClient from '../lib/prediction/localparserclient';
import * as I18n from '../lib/i18n';
import {GENERATION_OPTIONS} from "../lib/prediction/types";

interface Backend {
    schemas : ThingTalk.SchemaRetriever;
    i18n : I18n.LanguagePack;
    tokenizer : I18n.BaseTokenizer;
    nlu : LocalParserClient;
    nlg ?: LocalParserClient;
    translator ?: LocalParserClient;
}

declare global {
    namespace Express {
        interface Application {
            backend : Backend;
            args : any;
        }
    }
}

function learn(req : express.Request, res : express.Response) {
    res.status(501).json({ error: 'Learning is not available with this Genie server' });
}

interface TokenizeData {
    q : string;
    entities ?: EntityMap;
    expect ?: string;
}

async function tokenize(params : Record<string, string>, data : TokenizeData, res : express.Response) {
    const app = res.app;
    if (params.locale !== app.args.locale) {
        res.status(404).json({ error: 'Unsupported language' });
        return;
    }

    const tokenized = await app.backend.tokenizer.tokenize(data.q);
    if (data.entities)
        Utils.renumberEntities(tokenized, data.entities);

    res.json(tokenized);
}

interface QueryNLUData {
    q : string;
    store ?: string;
    access_token ?: string;
    thingtalk_version ?: string;
    limit ?: string;
    expect ?: string;
    choices ?: string[];
    context ?: string;
    entities ?: EntityMap;
    tokenized ?: boolean;
    skip_typechecking ?: boolean;
    developer_key ?: string;
}
const QUERY_PARAMS = {
    q: 'string',
    store: '?string',
    access_token: '?string',
    thingtalk_version: '?string',
    limit: '?integer',
    expect: '?string',
    choices: '?array',
    context: '?string',
    entities: '?object',
    tokenized: 'boolean',
    skip_typechecking: 'boolean',
    developer_key: '?string',
};

async function queryNLU(params : Record<string, string>,
                        data : QueryNLUData,
                        res : express.Response) {
    const app = res.app;

    if (params.locale !== app.args.locale) {
        res.status(400).json({ error: 'Unsupported language' });
        return;
    }

    const result = await res.app.backend.nlu.sendUtterance(data.q,
        data.context ? data.context.split(' ') : undefined, data.entities, data);
    res.json(result);
}

interface QueryNLGData {
    context : string;
    entities : EntityMap;
    target : string;
    limit ?: string;
}
const NLG_PARAMS = {
    context: 'string',
    entities: 'object',
    target: 'string',
    limit: '?number',
};

async function queryNLG(params : Record<string, string>,
                        data : QueryNLGData,
                        res : express.Response) {
    const app = res.app;

    if (params.locale !== app.args.locale) {
        res.status(400).json({ error: 'Unsupported language' });
        return;
    }

    const result = await res.app.backend.nlg!.generateUtterance(
        data.context.split(' '), data.entities, data.target.split(' '));
    res.json({
         candidates: result.slice(0, data.limit ? parseInt(data.limit) : undefined),
    });
}


interface TranslationData {
    input : string;
    tgt_locale : string
    entities ?: string[];
    limit ?: string;
    alignment ?: boolean;
    src_locale ?: string;
    align_remove_output_quotation ?: boolean
}
const Translation_PARAMS = {
    input: 'string',
    tgt_locale: 'string',
    entities: '?array',
    limit: '?number',
    alignment: '?boolean',
    src_locale: '?string',
    align_remove_output_quotation: '?boolean'
};

async function queryTranslate(params : Record<string, string>,
                            data : TranslationData,
                            res : express.Response) {
    const app = res.app;

    if (params.locale !== app.args.locale) {
        res.status(400).json({ error: 'Unsupported language' });
        return;
    }

    if (!data.src_locale)
        data.src_locale = 'en-US';

    const generationOptions : GENERATION_OPTIONS = {
        'src_locale': data.src_locale,
        'tgt_locale': data.tgt_locale,
        'do_alignment': data.alignment,
        'align_remove_output_quotation': data.align_remove_output_quotation,

    };

    const result = await res.app.backend.translator!.translateUtterance(
        data.input.split(' '), data.entities, generationOptions);
    res.json({
        candidates: result.slice(0, data.limit ? parseInt(data.limit) : undefined),
    });
}



export function initArgparse(subparsers : argparse.SubParser) {
    const parser = subparsers.add_parser('server', {
        add_help: true,
        description: "Expose a Genie-compatible NLP API over HTTP."
    });
    parser.add_argument('-p', '--port', {
        required: false,
        help: "HTTP port to listen on",
        default: 8400,
    });
    parser.add_argument('--nlu-model', {
        required: false,
        help: "Path to the NLU model, pointing to a model directory.",
    });
    parser.add_argument('--nlg-model', {
        required: false,
        help: "Path to the NLG model, pointing to a model directory.",
    });
    parser.add_argument('--translation-model', {
        required: false,
        help: "Path to the Translation model, pointing to a model directory.",
    });
    parser.add_argument('--thingpedia', {
        required: true,
        help: 'Path to ThingTalk file containing class definitions.'
    });
    parser.add_argument('-l', '--locale', {
        required: false,
        default: 'en-US',
        help: `BGP 47 locale tag of the language to evaluate (defaults to 'en-US', English)`
    });
    parser.add_argument('--debug', {
        action: 'store_true',
        help: 'Enable debugging.',
        default: true
    });
    parser.add_argument('--no-debug', {
        action: 'store_false',
        dest: 'debug',
        help: 'Disable debugging.',
    });
}

export async function execute(args : any) {
    const tpClient = new Tp.FileClient(args);
    const schemas = new ThingTalk.SchemaRetriever(tpClient, null, true);
    const app = express();

    const i18n = I18n.get(args.locale);
    app.backend = {
        schemas,
        i18n,
        tokenizer: i18n.getTokenizer(),
        nlu: new LocalParserClient(args.nlu_model, args.locale, undefined, undefined, tpClient)
    };

    if (args.nlu_model)
        app.backend.nlu.start();
    if (args.nlg_model && args.nlg_model !== args.nlu_model) {
        app.backend.nlg = new LocalParserClient(args.nlg_model, args.locale, undefined, undefined, tpClient);
        app.backend.nlg.start();
    } else {
        app.backend.nlg = app.backend.nlu;
    }

    if (args.translation_model) {
        app.backend.translator = new LocalParserClient(args.translation_model, args.locale, undefined, undefined, tpClient);
        app.backend.translator.start();
    }

    app.args = args;

    app.set('port', args.port);
    app.use(bodyParser.json());
    app.use(bodyParser.urlencoded({ extended: true }));
    //app.use(logger('dev'));

    app.use((req, res, next) => {
        res.set('Access-Control-Allow-Origin', '*');
        next();
    });

    app.post('/:locale/query', qv.validatePOST(QUERY_PARAMS, { accept: 'application/json' }), (req, res, next) => {
        queryNLU(req.params, req.body, res).catch(next);
    });

    app.post('/:locale/answer', qv.validatePOST(NLG_PARAMS, { accept: 'application/json' }), (req, res, next) => {
        queryNLG(req.params, req.body, res).catch(next);
    });

    app.post('/:locale/translate', qv.validatePOST(Translation_PARAMS, { accept: 'application/json' }), (req, res, next) => {
        queryTranslate(req.params, req.body, res).catch(next);
    });

    app.post('/:locale/tokenize', qv.validatePOST({ q: 'string', entities: '?object' }, { accept: 'application/json' }), (req, res, next) => {
        tokenize(req.params, req.body, res).catch(next);
    });

    app.post('/:locale/learn', learn);

    // if we get here, we have a 404 error
    app.use('/', (req, res) => {
        res.status(404).json({ error: 'Invalid endpoint' });
    });
    app.use(errorhandler());

    const server = app.listen(app.get('port'));

    await new Promise((resolve, reject) => {
        process.on('SIGINT', resolve);
        process.on('SIGTERM', resolve);
    });

    if (app.backend.nlu)
        await app.backend.nlu.stop();
    if (app.backend.nlg !== app.backend.nlu)
        await app.backend.nlg.stop();
    if (app.backend.translator)
        await app.backend.translator.stop();
    server.close();
}

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of Genie
4	//
5	// Copyright 2020 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19	// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
20
21	import * as argparse from 'argparse';
22	import express from 'express';	88✔
23	import bodyParser from 'body-parser';	88✔
24	// FIXME
25	//import logger from 'morgan';
26	import errorhandler from 'errorhandler';	88✔
27	import * as qv from 'query-validation';	88✔
28	import * as Tp from 'thingpedia';	88✔
29	import * as ThingTalk from 'thingtalk';	88✔
30
31	import * as Utils from '../lib/utils/misc-utils';	88✔
32	import { EntityMap } from '../lib/utils/entity-utils';
33	import LocalParserClient from '../lib/prediction/localparserclient';	88✔
34	import * as I18n from '../lib/i18n';	88✔
35	import {GENERATION_OPTIONS} from "../lib/prediction/types";
36
37	interface Backend {
38	schemas : ThingTalk.SchemaRetriever;
39	i18n : I18n.LanguagePack;
40	tokenizer : I18n.BaseTokenizer;
41	nlu : LocalParserClient;
42	nlg ?: LocalParserClient;
43	translator ?: LocalParserClient;
44	}
45
46	declare global {
47	namespace Express {
48	interface Application {
49	backend : Backend;
50	args : any;
51	}
52	}
53	}
54
55	function learn(req : express.Request, res : express.Response) {
56	res.status(501).json({ error: 'Learning is not available with this Genie server' });	×
57	}
58
59	interface TokenizeData {
60	q : string;
61	entities ?: EntityMap;
62	expect ?: string;
63	}
64
65	async function tokenize(params : Record<string, string>, data : TokenizeData, res : express.Response) {
66	const app = res.app;	×
67	if (params.locale !== app.args.locale) {	×
68	res.status(404).json({ error: 'Unsupported language' });	×
69	return;	×
70	}
71
72	const tokenized = await app.backend.tokenizer.tokenize(data.q);	×
73	if (data.entities)	×
74	Utils.renumberEntities(tokenized, data.entities);	×
75
76	res.json(tokenized);	×
77	}
78
79	interface QueryNLUData {
80	q : string;
81	store ?: string;
82	access_token ?: string;
83	thingtalk_version ?: string;
84	limit ?: string;
85	expect ?: string;
86	choices ?: string[];
87	context ?: string;
88	entities ?: EntityMap;
89	tokenized ?: boolean;
90	skip_typechecking ?: boolean;
91	developer_key ?: string;
92	}
93	const QUERY_PARAMS = {	88✔
94	q: 'string',
95	store: '?string',
96	access_token: '?string',
97	thingtalk_version: '?string',
98	limit: '?integer',
99	expect: '?string',
100	choices: '?array',
101	context: '?string',
102	entities: '?object',
103	tokenized: 'boolean',
104	skip_typechecking: 'boolean',
105	developer_key: '?string',
106	};
107
108	async function queryNLU(params : Record<string, string>,
109	data : QueryNLUData,
110	res : express.Response) {
111	const app = res.app;	×
112
113	if (params.locale !== app.args.locale) {	×
114	res.status(400).json({ error: 'Unsupported language' });	×
115	return;	×
116	}
117
118	const result = await res.app.backend.nlu.sendUtterance(data.q,	×
119	data.context ? data.context.split(' ') : undefined, data.entities, data);	×
120	res.json(result);	×
121	}
122
123	interface QueryNLGData {
124	context : string;
125	entities : EntityMap;
126	target : string;
127	limit ?: string;
128	}
129	const NLG_PARAMS = {	88✔
130	context: 'string',
131	entities: 'object',
132	target: 'string',
133	limit: '?number',
134	};
135
136	async function queryNLG(params : Record<string, string>,
137	data : QueryNLGData,
138	res : express.Response) {
139	const app = res.app;	×
140
141	if (params.locale !== app.args.locale) {	×
142	res.status(400).json({ error: 'Unsupported language' });	×
143	return;	×
144	}
145
146	const result = await res.app.backend.nlg!.generateUtterance(	×
147	data.context.split(' '), data.entities, data.target.split(' '));
148	res.json({	×
149	candidates: result.slice(0, data.limit ? parseInt(data.limit) : undefined),	×
150	});
151	}
152
153
154	interface TranslationData {
155	input : string;
156	tgt_locale : string
157	entities ?: string[];
158	limit ?: string;
159	alignment ?: boolean;
160	src_locale ?: string;
161	align_remove_output_quotation ?: boolean
162	}
163	const Translation_PARAMS = {	88✔
164	input: 'string',
165	tgt_locale: 'string',
166	entities: '?array',
167	limit: '?number',
168	alignment: '?boolean',
169	src_locale: '?string',
170	align_remove_output_quotation: '?boolean'
171	};
172
173	async function queryTranslate(params : Record<string, string>,
174	data : TranslationData,
175	res : express.Response) {
NEW 176	const app = res.app;	×
177
NEW 178	if (params.locale !== app.args.locale) {	×
NEW 179	res.status(400).json({ error: 'Unsupported language' });	×
NEW 180	return;	×
181	}
182
NEW 183	if (!data.src_locale)	×
NEW 184	data.src_locale = 'en-US';	×
185
NEW 186	const generationOptions : GENERATION_OPTIONS = {	×
187	'src_locale': data.src_locale,
188	'tgt_locale': data.tgt_locale,
189	'do_alignment': data.alignment,
190	'align_remove_output_quotation': data.align_remove_output_quotation,
191
192	};
193
NEW 194	const result = await res.app.backend.translator!.translateUtterance(	×
195	data.input.split(' '), data.entities, generationOptions);
NEW 196	res.json({	×
197	candidates: result.slice(0, data.limit ? parseInt(data.limit) : undefined),	×
198	});
199	}
200
201
202
203	export function initArgparse(subparsers : argparse.SubParser) {	88✔
204	const parser = subparsers.add_parser('server', {	88✔
205	add_help: true,
206	description: "Expose a Genie-compatible NLP API over HTTP."
207	});
208	parser.add_argument('-p', '--port', {	88✔
209	required: false,
210	help: "HTTP port to listen on",
211	default: 8400,
212	});
213	parser.add_argument('--nlu-model', {	88✔
214	required: false,
215	help: "Path to the NLU model, pointing to a model directory.",
216	});
217	parser.add_argument('--nlg-model', {	88✔
218	required: false,
219	help: "Path to the NLG model, pointing to a model directory.",
220	});
221	parser.add_argument('--translation-model', {	88✔
222	required: false,
223	help: "Path to the Translation model, pointing to a model directory.",
224	});
225	parser.add_argument('--thingpedia', {	88✔
226	required: true,
227	help: 'Path to ThingTalk file containing class definitions.'
228	});
229	parser.add_argument('-l', '--locale', {	88✔
230	required: false,
231	default: 'en-US',
232	help: `BGP 47 locale tag of the language to evaluate (defaults to 'en-US', English)`
233	});
234	parser.add_argument('--debug', {	88✔
235	action: 'store_true',
236	help: 'Enable debugging.',
237	default: true
238	});
239	parser.add_argument('--no-debug', {	88✔
240	action: 'store_false',
241	dest: 'debug',
242	help: 'Disable debugging.',
243	});
244	}
245
246	export async function execute(args : any) {	88✔
247	const tpClient = new Tp.FileClient(args);	×
248	const schemas = new ThingTalk.SchemaRetriever(tpClient, null, true);	×
249	const app = express();	×
250
251	const i18n = I18n.get(args.locale);	×
252	app.backend = {	×
253	schemas,
254	i18n,
255	tokenizer: i18n.getTokenizer(),
256	nlu: new LocalParserClient(args.nlu_model, args.locale, undefined, undefined, tpClient)
257	};
258
NEW 259	if (args.nlu_model)	×
NEW 260	app.backend.nlu.start();	×
261	if (args.nlg_model && args.nlg_model !== args.nlu_model) {	×
262	app.backend.nlg = new LocalParserClient(args.nlg_model, args.locale, undefined, undefined, tpClient);	×
263	app.backend.nlg.start();	×
264	} else {
265	app.backend.nlg = app.backend.nlu;	×
266	}
267
NEW 268	if (args.translation_model) {	×
NEW 269	app.backend.translator = new LocalParserClient(args.translation_model, args.locale, undefined, undefined, tpClient);	×
NEW 270	app.backend.translator.start();	×
271	}
272
UNCOV 273	app.args = args;	×
274
275	app.set('port', args.port);	×
276	app.use(bodyParser.json());	×
277	app.use(bodyParser.urlencoded({ extended: true }));	×
278	//app.use(logger('dev'));
279
280	app.use((req, res, next) => {	×
281	res.set('Access-Control-Allow-Origin', '*');	×
282	next();	×
283	});
284
285	app.post('/:locale/query', qv.validatePOST(QUERY_PARAMS, { accept: 'application/json' }), (req, res, next) => {	×
286	queryNLU(req.params, req.body, res).catch(next);	×
287	});
288
289	app.post('/:locale/answer', qv.validatePOST(NLG_PARAMS, { accept: 'application/json' }), (req, res, next) => {	×
290	queryNLG(req.params, req.body, res).catch(next);	×
291	});
292
NEW 293	app.post('/:locale/translate', qv.validatePOST(Translation_PARAMS, { accept: 'application/json' }), (req, res, next) => {	×
NEW 294	queryTranslate(req.params, req.body, res).catch(next);	×
295	});
296
297	app.post('/:locale/tokenize', qv.validatePOST({ q: 'string', entities: '?object' }, { accept: 'application/json' }), (req, res, next) => {	×
298	tokenize(req.params, req.body, res).catch(next);	×
299	});
300
301	app.post('/:locale/learn', learn);	×
302
303	// if we get here, we have a 404 error
304	app.use('/', (req, res) => {	×
305	res.status(404).json({ error: 'Invalid endpoint' });	×
306	});
307	app.use(errorhandler());	×
308
309	const server = app.listen(app.get('port'));	×
310
311	await new Promise((resolve, reject) => {	×
312	process.on('SIGINT', resolve);	×
313	process.on('SIGTERM', resolve);	×
314	});
315
NEW 316	if (app.backend.nlu)	×
NEW 317	await app.backend.nlu.stop();	×
318	if (app.backend.nlg !== app.backend.nlu)	×
319	await app.backend.nlg.stop();	×
NEW 320	if (app.backend.translator)	×
NEW 321	await app.backend.translator.stop();	×
UNCOV 322	server.close();	×
323	}

stanford-oval / genie-toolkit / 2408

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous