1108

pending completion

Build # 1108

Build Type

Pull #256

travis-ci-com

Committed by

web-flow

Commit Message

Merge 544770598 into 65b4e469a

Pull Request Pull Request #256: Patches to enable Almond server

Run Details

6553 of 12363 branches covered (53.0%)

Branch coverage included in aggregate %.

17 of 80 new or added lines in 5 files covered. (21.25%)

3 existing lines in 1 file now uncovered.

15112 of 23938 relevant lines covered (63.13%)

2757687.42 hits per line

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

54.72

/lib/dialogue-agent/conversation.js

// -*- mode: js; 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>
"use strict";

const events = require('events');

const interpolate = require('string-interp');
const ThingTalk = require('thingtalk');

const ParserClient = require('../prediction/parserclient');

const UserInput = require('./user-input');
const ValueCategory = require('./value-category');
const DialogueLoop = require('./dialogue-loop');
const { MessageType } = require('./protocol');


const DummyStatistics = {
    hit() {
    }
};

const DEFAULT_CONVERSATION_TTL = 600000; // 10 minutes

module.exports = class Conversation extends events.EventEmitter {
    constructor(engine, conversationId, user, options) {
        super();
        this._engine = engine;
        this._user = user;

        this._conversationId = conversationId;
        this._gettext = this._engine.platform.getCapability('gettext');
        this._ngettext = this._engine.ngettext;
        this._ = this._engine.gettext;

        this._stats = this._engine.platform.getCapability('statistics');
        if (this._stats === null)
            this._stats = DummyStatistics;

        this._raw = false;
        this._options = options || {};
        this._debug = !!this._options.debug;

        this.rng = options.rng || Math.random;

        this._prefs = engine.platform.getSharedPreferences();
        this._nlu = ParserClient.get(this._options.nluServerUrl, engine.platform.locale, engine.platform,
            null, engine.thingpedia);
        if (this._options.nlgServerUrl)
            this._nlg = ParserClient.get(this._options.nlgServerUrl, engine.platform.locale, engine.platform);
        else
            this._nlg = this._nlu;
        this._lastCommand = null;
        this._lastCandidates = null;

        this._loop = new DialogueLoop(this, this._engine, this._debug);
        this._choices = [];
        this.setContext(null);
        this._delegates = new Set;
        this._history = [];
        this._nextMsgId = 0;

        this._inactivityTimeout = null;
        this._inactivityTimeoutSec = options.inactivityTimeout || DEFAULT_CONVERSATION_TTL;
        this._contextResetTimeout = null;
        this._contextResetTimeoutSec = options.contextResetTimeout || this._inactivityTimeoutSec;
    }

    get isAnonymous() {
        return this._options.anonymous;
    }

    get id() {
        return this._conversationId;
    }

    get user() {
        return this._user;
    }

    get platform() {
        return this._engine.platform;
    }

    get locale() {
        return this._engine.platform.locale;
    }

    get timezone() {
        return this._engine.platform.timezone;
    }

    get gettext() {
        return this._gettext;
    }

    get stats() {
        return this._stats;
    }

    get apps() {
        return this._engine.apps;
    }

    get devices() {
        return this._engine.devices;
    }

    get schemas() {
        return this._engine.schemas;
    }

    get thingpedia() {
        return this._engine.thingpedia;
    }

    get history() {
        return this._history;
    }

    notify() {
        return this._loop.dispatchNotify.apply(this._loop, arguments);
    }

    notifyError() {
        return this._loop.dispatchNotifyError.apply(this._loop, arguments);
    }

    expect(expecting) {
        this._expecting = expecting;
        this._choices = [];
        this._raw = (expecting === ValueCategory.RawString || expecting === ValueCategory.Password);
    }

    async start() {
        await this._nlu.start();
        if (this._nlu !== this._nlg)
            await this._nlg.start();
        this._resetInactivityTimeout();
        return this._loop.start(this._options.showWelcome);
    }

    async stop() {
        await this._nlu.stop();
        if (this._nlu !== this._nlg)
            await this._nlg.stop();
    }

    _isUnsupportedError(e) {
        // FIXME there should be a better way to do this

        // 'xxx has no actions yyy' or 'xxx has no queries yyy'
        // quite likely means that the NN worked but it produced a device that
        // was not approved yet (otherwise the NN itself would catch the invalid function and
        // skip this result) and we don't have the necessary developer key
        // in that case, we reply to the user that the command is unsupported
        return /(invalid kind| has no (quer(ies|y)|actions?)) /i.test(e.message);
    }

    // set confident = true only if
    // 1) we are not dealing with natural language (code, gui, etc), or
    // 2) we find an exact match
    _doHandleCommand(intent, analyzed, candidates, confident=false) {
        this._lastCommand = analyzed;
        this._lastCandidates = candidates;
        return this._loop.handle(intent, confident);
    }

    _getContext(currentCommand, platformData) {
        return {
            command: currentCommand,
            previousCommand: this._lastCommand,
            previousCandidates: this._lastCandidates,
            platformData: platformData
        };
    }

    setContext(context, options = {}) {
        if (context === null) {
            this._context = {
                code: ['null'],
                entities: {}
            };
        } else {
            const entities = {};
            options.allocateEntities = true;
            const code = ThingTalk.NNSyntax.toNN(context, '', entities, options);
            this._context = { code, entities };
        }
    }

    async generateAnswer(policyPrediction) {
        const targetAct = ThingTalk.NNSyntax.toNN(policyPrediction, '', this._context.entities, {
            allocateEntities: true
        }).join(' ');
        const result = await this._nlg.generateUtterance(this._context, targetAct);
        return result.candidates[0].answer;
    }

    _continueHandleCommand(command, analyzed, platformData) {
        analyzed.utterance = command;
        // parse all code sequences into an Intent
        // this will correctly filter out anything that does not parse
        if (analyzed.candidates.length > 0)
            console.log('Analyzed message into ' + analyzed.candidates[0].code.join(' '));
        else
            console.log('Failed to analyze message');
        return Promise.all(analyzed.candidates.map(async (candidate, beamposition) => {
            let parsed;
            try {
                parsed = await UserInput.parse({ code: candidate.code, entities: analyzed.entities }, this.schemas, this._getContext(command, platformData));
            } catch(e) {
                // Likely, a type error in the ThingTalk code; not a big deal, but we still log it
                console.log(`Failed to parse beam ${beamposition}: ${e.message}`);

                if (this._isUnsupportedError(e))
                    parsed = new UserInput.Unsupported(platformData);
                else
                    return null;
            }
            return { target: parsed, score: candidate.score };
        })).then((candidates) => candidates.filter((c) => c !== null)).then((candidates) => {
            // here we used to do a complex heuristic dance of probabilities and confidence scores
            // we do none of that, because Almond-NNParser does not give us useful scores

            if (candidates.length > 0) {
                let i = 0;
                let choice = candidates[i];
                while (i < candidates.length-1 && choice.target.isUnsupported && choice.score === 'Infinity') {
                    i++;
                    choice = candidates[i];
                }

                this.stats.hit('sabrina-command-good');
                const confident = choice.score === 'Infinity' || this._context.code !== 'null';
                return this._doHandleCommand(choice.target, analyzed, analyzed.candidates, confident);
            } else {
                this._lastCommand = analyzed;
                this._lastCandidates = candidates;

                this.stats.hit('sabrina-failure');
                return this._loop.handle(new UserInput.Failed(command, platformData));
            }
        });
    }

    async _errorWrap(fn, platformData) {
        try {
            try {
                await fn();
            } catch(e) {
                if (this._isUnsupportedError(e))
                    await this._doHandleCommand(new UserInput.Unsupported(platformData), null, [], true);
                else
                    throw e;
            }
        } catch(e) {
            if (e.code === 'EHOSTUNREACH' || e.code === 'ETIMEDOUT') {
                await this.sendReply('Sorry, I cannot contact the Almond service. Please check your Internet connection and try again later.', null);
            } else {
                await this.sendReply(interpolate(this._("Sorry, I had an error processing your command: ${error}"), {
                    error: e.message
                }, { locale: this.platform.locale, timezone: this.platform.timezone }), null);
                console.error(e);
            }
        }
    }

    _sendUtterance(utterance) {
        return this._nlu.sendUtterance(utterance, this._context.code, this._context.entities, {
            expect: this._expecting,
            choices: this._choices,
            store: this._prefs.get('sabrina-store-log') || 'no'
        });
    }

    _resetInactivityTimeout() {
        // after "options.inactivityTimeout" milliseconds we inform the app that the conversation
        // is inactive (turn off LEDs, close the microphone, etc.)
        if (this._inactivityTimeout)
            clearTimeout(this._inactivityTimeout);
        if (this._inactivityTimeoutSec > 0) {
            this._inactivityTimeout = setTimeout(() => {
                this.emit('inactive');
            }, this._inactivityTimeoutSec);
        }

        // after "options.contextResetTimeout", we reset the context, forgetting the state of the
        // conversation
        if (this._contextResetTimeout)
            clearTimeout(this._contextResetTimeout);
        if (this._contextResetTimeoutSec) {
            this._contextResetTimeout = setTimeout(() => {
                this.setContext(null);
            }, this._contextResetTimeoutSec);
        }
    }

    async addOutput(out, replayHistory = true) {
        this._delegates.add(out);
        if (replayHistory) {
            for (let msg of this._history)
                await out.addMessage(msg);
        }
    }
    async removeOutput(out) {
        this._delegates.delete(out);
    }

    async _addMessage(msg) {
        msg.id = this._nextMsgId ++;
        this._history.push(msg);
        if (this._history.length > 30)
            this._history.shift();
        await Promise.all(Array.from(this._delegates).map((out) => out.addMessage(msg)));
    }

    async handleCommand(command, platformData = {}, postprocess) {
        this.stats.hit('sabrina-command');
        this.emit('active');
        this._resetInactivityTimeout();
        await this._addMessage({ type: MessageType.COMMAND, command });
        if (this._debug)
            console.log('Received assistant command ' + command);

        return this._errorWrap(async () => {
            if (this._raw && command !== null) {
                let intent = new UserInput.Answer(new ThingTalk.Ast.Value.String(command), platformData);
                return this._doHandleCommand(intent, command, [], true);
            }

            const analyzed = await this._sendUtterance(command);
            if (postprocess)
                postprocess(analyzed);
            return this._continueHandleCommand(command, analyzed, platformData);
        });
    }

    async handleParsedCommand(root, title, platformData = {}) {
        this.stats.hit('sabrina-parsed-command');
        this.emit('active');
        this._resetInactivityTimeout();
        if (typeof root === 'string')
            root = JSON.parse(root);
        await this._addMessage({ type: MessageType.COMMAND, command: title, json: root });
        if (this._debug)
            console.log('Received pre-parsed assistant command');
        if (root.example_id) {
            this.thingpedia.clickExample(root.example_id).catch((e) => {
                console.error('Failed to record example click: ' + e.message);
            });
        }

        return this._errorWrap(async () => {
            const intent = await UserInput.parse(root, this.schemas, this._getContext(null, platformData));
            return this._doHandleCommand(intent, null, [], true);
        }, platformData);
    }

    async handleThingTalk(thingtalk, platformData = {}) {
        this.stats.hit('sabrina-thingtalk-command');
        this.emit('active');
        this._resetInactivityTimeout();
        await this._addMessage({ type: MessageType.COMMAND, command: '\\t ' + thingtalk });
        if (this._debug)
            console.log('Received ThingTalk program');

        return this._errorWrap(async () => {
            const intent = await UserInput.parseThingTalk(thingtalk, this.schemas, this._getContext(null, platformData));
            return this._doHandleCommand(intent, null, [], true);
        }, platformData);
    }

    setHypothesis(hypothesis) {
        return Promise.all(Array.from(this._delegates).map((out) => out.setHypothesis(hypothesis)));
    }

    sendAskSpecial() {
        let what = ValueCategory.toAskSpecial(this._expecting);

        if (this._debug) {
            if (what !== null && what !== 'generic')
                console.log('Genie sends a special request');
            else if (what !== null)
                console.log('Genie expects an answer');
        }

        return Promise.all(Array.from(this._delegates).map((out) => out.setExpected(what, this._context)));
    }

    sendReply(message, icon) {
        if (this._debug)
            console.log('Genie says: ' + message);
        return this._addMessage({ type: MessageType.TEXT, text: message, icon });
    }

    sendResult(message, icon) {
        return this._addMessage({ type: MessageType.RESULT, text: message.toLocaleString(this._locale), result: message, icon });
    }

    sendPicture(url, icon) {
        if (this._debug)
            console.log('Genie sends picture: '+ url);
        return this._addMessage({ type: MessageType.PICTURE, url, icon });
    }

    sendRDL(rdl, icon) {
        if (this._debug)
            console.log('Genie sends RDL: '+ rdl.callback);
        return this._addMessage({ type: MessageType.RDL, rdl, icon });
    }

    sendChoice(idx, title) {
        if (this._expecting !== ValueCategory.MultipleChoice)
            console.log('UNEXPECTED: sendChoice while not expecting a MultipleChoice');

        this._choices[idx] = title;
        if (this._debug)
            console.log('Genie sends multiple choice button: '+ title);
        return this._addMessage({ type: MessageType.CHOICE, idx, title });
    }

    async resendChoices() {
        if (this._expecting !== ValueCategory.MultipleChoice)
            console.log('UNEXPECTED: sendChoice while not expecting a MultipleChoice');

        for (let idx = 0; idx < this._choices.length; idx++)
            await this._addMessage({ type: MessageType.CHOICE, idx, title: this._choices[idx] });
    }

    sendButton(title, json) {
        if (this._debug)
            console.log('Genie sends generic button: '+ title);
        return this._addMessage({ type: MessageType.BUTTON, json, title });
    }

    sendLink(title, url) {
        if (this._debug)
            console.log('Almond sends link: '+ url);
        return this._addMessage({ type: MessageType.LINK, url, title });
    }
};

1	// -- mode: js; 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	"use strict";
21
22	const events = require('events');	57✔
23
24	const interpolate = require('string-interp');	57✔
25	const ThingTalk = require('thingtalk');	57✔
26
27	const ParserClient = require('../prediction/parserclient');	57✔
28
29	const UserInput = require('./user-input');	57✔
30	const ValueCategory = require('./value-category');	57✔
31	const DialogueLoop = require('./dialogue-loop');	57✔
32	const { MessageType } = require('./protocol');	57✔
33
34
35	const DummyStatistics = {	57✔
36	hit() {
37	}
38	};
39
40	const DEFAULT_CONVERSATION_TTL = 600000; // 10 minutes	57✔
41
42	module.exports = class Conversation extends events.EventEmitter {	57✔
43	constructor(engine, conversationId, user, options) {
44	super();	2✔
45	this._engine = engine;	2✔
46	this._user = user;	2✔
47
48	this._conversationId = conversationId;	2✔
49	this._gettext = this._engine.platform.getCapability('gettext');	2✔
50	this._ngettext = this._engine.ngettext;	2✔
51	this._ = this._engine.gettext;	2✔
52
53	this._stats = this._engine.platform.getCapability('statistics');	2✔
54	if (this._stats === null)	2!
55	this._stats = DummyStatistics;	2✔
56
57	this._raw = false;	2✔
58	this._options = options \|\| {};	2!
59	this._debug = !!this._options.debug;	2✔
60
61	this.rng = options.rng \|\| Math.random;	2✔
62
63	this._prefs = engine.platform.getSharedPreferences();	2✔
64	this._nlu = ParserClient.get(this._options.nluServerUrl, engine.platform.locale, engine.platform,	2✔
65	null, engine.thingpedia);
66	if (this._options.nlgServerUrl)	2!
67	this._nlg = ParserClient.get(this._options.nlgServerUrl, engine.platform.locale, engine.platform);	×
68	else
69	this._nlg = this._nlu;	2✔
70	this._lastCommand = null;	2✔
71	this._lastCandidates = null;	2✔
72
73	this._loop = new DialogueLoop(this, this._engine, this._debug);	2✔
74	this._choices = [];	2✔
75	this.setContext(null);	2✔
76	this._delegates = new Set;	2✔
77	this._history = [];	2✔
78	this._nextMsgId = 0;	2✔
79
80	this._inactivityTimeout = null;	2✔
81	this._inactivityTimeoutSec = options.inactivityTimeout \|\| DEFAULT_CONVERSATION_TTL;	2✔
82	this._contextResetTimeout = null;	2✔
83	this._contextResetTimeoutSec = options.contextResetTimeout \|\| this._inactivityTimeoutSec;	2✔
84	}
85
86	get isAnonymous() {
87	return this._options.anonymous;	×
88	}
89
90	get id() {
91	return this._conversationId;	×
92	}
93
94	get user() {
95	return this._user;	×
96	}
97
98	get platform() {
99	return this._engine.platform;	4✔
100	}
101
102	get locale() {
103	return this._engine.platform.locale;	4✔
104	}
105
106	get timezone() {
107	return this._engine.platform.timezone;	×
108	}
109
110	get gettext() {
111	return this._gettext;	2✔
112	}
113
114	get stats() {
115	return this._stats;	24✔
116	}
117
118	get apps() {
119	return this._engine.apps;	×
120	}
121
122	get devices() {
123	return this._engine.devices;	17✔
124	}
125
126	get schemas() {
127	return this._engine.schemas;	27✔
128	}
129
130	get thingpedia() {
131	return this._engine.thingpedia;	5✔
132	}
133
134	get history() {
NEW 135	return this._history;	×
136	}
137
138	notify() {
139	return this._loop.dispatchNotify.apply(this._loop, arguments);	25✔
140	}
141
142	notifyError() {
143	return this._loop.dispatchNotifyError.apply(this._loop, arguments);	3✔
144	}
145
146	expect(expecting) {
147	this._expecting = expecting;	41✔
148	this._choices = [];	41✔
149	this._raw = (expecting === ValueCategory.RawString \|\| expecting === ValueCategory.Password);	41✔
150	}
151
152	async start() {
153	await this._nlu.start();	1✔
154	if (this._nlu !== this._nlg)	1!
155	await this._nlg.start();	×
156	this._resetInactivityTimeout();	1✔
157	return this._loop.start(this._options.showWelcome);	1✔
158	}
159
160	async stop() {
161	await this._nlu.stop();	×
162	if (this._nlu !== this._nlg)	×
163	await this._nlg.stop();	×
164	}
165
166	_isUnsupportedError(e) {
167	// FIXME there should be a better way to do this
168
169	// 'xxx has no actions yyy' or 'xxx has no queries yyy'
170	// quite likely means that the NN worked but it produced a device that
171	// was not approved yet (otherwise the NN itself would catch the invalid function and
172	// skip this result) and we don't have the necessary developer key
173	// in that case, we reply to the user that the command is unsupported
174	return /(invalid kind\| has no (quer(ies\|y)\|actions?)) /i.test(e.message);	×
175	}
176
177	// set confident = true only if
178	// 1) we are not dealing with natural language (code, gui, etc), or
179	// 2) we find an exact match
180	_doHandleCommand(intent, analyzed, candidates, confident=false) {	×
181	this._lastCommand = analyzed;	24✔
182	this._lastCandidates = candidates;	24✔
183	return this._loop.handle(intent, confident);	24✔
184	}
185
186	_getContext(currentCommand, platformData) {
187	return {	23✔
188	command: currentCommand,
189	previousCommand: this._lastCommand,
190	previousCandidates: this._lastCandidates,
191	platformData: platformData
192	};
193	}
194
195	setContext(context, options = {}) {	2✔
196	if (context === null) {	43✔
197	this._context = {	12✔
198	code: ['null'],
199	entities: {}
200	};
201	} else {
202	const entities = {};	31✔
203	options.allocateEntities = true;	31✔
204	const code = ThingTalk.NNSyntax.toNN(context, '', entities, options);	31✔
205	this._context = { code, entities };	31✔
206	}
207	}
208
209	async generateAnswer(policyPrediction) {
210	const targetAct = ThingTalk.NNSyntax.toNN(policyPrediction, '', this._context.entities, {	×
211	allocateEntities: true
212	}).join(' ');
213	const result = await this._nlg.generateUtterance(this._context, targetAct);	×
214	return result.candidates[0].answer;	×
215	}
216
217	_continueHandleCommand(command, analyzed, platformData) {
218	analyzed.utterance = command;	×
219	// parse all code sequences into an Intent
220	// this will correctly filter out anything that does not parse
221	if (analyzed.candidates.length > 0)	×
222	console.log('Analyzed message into ' + analyzed.candidates[0].code.join(' '));	×
223	else
224	console.log('Failed to analyze message');	×
225	return Promise.all(analyzed.candidates.map(async (candidate, beamposition) => {	×
226	let parsed;
227	try {	×
228	parsed = await UserInput.parse({ code: candidate.code, entities: analyzed.entities }, this.schemas, this._getContext(command, platformData));	×
229	} catch(e) {
230	// Likely, a type error in the ThingTalk code; not a big deal, but we still log it
231	console.log(`Failed to parse beam ${beamposition}: ${e.message}`);	×
232
233	if (this._isUnsupportedError(e))	×
234	parsed = new UserInput.Unsupported(platformData);	×
235	else
236	return null;	×
237	}
238	return { target: parsed, score: candidate.score };	×
239	})).then((candidates) => candidates.filter((c) => c !== null)).then((candidates) => {	×
240	// here we used to do a complex heuristic dance of probabilities and confidence scores
241	// we do none of that, because Almond-NNParser does not give us useful scores
242
243	if (candidates.length > 0) {	×
244	let i = 0;	×
245	let choice = candidates[i];	×
246	while (i < candidates.length-1 && choice.target.isUnsupported && choice.score === 'Infinity') {	×
247	i++;	×
248	choice = candidates[i];	×
249	}
250
251	this.stats.hit('sabrina-command-good');	×
252	const confident = choice.score === 'Infinity' \|\| this._context.code !== 'null';	×
253	return this._doHandleCommand(choice.target, analyzed, analyzed.candidates, confident);	×
254	} else {
255	this._lastCommand = analyzed;	×
256	this._lastCandidates = candidates;	×
257
258	this.stats.hit('sabrina-failure');	×
259	return this._loop.handle(new UserInput.Failed(command, platformData));	×
260	}
261	});
262	}
263
264	async _errorWrap(fn, platformData) {
265	try {	24✔
266	try {	24✔
267	await fn();	24✔
268	} catch(e) {
269	if (this._isUnsupportedError(e))	×
270	await this._doHandleCommand(new UserInput.Unsupported(platformData), null, [], true);	×
271	else
272	throw e;	×
273	}
274	} catch(e) {
275	if (e.code === 'EHOSTUNREACH' \|\| e.code === 'ETIMEDOUT') {	×
276	await this.sendReply('Sorry, I cannot contact the Almond service. Please check your Internet connection and try again later.', null);	×
277	} else {
278	await this.sendReply(interpolate(this._("Sorry, I had an error processing your command: ${error}"), {	×
279	error: e.message
280	}, { locale: this.platform.locale, timezone: this.platform.timezone }), null);
281	console.error(e);	×
282	}
283	}
284	}
285
286	_sendUtterance(utterance) {
287	return this._nlu.sendUtterance(utterance, this._context.code, this._context.entities, {	×
288	expect: this._expecting,
289	choices: this._choices,
290	store: this._prefs.get('sabrina-store-log') \|\| 'no'	×
291	});
292	}
293
294	_resetInactivityTimeout() {
295	// after "options.inactivityTimeout" milliseconds we inform the app that the conversation
296	// is inactive (turn off LEDs, close the microphone, etc.)
297	if (this._inactivityTimeout)	25✔
298	clearTimeout(this._inactivityTimeout);	24✔
299	if (this._inactivityTimeoutSec > 0) {	25!
300	this._inactivityTimeout = setTimeout(() => {	25✔
NEW 301	this.emit('inactive');	×
302	}, this._inactivityTimeoutSec);
303	}
304
305	// after "options.contextResetTimeout", we reset the context, forgetting the state of the
306	// conversation
307	if (this._contextResetTimeout)	25✔
308	clearTimeout(this._contextResetTimeout);	24✔
309	if (this._contextResetTimeoutSec) {	25!
310	this._contextResetTimeout = setTimeout(() => {	25✔
NEW 311	this.setContext(null);	×
312	}, this._contextResetTimeoutSec);
313	}
314	}
315
316	async addOutput(out, replayHistory = true) {	1✔
317	this._delegates.add(out);	1✔
318	if (replayHistory) {	1!
319	for (let msg of this._history)	1✔
320	await out.addMessage(msg);	×
321	}
322	}
323	async removeOutput(out) {
324	this._delegates.delete(out);	×
325	}
326
327	async _addMessage(msg) {
328	msg.id = this._nextMsgId ++;	44✔
329	this._history.push(msg);	44✔
330	if (this._history.length > 30)	44✔
331	this._history.shift();	14✔
332	await Promise.all(Array.from(this._delegates).map((out) => out.addMessage(msg)));	44✔
333	}
334
335	async handleCommand(command, platformData = {}, postprocess) {	1✔
336	this.stats.hit('sabrina-command');	1✔
337	this.emit('active');	1✔
338	this._resetInactivityTimeout();	1✔
339	await this._addMessage({ type: MessageType.COMMAND, command });	1✔
340	if (this._debug)	1!
341	console.log('Received assistant command ' + command);	1✔
342
343	return this._errorWrap(async () => {	1✔
344	if (this._raw && command !== null) {	1!
345	let intent = new UserInput.Answer(new ThingTalk.Ast.Value.String(command), platformData);	1✔
346	return this._doHandleCommand(intent, command, [], true);	1✔
347	}
348
349	const analyzed = await this._sendUtterance(command);	×
350	if (postprocess)	×
351	postprocess(analyzed);	×
352	return this._continueHandleCommand(command, analyzed, platformData);	×
353	});
354	}
355
356	async handleParsedCommand(root, title, platformData = {}) {	5✔
357	this.stats.hit('sabrina-parsed-command');	5✔
358	this.emit('active');	5✔
359	this._resetInactivityTimeout();	5✔
360	if (typeof root === 'string')	5!
361	root = JSON.parse(root);	×
362	await this._addMessage({ type: MessageType.COMMAND, command: title, json: root });	5✔
363	if (this._debug)	5!
364	console.log('Received pre-parsed assistant command');	5✔
365	if (root.example_id) {	5!
366	this.thingpedia.clickExample(root.example_id).catch((e) => {	×
367	console.error('Failed to record example click: ' + e.message);	×
368	});
369	}
370
371	return this._errorWrap(async () => {	5✔
372	const intent = await UserInput.parse(root, this.schemas, this._getContext(null, platformData));	5✔
373	return this._doHandleCommand(intent, null, [], true);	5✔
374	}, platformData);
375	}
376
377	async handleThingTalk(thingtalk, platformData = {}) {	18✔
378	this.stats.hit('sabrina-thingtalk-command');	18✔
379	this.emit('active');	18✔
380	this._resetInactivityTimeout();	18✔
381	await this._addMessage({ type: MessageType.COMMAND, command: '\\t ' + thingtalk });	18✔
382	if (this._debug)	18!
383	console.log('Received ThingTalk program');	18✔
384
385	return this._errorWrap(async () => {	18✔
386	const intent = await UserInput.parseThingTalk(thingtalk, this.schemas, this._getContext(null, platformData));	18✔
387	return this._doHandleCommand(intent, null, [], true);	18✔
388	}, platformData);
389	}
390
391	setHypothesis(hypothesis) {
392	return Promise.all(Array.from(this._delegates).map((out) => out.setHypothesis(hypothesis)));	×
393	}
394
395	sendAskSpecial() {
396	let what = ValueCategory.toAskSpecial(this._expecting);	25✔
397
398	if (this._debug) {	25!
399	if (what !== null && what !== 'generic')	25✔
400	console.log('Genie sends a special request');	10✔
401	else if (what !== null)	15!
402	console.log('Genie expects an answer');	×
403	}
404
405	return Promise.all(Array.from(this._delegates).map((out) => out.setExpected(what, this._context)));	25✔
406	}
407
408	sendReply(message, icon) {
409	if (this._debug)	20!
410	console.log('Genie says: ' + message);	20✔
411	return this._addMessage({ type: MessageType.TEXT, text: message, icon });	20✔
412	}
413
414	sendResult(message, icon) {
415	return this._addMessage({ type: MessageType.RESULT, text: message.toLocaleString(this._locale), result: message, icon });	×
416	}
417
418	sendPicture(url, icon) {
419	if (this._debug)	×
420	console.log('Genie sends picture: '+ url);	×
421	return this._addMessage({ type: MessageType.PICTURE, url, icon });	×
422	}
423
424	sendRDL(rdl, icon) {
425	if (this._debug)	×
426	console.log('Genie sends RDL: '+ rdl.callback);	×
427	return this._addMessage({ type: MessageType.RDL, rdl, icon });	×
428	}
429
430	sendChoice(idx, title) {
431	if (this._expecting !== ValueCategory.MultipleChoice)	×
432	console.log('UNEXPECTED: sendChoice while not expecting a MultipleChoice');	×
433
434	this._choices[idx] = title;	×
435	if (this._debug)	×
436	console.log('Genie sends multiple choice button: '+ title);	×
437	return this._addMessage({ type: MessageType.CHOICE, idx, title });	×
438	}
439
440	async resendChoices() {
441	if (this._expecting !== ValueCategory.MultipleChoice)	×
442	console.log('UNEXPECTED: sendChoice while not expecting a MultipleChoice');	×
443
444	for (let idx = 0; idx < this._choices.length; idx++)	×
445	await this._addMessage({ type: MessageType.CHOICE, idx, title: this._choices[idx] });	×
446	}
447
448	sendButton(title, json) {
449	if (this._debug)	×
450	console.log('Genie sends generic button: '+ title);	×
451	return this._addMessage({ type: MessageType.BUTTON, json, title });	×
452	}
453
454	sendLink(title, url) {
455	if (this._debug)	×
456	console.log('Almond sends link: '+ url);	×
457	return this._addMessage({ type: MessageType.LINK, url, title });	×
458	}
459	};

stanford-oval / genie-toolkit / 1108

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