stanford-oval / genie-toolkit / 595

pending completion

Build # 595

Build Type

push

travis-ci-com

Committed by

web-flow

Commit Message

Merge pull request #125 from stanford-oval/wip/update-thingtalk

Update to the new version of ThingTalk

Run Details

1684 of 4123 branches covered (40.84%)

Branch coverage included in aggregate %.

65 of 142 new or added lines in 7 files covered. (45.77%)

8 existing lines in 4 files now uncovered.

4272 of 8274 relevant lines covered (51.63%)

553329.11 hits per line

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

4.01

/tool/manual-annotate-dialog.js

// -*- mode: js; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of ThingEngine
//
// Copyright 2016 The Board of Trustees of the Leland Stanford Junior University
//
// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
//
// See COPYING for details
"use strict";

const fs = require('fs');
const readline = require('readline');
const Stream = require('stream');
const Tp = require('thingpedia');

const ParserClient = require('./lib/parserclient');
const { DialogSerializer } = require('./lib/dialog_parser');
const StreamUtils = require('../lib/stream-utils');

const ThingTalk = require('thingtalk');
const Ast = ThingTalk.Ast;

class Annotator extends Stream.Readable {
    constructor(rl, options) {
        super({ objectMode: true });

        this._rl = rl;

        const tpClient = new Tp.FileClient(options);
        this._schemas = new ThingTalk.SchemaRetriever(tpClient, null, true);
        this._parser = ParserClient.get(options.server, 'en-US');

        this._state = 'loading';

        this._serial = 0;

        this._currentDialog = [];

        this._dialogState = undefined;
        this._context = undefined;
        this._utterance = undefined;
        this._preprocessed = undefined;
        this._entities = undefined;
        this._candidates = undefined;

        rl.on('line', async (line) => {
            if (this._state === 'done')
                return;

            line = line.trim();

            if (line.length === 0 || this._state === 'loading') {
                rl.prompt();
                return;
            }

            if (line === 'q') {
                this.quit();
                return;
            }

            if (line === 'h' || line === '?') {
                this._help();
                return;
            }

            if (line === 'd') {
                this.nextDialog();
                return;
            }

            if (this._state === 'input') {
                this._utterance = line;
                this._handleInput().catch((e) => this.emit('error', e));
                return;
            }

            if (this._state === 'code') {
                this._learnThingTalk(line).catch((e) => this.emit('error', e));
                return;
            }

            if (Number.isFinite(parseInt(line))) {
                this._learnNumber(parseInt(line));
            } else if (line === 'n') {
                this._more();
            } else if (line.startsWith('e ')) {
                this._edit(parseInt(line.substring(2).trim()));
            } else if (line.startsWith('t ')) {
                this._learnThingTalk(line.substring(2)).catch((e) => this.emit('error', e));
            } else if (line === 't') {
                this._state = 'code';
                rl.setPrompt('TT: ');
                rl.prompt();
            } else {
                console.log('Invalid command');
                rl.prompt();
            }
        });
    }

    _read() {}

    quit() {
        if (this._currentDialog.length > 0)
            this.push(this._currentDialog);
        this._state = 'done';
        this.push(null);
    }

    _help() {
        console.log('Available commands:');
        console.log('q: quit');
        console.log('d: (done/drop) complete the current dialog and start the next one');
        console.log('<0-9>: make a choice');
        console.log('n: (next) show more choices');
        console.log('e <0-9>: edit a choice');
        console.log('t: (thingtalk) write code directly');
        console.log('? or h: this help');
    }

    async start() {
        await this._parser.start();
        this.nextDialog();
    }
    async stop() {
        await this._parser.stop();
    }

    async _learnThingTalk(code) {
        let program;
        try {
            program = await ThingTalk.Grammar.parseAndTypecheck(code, this._schemas);

            const clone = {};
            Object.assign(clone, this._entities);
            ThingTalk.NNSyntax.toNN(program, this._preprocessed, clone);
        } catch(e) {
            console.log(`${e.name}: ${e.message}`);
            this._rl.setPrompt('TT: ');
            this._rl.prompt();
            return;
        }

        if (!this._applyReplyToContext(program)) {
            this._rl.setPrompt('TT: ');
            this._rl.prompt();
            return;
        }

        this._currentDialog.push(
            this._preprocessed,
            program.prettyprint()
        );
        this._computeAssistantAction();
        this.nextTurn();
    }

    _edit(i) {
        if (Number.isNaN(i) || i < 1 || i > this._candidates.length) {
            console.log('Invalid number');
            this._rl.setPrompt('$ ');
            this._rl.prompt();
            return;
        }
        i -= 1;
        const program = this._candidates[i];
        this._state = 'code';
        this._rl.setPrompt('TT: ');
        this._rl.write(program.prettyprint(true));
        this._rl.prompt();
    }

    _learnNumber(i) {
        if (i < 1 || i > this._candidates.length) {
            console.log('Invalid number');
            this._rl.setPrompt('$ ');
            this._rl.prompt();
            return;
        }
        i -= 1;

        const program = this._candidates[i];
        if (!this._applyReplyToContext(program)) {
            this._rl.setPrompt('$ ');
            this._rl.prompt();
            return;
        }

        this._currentDialog.push(
            this._preprocessed,
            program.prettyprint()
        );
        this._computeAssistantAction();
        this.nextTurn();
    }

    _more() {
        if (this._state === 'top3') {
            this._state = 'full';
            console.log(`Sentence #${this._serial+1} (${this._id}): ${this._utterance}`);
            for (let i = 0; i < this._candidates.length; i++)
                console.log(`${i+1}) ${this._candidates[i].code.join(' ')}`);
            this._rl.setPrompt('$ ');
            this._rl.prompt();
        } else {
            this._state = 'code';
            this._rl.setPrompt('TT: ');
            this._rl.prompt();
        }
    }

    _computeAssistantAction() {
        for (let [schema, slot] of this._context.iterateSlots()) {
            if (slot instanceof Ast.Selector)
                continue;
            if (slot.value.isUndefined) {
                this._currentDialog.push(`# assistant asks for ${slot.name}`);
                console.log(`A: asks for ${slot.name}`);

                let argname = slot.name;
                let type = schema.inReq[argname] || schema.inOpt[argname] || schema.out[argname];
                if (slot instanceof Ast.BooleanExpression && slot.operator === 'contains')
                    type = type.elem;
                this._dialogState = type.isString ? 'raw' : 'slot-fill';
                return;
            }
        }

        if (this._context.isProgram && this._context.rules.every((r) => !r.stream && r.actions.every((a) => a.isInvocation && a.invocation.selector.isBuiltin))) {
            this._currentDialog.push(`# assistant shows result`);
            console.log(`A: shows result`);
            this._dialogState = 'result';
            return;
        }

        if (this._dialogState === 'confirm') {
            this._currentDialog.push(`# assistant executes`);
            console.log(`A: consider it done`);
            this._dialogState = 'initial';
            return;
        }

        this._currentDialog.push(`# assistant confirms`);
        console.log(`A: confirms`);
        this._dialogState = 'confirm';
    }

    _applyReplyToContext(newCommand) {
        if (newCommand.isProgram || newCommand.isPermissionRule) {
            this._context = newCommand;
            this._dialogState = 'initial';
            return true;
        }

        if (newCommand.isBookkeeping && this._context !== null) {
            if (this._dialogState === 'slot-fill') {
                // while slot filling, treat yes/no as true/false
                if (newCommand.intent.isSpecial &&
                    (newCommand.intent.type === 'yes' || newCommand.intent.type === 'no')) {
                    newCommand = new Ast.Input.Bookkeeping(null,
                        new Ast.BookkeepingIntent.Answer(null, new Ast.Value.Boolean(newCommand.intent.type === 'yes'))
                    );
                }
            }

            if (newCommand.intent.isAnswer) {
                if (this._dialogState !== 'slot-fill' && this._dialogState !== 'raw') {
                    console.log(`Unexpected answer`);
                    return false;
                }

                for (let [schema, slot] of this._context.iterateSlots()) {
                    if (slot instanceof Ast.Selector)
                        continue;
                    if (!slot.value.isUndefined)
                        continue;
                    let argname = slot.name;
                    let type = schema.inReq[argname] || schema.inOpt[argname] || schema.out[argname];
                    if (slot instanceof Ast.BooleanExpression && slot.operator === 'contains')
                        type = type.elem;

                    if (!ThingTalk.Type.isAssignable(newCommand.intent.value.getType(), type)) {
                        console.log(`Answer has the wrong type (expected ${type})`);
                        return false;
                    }
                    slot.value = newCommand.intent.value;
                    console.log(this._context.prettyprint());
                    return true;
                }

                throw new Error('??? slot-fill state without a slot?');
            }

            if (newCommand.intent.isSpecial) {
                if (newCommand.intent.type === 'nevermind' || newCommand.intent.type === 'stop') {
                    console.log(`Unexpected stop/nevermind, use "d" to terminate the current dialog`);
                    return false;
                }

                // in the confirm state, accept a single "yes" w/ no change in context
                if (this._dialogState === 'confirm' && newCommand.intent.type === 'yes')
                    return true;
            }
        }

        console.log(`Unexpected command ${newCommand.prettyprint()}`);
        return false;
    }

    nextDialog() {
        if (this._currentDialog.length > 0)
            this.push(this._currentDialog);

        if (this._serial > 0)
            console.log();
        console.log(`Dialog #${this._serial+1}`);
        this._serial++;

        this._currentDialog = [];
        this._context = null;
        this._dialogState = 'initial';
        this.nextTurn();
    }
    nextTurn() {
        this._state = 'input';
        this._utterance = undefined;
        console.log('Context: ' + (this._context ? this._context.prettyprint() : 'null'));
        this._rl.setPrompt('U: ');
        this._rl.prompt();
    }

    async _handleInput() {
        if (this._dialogState === 'raw') {
            const program = new Ast.Input.Bookkeeping(null,
                new Ast.BookkeepingIntent.Answer(null, new Ast.Value.String(this._utterance)));
            if (!this._applyReplyToContext(program)) {
                this._rl.setPrompt('$ ');
                this._rl.prompt();
                return;
            }

            this._currentDialog.push(
                this._preprocessed,
                program.prettyprint()
            );
            this._computeAssistantAction();
            this.nextTurn();
            return;
        }

        this._state = 'loading';

        let contextCode, contextEntities = {};
        if (this._context !== null)
            contextCode = ThingTalk.NNSyntax.toNN(this._context, '', contextEntities, { allocateEntities: true });
        else
            contextCode = ['null'];
        const parsed = await this._parser.sendUtterance(this._utterance, false, contextCode, contextEntities);

        this._state = 'top3';
        this._preprocessed = parsed.tokens.join(' ');
        this._entities = parsed.entities;
        this._candidates = (await Promise.all(parsed.candidates.map(async (cand) => {
            try {
                const program = ThingTalk.NNSyntax.fromNN(cand.code, parsed.entities);
                await program.typecheck(this._schemas);

                // convert the program to NN syntax once, which will force the program to be syntactically normalized
                // (and therefore rearrange slot-fill by name rather than Thingpedia order)
                ThingTalk.NNSyntax.toNN(program, '', {}, { allocateEntities: true });
                return program;
            } catch(e) {
                return null;
            }
        }))).filter((c) => c !== null);

        for (var i = 0; i < 3 && i < this._candidates.length; i++)
            console.log(`${i+1}) ${this._candidates[i].prettyprint()}`);
        this._rl.setPrompt('$ ');
        this._rl.prompt();
    }
}

module.exports = {
    initArgparse(subparsers) {
        const parser = subparsers.addParser('manual-annotate-dialog', {
            addHelp: true,
            description: `Interactive create a dialog dataset, by annotating each sentence turn-by-turn.`
        });
        parser.addArgument(['-o', '--output'], {
            required: true,
        });
        parser.addArgument(['-l', '--locale'], {
            required: false,
            defaultValue: 'en-US',
            help: `BGP 47 locale tag of the natural language being processed (defaults to en-US).`
        });
        parser.addArgument('--thingpedia', {
            required: true,
            help: 'Path to ThingTalk file containing class definitions.'
        });
        parser.addArgument('--server', {
            required: false,
            defaultValue: 'https://almond-nl.stanford.edu',
            help: `The URL of the natural language server. Use a file:// URL pointing to a model directory to evaluate using a local instance of decanlp.`
        });
    },

    async execute(args) {
        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
        rl.setPrompt('$ ');

        const annotator = new Annotator(rl, args);
        rl.on('SIGINT', () => annotator.quit());
        await annotator.start();
        //process.stdin.on('end', quit);

        await StreamUtils.waitFinish(annotator
            .pipe(new DialogSerializer())
            .pipe(fs.createWriteStream(args.output, { flags: 'a' }))
        );

        console.log('Bye\n');
        rl.close();

        await annotator.stop();
    }
};

1	// -- mode: js; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of ThingEngine
4	//
5	// Copyright 2016 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
8	//
9	// See COPYING for details
10	"use strict";
11
12	const fs = require('fs');	52✔
13	const readline = require('readline');	52✔
14	const Stream = require('stream');	52✔
15	const Tp = require('thingpedia');	52✔
16
17	const ParserClient = require('./lib/parserclient');	52✔
18	const { DialogSerializer } = require('./lib/dialog_parser');	52✔
19	const StreamUtils = require('../lib/stream-utils');	52✔
20
21	const ThingTalk = require('thingtalk');	52✔
22	const Ast = ThingTalk.Ast;	52✔
23
24	class Annotator extends Stream.Readable {
25	constructor(rl, options) {
26	super({ objectMode: true });	×
27
28	this._rl = rl;	×
29
30	const tpClient = new Tp.FileClient(options);	×
31	this._schemas = new ThingTalk.SchemaRetriever(tpClient, null, true);	×
32	this._parser = ParserClient.get(options.server, 'en-US');	×
33
34	this._state = 'loading';	×
35
36	this._serial = 0;	×
37
38	this._currentDialog = [];	×
39
40	this._dialogState = undefined;	×
41	this._context = undefined;	×
42	this._utterance = undefined;	×
43	this._preprocessed = undefined;	×
44	this._entities = undefined;	×
45	this._candidates = undefined;	×
46
47	rl.on('line', async (line) => {	×
48	if (this._state === 'done')	×
49	return;	×
50
51	line = line.trim();	×
52
53	if (line.length === 0 \|\| this._state === 'loading') {	×
54	rl.prompt();	×
55	return;	×
56	}
57
58	if (line === 'q') {	×
59	this.quit();	×
60	return;	×
61	}
62
63	if (line === 'h' \|\| line === '?') {	×
64	this._help();	×
65	return;	×
66	}
67
68	if (line === 'd') {	×
69	this.nextDialog();	×
70	return;	×
71	}
72
73	if (this._state === 'input') {	×
74	this._utterance = line;	×
75	this._handleInput().catch((e) => this.emit('error', e));	×
76	return;	×
77	}
78
79	if (this._state === 'code') {	×
80	this._learnThingTalk(line).catch((e) => this.emit('error', e));	×
81	return;	×
82	}
83
84	if (Number.isFinite(parseInt(line))) {	×
85	this._learnNumber(parseInt(line));	×
86	} else if (line === 'n') {	×
87	this._more();	×
88	} else if (line.startsWith('e ')) {	×
89	this._edit(parseInt(line.substring(2).trim()));	×
90	} else if (line.startsWith('t ')) {	×
91	this._learnThingTalk(line.substring(2)).catch((e) => this.emit('error', e));	×
92	} else if (line === 't') {	×
93	this._state = 'code';	×
94	rl.setPrompt('TT: ');	×
95	rl.prompt();	×
96	} else {
97	console.log('Invalid command');	×
98	rl.prompt();	×
99	}
100	});
101	}
102
103	_read() {}
104
105	quit() {
106	if (this._currentDialog.length > 0)	×
107	this.push(this._currentDialog);	×
108	this._state = 'done';	×
109	this.push(null);	×
110	}
111
112	_help() {
113	console.log('Available commands:');	×
114	console.log('q: quit');	×
115	console.log('d: (done/drop) complete the current dialog and start the next one');	×
116	console.log('<0-9>: make a choice');	×
117	console.log('n: (next) show more choices');	×
118	console.log('e <0-9>: edit a choice');	×
119	console.log('t: (thingtalk) write code directly');	×
120	console.log('? or h: this help');	×
121	}
122
123	async start() {
124	await this._parser.start();	×
125	this.nextDialog();	×
126	}
127	async stop() {
128	await this._parser.stop();	×
129	}
130
131	async _learnThingTalk(code) {
132	let program;
133	try {	×
134	program = await ThingTalk.Grammar.parseAndTypecheck(code, this._schemas);	×
135
136	const clone = {};	×
137	Object.assign(clone, this._entities);	×
138	ThingTalk.NNSyntax.toNN(program, this._preprocessed, clone);	×
139	} catch(e) {
140	console.log(`${e.name}: ${e.message}`);	×
141	this._rl.setPrompt('TT: ');	×
142	this._rl.prompt();	×
143	return;	×
144	}
145
146	if (!this._applyReplyToContext(program)) {	×
147	this._rl.setPrompt('TT: ');	×
148	this._rl.prompt();	×
149	return;	×
150	}
151
152	this._currentDialog.push(	×
153	this._preprocessed,
154	program.prettyprint()
155	);
156	this._computeAssistantAction();	×
157	this.nextTurn();	×
158	}
159
160	_edit(i) {
161	if (Number.isNaN(i) \|\| i < 1 \|\| i > this._candidates.length) {	×
162	console.log('Invalid number');	×
163	this._rl.setPrompt('$ ');	×
164	this._rl.prompt();	×
165	return;	×
166	}
167	i -= 1;	×
168	const program = this._candidates[i];	×
169	this._state = 'code';	×
170	this._rl.setPrompt('TT: ');	×
171	this._rl.write(program.prettyprint(true));	×
172	this._rl.prompt();	×
173	}
174
175	_learnNumber(i) {
176	if (i < 1 \|\| i > this._candidates.length) {	×
177	console.log('Invalid number');	×
178	this._rl.setPrompt('$ ');	×
179	this._rl.prompt();	×
180	return;	×
181	}
182	i -= 1;	×
183
184	const program = this._candidates[i];	×
185	if (!this._applyReplyToContext(program)) {	×
186	this._rl.setPrompt('$ ');	×
187	this._rl.prompt();	×
188	return;	×
189	}
190
191	this._currentDialog.push(	×
192	this._preprocessed,
193	program.prettyprint()
194	);
195	this._computeAssistantAction();	×
196	this.nextTurn();	×
197	}
198
199	_more() {
200	if (this._state === 'top3') {	×
201	this._state = 'full';	×
202	console.log(`Sentence #${this._serial+1} (${this._id}): ${this._utterance}`);	×
203	for (let i = 0; i < this._candidates.length; i++)	×
204	console.log(`${i+1}) ${this._candidates[i].code.join(' ')}`);	×
205	this._rl.setPrompt('$ ');	×
206	this._rl.prompt();	×
207	} else {
208	this._state = 'code';	×
209	this._rl.setPrompt('TT: ');	×
210	this._rl.prompt();	×
211	}
212	}
213
214	_computeAssistantAction() {
215	for (let [schema, slot] of this._context.iterateSlots()) {	×
216	if (slot instanceof Ast.Selector)	×
217	continue;	×
218	if (slot.value.isUndefined) {	×
219	this._currentDialog.push(`# assistant asks for ${slot.name}`);	×
220	console.log(`A: asks for ${slot.name}`);	×
221
222	let argname = slot.name;	×
223	let type = schema.inReq[argname] \|\| schema.inOpt[argname] \|\| schema.out[argname];	×
224	if (slot instanceof Ast.BooleanExpression && slot.operator === 'contains')	×
225	type = type.elem;	×
226	this._dialogState = type.isString ? 'raw' : 'slot-fill';	×
227	return;	×
228	}
229	}
230
231	if (this._context.isProgram && this._context.rules.every((r) => !r.stream && r.actions.every((a) => a.isInvocation && a.invocation.selector.isBuiltin))) {	×
232	this._currentDialog.push(`# assistant shows result`);	×
233	console.log(`A: shows result`);	×
234	this._dialogState = 'result';	×
235	return;	×
236	}
237
238	if (this._dialogState === 'confirm') {	×
239	this._currentDialog.push(`# assistant executes`);	×
240	console.log(`A: consider it done`);	×
241	this._dialogState = 'initial';	×
242	return;	×
243	}
244
245	this._currentDialog.push(`# assistant confirms`);	×
246	console.log(`A: confirms`);	×
247	this._dialogState = 'confirm';	×
248	}
249
250	_applyReplyToContext(newCommand) {
251	if (newCommand.isProgram \|\| newCommand.isPermissionRule) {	×
252	this._context = newCommand;	×
253	this._dialogState = 'initial';	×
254	return true;	×
255	}
256
257	if (newCommand.isBookkeeping && this._context !== null) {	×
258	if (this._dialogState === 'slot-fill') {	×
259	// while slot filling, treat yes/no as true/false
260	if (newCommand.intent.isSpecial &&	×
261	(newCommand.intent.type === 'yes' \|\| newCommand.intent.type === 'no')) {
NEW 262	newCommand = new Ast.Input.Bookkeeping(null,	×
263	new Ast.BookkeepingIntent.Answer(null, new Ast.Value.Boolean(newCommand.intent.type === 'yes'))
264	);
265	}
266	}
267
268	if (newCommand.intent.isAnswer) {	×
269	if (this._dialogState !== 'slot-fill' && this._dialogState !== 'raw') {	×
270	console.log(`Unexpected answer`);	×
271	return false;	×
272	}
273
274	for (let [schema, slot] of this._context.iterateSlots()) {	×
275	if (slot instanceof Ast.Selector)	×
276	continue;	×
277	if (!slot.value.isUndefined)	×
278	continue;	×
279	let argname = slot.name;	×
280	let type = schema.inReq[argname] \|\| schema.inOpt[argname] \|\| schema.out[argname];	×
281	if (slot instanceof Ast.BooleanExpression && slot.operator === 'contains')	×
282	type = type.elem;	×
283
284	if (!ThingTalk.Type.isAssignable(newCommand.intent.value.getType(), type)) {	×
285	console.log(`Answer has the wrong type (expected ${type})`);	×
286	return false;	×
287	}
288	slot.value = newCommand.intent.value;	×
289	console.log(this._context.prettyprint());	×
290	return true;	×
291	}
292
293	throw new Error('??? slot-fill state without a slot?');	×
294	}
295
296	if (newCommand.intent.isSpecial) {	×
297	if (newCommand.intent.type === 'nevermind' \|\| newCommand.intent.type === 'stop') {	×
298	console.log(`Unexpected stop/nevermind, use "d" to terminate the current dialog`);	×
299	return false;	×
300	}
301
302	// in the confirm state, accept a single "yes" w/ no change in context
303	if (this._dialogState === 'confirm' && newCommand.intent.type === 'yes')	×
304	return true;	×
305	}
306	}
307
308	console.log(`Unexpected command ${newCommand.prettyprint()}`);	×
309	return false;	×
310	}
311
312	nextDialog() {
313	if (this._currentDialog.length > 0)	×
314	this.push(this._currentDialog);	×
315
316	if (this._serial > 0)	×
317	console.log();	×
318	console.log(`Dialog #${this._serial+1}`);	×
319	this._serial++;	×
320
321	this._currentDialog = [];	×
322	this._context = null;	×
323	this._dialogState = 'initial';	×
324	this.nextTurn();	×
325	}
326	nextTurn() {
327	this._state = 'input';	×
328	this._utterance = undefined;	×
329	console.log('Context: ' + (this._context ? this._context.prettyprint() : 'null'));	×
330	this._rl.setPrompt('U: ');	×
331	this._rl.prompt();	×
332	}
333
334	async _handleInput() {
335	if (this._dialogState === 'raw') {	×
NEW 336	const program = new Ast.Input.Bookkeeping(null,	×
337	new Ast.BookkeepingIntent.Answer(null, new Ast.Value.String(this._utterance)));
338	if (!this._applyReplyToContext(program)) {	×
339	this._rl.setPrompt('$ ');	×
340	this._rl.prompt();	×
341	return;	×
342	}
343
344	this._currentDialog.push(	×
345	this._preprocessed,
346	program.prettyprint()
347	);
348	this._computeAssistantAction();	×
349	this.nextTurn();	×
350	return;	×
351	}
352
353	this._state = 'loading';	×
354
355	let contextCode, contextEntities = {};	×
356	if (this._context !== null)	×
357	contextCode = ThingTalk.NNSyntax.toNN(this._context, '', contextEntities, { allocateEntities: true });	×
358	else
359	contextCode = ['null'];	×
360	const parsed = await this._parser.sendUtterance(this._utterance, false, contextCode, contextEntities);	×
361
362	this._state = 'top3';	×
363	this._preprocessed = parsed.tokens.join(' ');	×
364	this._entities = parsed.entities;	×
365	this._candidates = (await Promise.all(parsed.candidates.map(async (cand) => {	×
366	try {	×
367	const program = ThingTalk.NNSyntax.fromNN(cand.code, parsed.entities);	×
368	await program.typecheck(this._schemas);	×
369
370	// convert the program to NN syntax once, which will force the program to be syntactically normalized
371	// (and therefore rearrange slot-fill by name rather than Thingpedia order)
372	ThingTalk.NNSyntax.toNN(program, '', {}, { allocateEntities: true });	×
373	return program;	×
374	} catch(e) {
375	return null;	×
376	}
377	}))).filter((c) => c !== null);	×
378
379	for (var i = 0; i < 3 && i < this._candidates.length; i++)	×
380	console.log(`${i+1}) ${this._candidates[i].prettyprint()}`);	×
381	this._rl.setPrompt('$ ');	×
382	this._rl.prompt();	×
383	}
384	}
385
386	module.exports = {	52✔
387	initArgparse(subparsers) {
388	const parser = subparsers.addParser('manual-annotate-dialog', {	52✔
389	addHelp: true,
390	description: `Interactive create a dialog dataset, by annotating each sentence turn-by-turn.`
391	});
392	parser.addArgument(['-o', '--output'], {	52✔
393	required: true,
394	});
395	parser.addArgument(['-l', '--locale'], {	52✔
396	required: false,
397	defaultValue: 'en-US',
398	help: `BGP 47 locale tag of the natural language being processed (defaults to en-US).`
399	});
400	parser.addArgument('--thingpedia', {	52✔
401	required: true,
402	help: 'Path to ThingTalk file containing class definitions.'
403	});
404	parser.addArgument('--server', {	52✔
405	required: false,
406	defaultValue: 'https://almond-nl.stanford.edu',
407	help: `The URL of the natural language server. Use a file:// URL pointing to a model directory to evaluate using a local instance of decanlp.`
408	});
409	},
410
411	async execute(args) {
412	const rl = readline.createInterface({ input: process.stdin, output: process.stdout });	×
413	rl.setPrompt('$ ');	×
414
415	const annotator = new Annotator(rl, args);	×
416	rl.on('SIGINT', () => annotator.quit());	×
417	await annotator.start();	×
418	//process.stdin.on('end', quit);
419
420	await StreamUtils.waitFinish(annotator	×
421	.pipe(new DialogSerializer())
422	.pipe(fs.createWriteStream(args.output, { flags: 'a' }))
423	);
424
425	console.log('Bye\n');	×
426	rl.close();	×
427
428	await annotator.stop();	×
429	}
430	};

stanford-oval / genie-toolkit / 595

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