2180

pending completion

Build # 2180

Build Type

push

travis-ci-com

Committed by

web-flow

Commit Message

Differentiate between simple alerts and timers (#681)

Simple alerts/alarms will play a sound at the requested time.
Timers will play a sound and say the amount of time that has elapsed.

Run Details

9977 of 20084 branches covered (49.68%)

Branch coverage included in aggregate %.

4 of 7 new or added lines in 4 files covered. (57.14%)

2 existing lines in 1 file now uncovered.

23571 of 39597 relevant lines covered (59.53%)

630047.99 hits per line

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

34.18

/lib/engine/devices/builtins/thingengine.builtin.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 assert from 'assert';
import * as Tp from 'thingpedia';
import * as TT from 'thingtalk';
import * as stream from 'stream';

import ExecWrapper from '../../apps/exec_wrapper';
import AssistantEngine from '../..';

import FAQ from './faq.json';

class CustomError extends Error {
    constructor(public code : string,
                message : string) {
        super(message);
    }
}

// A placeholder object for builtin triggers/queries/actions that
// don't have any better place to live, such as those related to
// time
export default class MiscellaneousDevice extends Tp.BaseDevice {
    constructor(engine : Tp.BaseEngine, state : { kind : string }) {
        super(engine, state);

        this.isTransient = true;
        this.uniqueId = 'org.thingpedia.builtin.thingengine.builtin';
    }

    get ownerTier() {
        // this pseudo-device does not live anywhere specifically
        return Tp.Tier.GLOBAL;
    }

    async checkAvailable() {
        return Tp.Availability.AVAILABLE;
    }

    get_get_date() {
        const today = new Date;
        today.setHours(0, 0, 0);
        return [{ date: today }];
    }
    get_get_time() {
        const now = new Date;
        // FIXME convert to the right timezone...
        return [{ time: new Tp.Value.Time(now.getHours(), now.getMinutes(), now.getSeconds()) }];
    }
    get_get_random_between({ low, high } : { low : number|null|undefined, high : number|null|undefined }) {
        if ((low === null || low === undefined) && (high === null || high === undefined)) {
            low = 1;
            high = 6;
        } else if (low === null || low === undefined) {
            low = high! < 0 ? Math.min(2 * high!, high! - 5) : 1;
        } else if (high === null || high === undefined) {
            high = low < 0 ? 0 : Math.max(2 * low, low + 5);
        }
        return [{ random: Math.round(low + (Math.random() * (high! - low))) }];
    }

    get_get_name() {
        const platform = this.platform;
        const prefs = platform.getSharedPreferences();
        const name = prefs.get('user-preferred-name');
        if (!name) {
            const err : Error & { code ?: string } = new Error('preferred name is not set yet');
            err.code = 'unset';
            throw err;
        }
        return [{ name }];
    }

    async get_get_gps() {
        const gps = this.platform.getCapability('gps');
        if (gps === null)
            throw new CustomError('unsupported_platform', `get_gps is not supported in ${this.platform.type} platform`);
        const location = await gps.getCurrentLocation();
        if (location) {
            return [{ location: { x: location.longitude, y: location.latitude, display: location.display },
                      altitude: location.altitude,
                      bearing: location.bearing,
                      speed: location.speed }];
        } else {
            return [{ location: { x: 0, y: 0, display: (this.engine as AssistantEngine)._("Unknown") },
                      altitude: 0,
                      bearing: 0,
                      speed: 0 }];
        }
    }
    subscribe_get_gps() {
        const gps = this.platform.getCapability('gps');
        if (gps === null)
            throw new CustomError('unsupported_platform', `get_gps is not supported in ${this.platform.type} platform`);
        const gpsstream = new stream.Readable({ objectMode: true, read() {} });

        gps.onlocationchanged = (location) => {
            if (location !== null) {
                gpsstream.push({ location: { x: location.longitude, y: location.latitude, display: location.display },
                                 altitude: location.altitude,
                                 bearing: location.bearing,
                                 speed: location.speed });
            }
        };
        gps.start();
        gpsstream.destroy = () => gps.stop();
        return gpsstream;
    }

    async *get_device() {
        // TODO use hints

        for (let page = 0; ; page++) {
            const devices = await this.engine.thingpedia.getDeviceList(undefined, page, 10);
            for (let j = 0; j < Math.min(devices.length, 10); j++) {
                const device = devices[j];
                yield {
                    id: new Tp.Value.Entity(device.primary_kind, device.name),
                    description: device.description,
                    category: device.subcategory
                };
            }
            if (devices.length <= 10)
                break;
        }
    }

    async get_device_info({ id } : { id : unknown }) {
        const manifest = await this.engine.schemas.getFullMeta(String(id));
        return [{
            help: manifest.getNaturalLanguageAnnotation('help'),
            description: manifest.getNaturalLanguageAnnotation('thingpedia_description'),
            thingpedia_url: manifest.getImplementationAnnotation('thingpedia_url') || `https://almond.stanford.edu/thingpedia/devices/by-id/${id}`,
            website:  manifest.getImplementationAnnotation('website'),
            category:  manifest.getImplementationAnnotation('subcategory'),
            issue_tracker:  manifest.getImplementationAnnotation('issue_tracker'),
        }];
    }

    async get_commands(params : unknown, hints ?: TT.Runtime.CompiledQueryHints) {
        let dataset;
        if (hints && hints.filter) {
            for (const [pname, op, value] of hints.filter) {
                if (pname === 'device' && op === '==') {
                    dataset = this.engine.thingpedia.getExamplesByKinds([String(value)]);
                    break;
                } else if (pname === 'device' && op === 'in_array') {
                    dataset = this.engine.thingpedia.getExamplesByKinds((value as unknown[]).map((v) => String(v)));
                    break;
                }
            }
        }
        if (!dataset)
            dataset = this.engine.thingpedia.getAllExamples();

        const code = await dataset;
        let parsed;
        try {
            parsed = TT.Syntax.parse(code);
        } catch(e) {
            if (e.name !== 'SyntaxError')
                throw e;
            // try parsing using legacy syntax too in case we're talking
            // to an old Thingpedia that has not been migrated
            parsed = TT.Syntax.parse(code, TT.Syntax.SyntaxType.Legacy);
        }
        await parsed.typecheck(this.engine.schemas, false);
        assert(parsed instanceof TT.Ast.Library);

        return parsed.datasets[0].examples.map((ex) => {
            let device;
            // find the device name for the example
            ex.visit(new class extends TT.Ast.NodeVisitor {
                visitDeviceSelector(sel : TT.Ast.DeviceSelector) {
                    device = sel.kind;
                    return false;
                }
            });
            return {
                id: String(ex.id),
                device: device,
                program: new Tp.Value.Entity(ex.prettyprint(), ex.utterances[0])
            };
        });
    }

    do_faq_reply({ question } : { question : string }) {
        let replies = (FAQ as Record<string, (string[]|Record<string,string[]>)>)[question];
        if (!Array.isArray(replies))
            replies = replies[this.platform.type] || replies.default;

        if (process.env.TEST_MODE)
            return { reply: replies[0] };
        else
            return { reply: replies[Math.floor(Math.random()*replies.length)] };
    }

    do_debug_log(args : { message : string }) {
        console.log('DEBUG:', args.message);
    }
    do_say(args : { message : string }) {
        return { message_output: args.message };
    }
    do_open_url({ url } : { url : unknown }) {
        const cap = this.engine.platform.getCapability('app-launcher');
        if (!cap)
            throw new CustomError('unsupported_platform', `open_url is not supported in ${this.platform.type} platform`);
        return cap.launchURL(String(url));
    }

    do_alert() {}

    do_timer_expire(env : ExecWrapper) {
        const now = new Date;
        const duration = now.getTime() - env.app.metadata.startTime;

        return { duration : duration };
    }

    async do_configure({ device } : { device : unknown }) : Promise<never> {
        const tpClient = this.engine.thingpedia;
        try {
            await tpClient.getDeviceCode(String(device));
        } catch(e) {
            if (e.code === 404)
                e.code = 'unsupported_skill';
            throw e;
        }

        // TODO restore the ability to configure skills from inside the dialogue
        throw new CustomError('unsupported_platform', `not supported`);

        /*
        var conversation = env.app.getConversation();
        if (!conversation)
            throw new Error(this.engine._("User not available"));
        // run it asynchronously, or we'll deadlock
        Promise.resolve(conversation.interactiveConfigure(String(args.device))).catch((err) => {
            // the error has already been logged by Almond, and the user has been informed
        });
        */
    }
    do_discover(args : unknown, env : ExecWrapper) : never {
        /*
        var conversation = env.app.getConversation();
        if (!conversation)
            throw new Error(this.engine._("User not available"));
        // run it asynchronously, or we'll deadlock
        Promise.resolve(conversation.interactiveConfigure(null)).catch((err) => {
            // the error has already been logged by Almond, and the user has been informed
        });
        */
        throw new Error('not implemented');
    }

    do_set_language() : never {
        throw new CustomError(this.platform.type === 'cloud' ? 'unsupported_platform_cloud' : 'unsupported_language', `not supported`);
    }

    do_set_timezone() : never {
        throw new CustomError(this.platform.type === 'cloud' ? 'unsupported_platform_cloud' : 'unsupported_platform', `not supported`);
    }

    do_set_wake_word() : never {
        throw new CustomError('unsupported', `not supported`);
    }

    do_set_voice_output({ status } : { status : 'on'|'off' }) {
        const platform = this.platform;
        if (!platform.hasCapability('sound'))
            throw new CustomError('unsupported', `not supported`);
        const prefs = platform.getSharedPreferences();
        // TODO this does not quite work because SpeechHandler doesn't listen
        // to preference changes
        prefs.set('enable-voice-output', status === 'on');
    }

    do_set_voice_input({ status } : { status : 'on'|'off' }) {
        const platform = this.platform;
        if (!platform.hasCapability('sound'))
            throw new CustomError('unsupported', `not supported`);
        const prefs = platform.getSharedPreferences();
        // TODO this does not quite work because SpeechHandler doesn't listen
        // to preference changes
        prefs.set('enable-voice-input', status === 'on');
    }

    do_set_name({ name } : { name : string }) {
        const platform = this.platform;
        const prefs = platform.getSharedPreferences();
        prefs.set('user-preferred-name', name);
    }

    do_set_location({ type, location } : { type : 'current'|'home'|'work', location : Tp.Value.Location }) {
        const platform = this.platform;
        const prefs = platform.getSharedPreferences();
        prefs.set('context-$context.location.' + (type === 'current' ? 'current_location' : type),
            new TT.Ast.LocationValue(new TT.Ast.AbsoluteLocation(location.lat, location.lon, location.display)).toJS());
    }

    do_set_temperature_unit({ unit } : { unit : string }) {
        const platform = this.platform;
        const prefs = platform.getSharedPreferences();
        prefs.set('preferred-temperature', unit[0].toUpperCase());
    }
}

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 assert from 'assert';	97✔
22	import * as Tp from 'thingpedia';	97✔
23	import * as TT from 'thingtalk';	97✔
24	import * as stream from 'stream';	97✔
25
26	import ExecWrapper from '../../apps/exec_wrapper';
27	import AssistantEngine from '../..';
28
29	import FAQ from './faq.json';	97✔
30
31	class CustomError extends Error {
32	constructor(public code : string,	×
33	message : string) {
34	super(message);	×
35	}
36	}
37
38	// A placeholder object for builtin triggers/queries/actions that
39	// don't have any better place to live, such as those related to
40	// time
41	export default class MiscellaneousDevice extends Tp.BaseDevice {	97✔
42	constructor(engine : Tp.BaseEngine, state : { kind : string }) {
43	super(engine, state);	5✔
44
45	this.isTransient = true;	5✔
46	this.uniqueId = 'org.thingpedia.builtin.thingengine.builtin';	5✔
47	}
48
49	get ownerTier() {
50	// this pseudo-device does not live anywhere specifically
51	return Tp.Tier.GLOBAL;	21✔
52	}
53
54	async checkAvailable() {
55	return Tp.Availability.AVAILABLE;	×
56	}
57
58	get_get_date() {
59	const today = new Date;	1✔
60	today.setHours(0, 0, 0);	1✔
61	return [{ date: today }];	1✔
62	}
63	get_get_time() {
64	const now = new Date;	1✔
65	// FIXME convert to the right timezone...
66	return [{ time: new Tp.Value.Time(now.getHours(), now.getMinutes(), now.getSeconds()) }];	1✔
67	}
68	get_get_random_between({ low, high } : { low : number\|null\|undefined, high : number\|null\|undefined }) {
69	if ((low === null \|\| low === undefined) && (high === null \|\| high === undefined)) {	12,000✔
70	low = 1;	1,000✔
71	high = 6;	1,000✔
72	} else if (low === null \|\| low === undefined) {	11,000✔
73	low = high! < 0 ? Math.min(2 * high!, high! - 5) : 1;	5,000✔
74	} else if (high === null \|\| high === undefined) {	6,000✔
75	high = low < 0 ? 0 : Math.max(2 * low, low + 5);	4,000✔
76	}
77	return [{ random: Math.round(low + (Math.random() * (high! - low))) }];	12,000✔
78	}
79
80	get_get_name() {
81	const platform = this.platform;	×
82	const prefs = platform.getSharedPreferences();	×
83	const name = prefs.get('user-preferred-name');	×
84	if (!name) {	×
85	const err : Error & { code ?: string } = new Error('preferred name is not set yet');	×
86	err.code = 'unset';	×
87	throw err;	×
88	}
89	return [{ name }];	×
90	}
91
92	async get_get_gps() {
93	const gps = this.platform.getCapability('gps');	×
94	if (gps === null)	×
95	throw new CustomError('unsupported_platform', `get_gps is not supported in ${this.platform.type} platform`);	×
96	const location = await gps.getCurrentLocation();	×
97	if (location) {	×
98	return [{ location: { x: location.longitude, y: location.latitude, display: location.display },	×
99	altitude: location.altitude,
100	bearing: location.bearing,
101	speed: location.speed }];
102	} else {
103	return [{ location: { x: 0, y: 0, display: (this.engine as AssistantEngine)._("Unknown") },	×
104	altitude: 0,
105	bearing: 0,
106	speed: 0 }];
107	}
108	}
109	subscribe_get_gps() {
110	const gps = this.platform.getCapability('gps');	×
111	if (gps === null)	×
112	throw new CustomError('unsupported_platform', `get_gps is not supported in ${this.platform.type} platform`);	×
113	const gpsstream = new stream.Readable({ objectMode: true, read() {} });	×
114
115	gps.onlocationchanged = (location) => {	×
116	if (location !== null) {	×
117	gpsstream.push({ location: { x: location.longitude, y: location.latitude, display: location.display },	×
118	altitude: location.altitude,
119	bearing: location.bearing,
120	speed: location.speed });
121	}
122	};
123	gps.start();	×
124	gpsstream.destroy = () => gps.stop();	×
125	return gpsstream;	×
126	}
127
128	async *get_device() {
129	// TODO use hints
130
131	for (let page = 0; ; page++) {	1✔
132	const devices = await this.engine.thingpedia.getDeviceList(undefined, page, 10);	4✔
133	for (let j = 0; j < Math.min(devices.length, 10); j++) {	4✔
134	const device = devices[j];	40✔
135	yield {	40✔
136	id: new Tp.Value.Entity(device.primary_kind, device.name),
137	description: device.description,
138	category: device.subcategory
139	};
140	}
141	if (devices.length <= 10)	4✔
142	break;	1✔
143	}
144	}
145
146	async get_device_info({ id } : { id : unknown }) {
147	const manifest = await this.engine.schemas.getFullMeta(String(id));	×
148	return [{	×
149	help: manifest.getNaturalLanguageAnnotation('help'),
150	description: manifest.getNaturalLanguageAnnotation('thingpedia_description'),
151	thingpedia_url: manifest.getImplementationAnnotation('thingpedia_url') \|\| `https://almond.stanford.edu/thingpedia/devices/by-id/${id}`,	×
152	website: manifest.getImplementationAnnotation('website'),
153	category: manifest.getImplementationAnnotation('subcategory'),
154	issue_tracker: manifest.getImplementationAnnotation('issue_tracker'),
155	}];
156	}
157
158	async get_commands(params : unknown, hints ?: TT.Runtime.CompiledQueryHints) {
159	let dataset;
160	if (hints && hints.filter) {	1!
161	for (const [pname, op, value] of hints.filter) {	×
162	if (pname === 'device' && op === '==') {	×
163	dataset = this.engine.thingpedia.getExamplesByKinds([String(value)]);	×
164	break;	×
165	} else if (pname === 'device' && op === 'in_array') {	×
166	dataset = this.engine.thingpedia.getExamplesByKinds((value as unknown[]).map((v) => String(v)));	×
167	break;	×
168	}
169	}
170	}
171	if (!dataset)	1!
172	dataset = this.engine.thingpedia.getAllExamples();	1✔
173
174	const code = await dataset;	1✔
175	let parsed;
176	try {	1✔
177	parsed = TT.Syntax.parse(code);	1✔
178	} catch(e) {
179	if (e.name !== 'SyntaxError')	×
180	throw e;	×
181	// try parsing using legacy syntax too in case we're talking
182	// to an old Thingpedia that has not been migrated
183	parsed = TT.Syntax.parse(code, TT.Syntax.SyntaxType.Legacy);	×
184	}
185	await parsed.typecheck(this.engine.schemas, false);	1✔
186	assert(parsed instanceof TT.Ast.Library);	1✔
187
188	return parsed.datasets[0].examples.map((ex) => {	1✔
189	let device;
190	// find the device name for the example
191	ex.visit(new class extends TT.Ast.NodeVisitor {	522✔
192	visitDeviceSelector(sel : TT.Ast.DeviceSelector) {
193	device = sel.kind;	529✔
194	return false;	529✔
195	}
196	});
197	return {	522✔
198	id: String(ex.id),
199	device: device,
200	program: new Tp.Value.Entity(ex.prettyprint(), ex.utterances[0])
201	};
202	});
203	}
204
205	do_faq_reply({ question } : { question : string }) {
206	let replies = (FAQ as Record<string, (string[]\|Record<string,string[]>)>)[question];	×
207	if (!Array.isArray(replies))	×
208	replies = replies[this.platform.type] \|\| replies.default;	×
209
210	if (process.env.TEST_MODE)	×
211	return { reply: replies[0] };	×
212	else
213	return { reply: replies[Math.floor(Math.random()*replies.length)] };	×
214	}
215
216	do_debug_log(args : { message : string }) {
217	console.log('DEBUG:', args.message);	×
218	}
219	do_say(args : { message : string }) {
220	return { message_output: args.message };	1✔
221	}
222	do_open_url({ url } : { url : unknown }) {
223	const cap = this.engine.platform.getCapability('app-launcher');	×
224	if (!cap)	×
225	throw new CustomError('unsupported_platform', `open_url is not supported in ${this.platform.type} platform`);	×
226	return cap.launchURL(String(url));	×
227	}
228
229	do_alert() {}
230
231	do_timer_expire(env : ExecWrapper) {
NEW 232	const now = new Date;	×
NEW 233	const duration = now.getTime() - env.app.metadata.startTime;	×
234
NEW 235	return { duration : duration };	×
236	}
237
238	async do_configure({ device } : { device : unknown }) : Promise<never> {
239	const tpClient = this.engine.thingpedia;	×
240	try {	×
241	await tpClient.getDeviceCode(String(device));	×
242	} catch(e) {
243	if (e.code === 404)	×
244	e.code = 'unsupported_skill';	×
245	throw e;	×
246	}
247
248	// TODO restore the ability to configure skills from inside the dialogue
249	throw new CustomError('unsupported_platform', `not supported`);	×
250
251	/*
252	var conversation = env.app.getConversation();
253	if (!conversation)
254	throw new Error(this.engine._("User not available"));
255	// run it asynchronously, or we'll deadlock
256	Promise.resolve(conversation.interactiveConfigure(String(args.device))).catch((err) => {
257	// the error has already been logged by Almond, and the user has been informed
258	});
259	*/
260	}
261	do_discover(args : unknown, env : ExecWrapper) : never {
262	/*
263	var conversation = env.app.getConversation();
264	if (!conversation)
265	throw new Error(this.engine._("User not available"));
266	// run it asynchronously, or we'll deadlock
267	Promise.resolve(conversation.interactiveConfigure(null)).catch((err) => {
268	// the error has already been logged by Almond, and the user has been informed
269	});
270	*/
271	throw new Error('not implemented');	×
272	}
273
274	do_set_language() : never {
275	throw new CustomError(this.platform.type === 'cloud' ? 'unsupported_platform_cloud' : 'unsupported_language', `not supported`);	×
276	}
277
278	do_set_timezone() : never {
279	throw new CustomError(this.platform.type === 'cloud' ? 'unsupported_platform_cloud' : 'unsupported_platform', `not supported`);	×
280	}
281
282	do_set_wake_word() : never {
283	throw new CustomError('unsupported', `not supported`);	×
284	}
285
286	do_set_voice_output({ status } : { status : 'on'\|'off' }) {
287	const platform = this.platform;	×
288	if (!platform.hasCapability('sound'))	×
289	throw new CustomError('unsupported', `not supported`);	×
290	const prefs = platform.getSharedPreferences();	×
291	// TODO this does not quite work because SpeechHandler doesn't listen
292	// to preference changes
293	prefs.set('enable-voice-output', status === 'on');	×
294	}
295
296	do_set_voice_input({ status } : { status : 'on'\|'off' }) {
297	const platform = this.platform;	×
298	if (!platform.hasCapability('sound'))	×
299	throw new CustomError('unsupported', `not supported`);	×
300	const prefs = platform.getSharedPreferences();	×
301	// TODO this does not quite work because SpeechHandler doesn't listen
302	// to preference changes
303	prefs.set('enable-voice-input', status === 'on');	×
304	}
305
306	do_set_name({ name } : { name : string }) {
307	const platform = this.platform;	×
308	const prefs = platform.getSharedPreferences();	×
309	prefs.set('user-preferred-name', name);	×
310	}
311
312	do_set_location({ type, location } : { type : 'current'\|'home'\|'work', location : Tp.Value.Location }) {
313	const platform = this.platform;	×
314	const prefs = platform.getSharedPreferences();	×
315	prefs.set('context-$context.location.' + (type === 'current' ? 'current_location' : type),	×
316	new TT.Ast.LocationValue(new TT.Ast.AbsoluteLocation(location.lat, location.lon, location.display)).toJS());
317	}
318
319	do_set_temperature_unit({ unit } : { unit : string }) {
320	const platform = this.platform;	×
321	const prefs = platform.getSharedPreferences();	×
322	prefs.set('preferred-temperature', unit[0].toUpperCase());	×
323	}
324	}

stanford-oval / genie-toolkit / 2180

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