1986

pending completion

Build # 1986

Build Type

Pull #564

travis-ci-com

Committed by

web-flow

Commit Message

Merge ee12ebb80 into b74f3c67e

Pull Request Pull Request #564: Changes to enable Genie for COVID

Run Details

12396 of 26117 branches covered (47.46%)

Branch coverage included in aggregate %.

130 of 195 new or added lines in 19 files covered. (66.67%)

324 existing lines in 15 files now uncovered.

28775 of 49014 relevant lines covered (58.71%)

452131.65 hits per line

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

85.59

/lib/dialogue-agent/dialogue_policy.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 { Ast, Type, SchemaRetriever, Syntax } from 'thingtalk';

import * as I18n from '../i18n';
import SentenceGenerator, { SentenceGeneratorOptions } from '../sentence-generator/generator';
import { AgentReplyRecord } from '../sentence-generator/types';
import * as ThingTalkUtils from '../utils/thingtalk';
import { EntityMap } from '../utils/entity-utils';

const MAX_DEPTH = 7;
const TARGET_PRUNING_SIZES = [15, 50, 100];

let TEMPLATE_FILE_PATH : string;
try {
    // try the path relative to our build location first (in dist/lib/dialogue-agent)
    TEMPLATE_FILE_PATH = require.resolve('../../../languages-dist/thingtalk/en/dialogue.genie');
} catch(e) {
    if (e.code !== 'MODULE_NOT_FOUND')
        throw e;
    try {
        // if that fails, try the location relative to our source directory
        // (in case we're running with ts-node)
        TEMPLATE_FILE_PATH = require.resolve('../../languages-dist/thingtalk/en/dialogue.genie');
    } catch(e) {
        if (e.code !== 'MODULE_NOT_FOUND')
            throw e;
        // if that still fails, we're probably in the "compile-template" call
        // in a clean build, so set ourselves empty (it will not matter)
        TEMPLATE_FILE_PATH = '';
    }
}

function arrayEqual<T>(a : T[], b : T[]) : boolean {
    if (a.length !== b.length)
        return false;
    for (let i = 0; i < a.length; i++) {
        if (a[i] !== b[i])
            return false;
    }
    return true;
}

/*interface GeneratorOptions {
    locale : string;
    templateFiles : string[];
    flags : { [key : string] : boolean };
    rootSymbol ?: string;
    targetPruningSize : number;
    maxDepth : number;
    maxConstants : number;
    debug : number;
    rng : () => number;

    thingpediaClient ?: Tp.BaseClient;
    schemaRetriever ?: SchemaRetriever;
    onlyDevices ?: string[];
    whiteList ?: string;

    contextual : true;
    contextInitializer : ContextInitializer;
}*/

interface DialoguePolicyOptions {
    thingpedia : Tp.BaseClient;
    schemas : SchemaRetriever;
    locale : string;
    timezone : string|undefined;
    extraFlags : Record<string, boolean>;
    anonymous : boolean;

    rng : () => number;
    debug : number;
}

// HACK
const MUST_INCLUDE_DEVICES = ['org.thingpedia.covid-vaccine'];

interface PolicyResult {
    state : Ast.DialogueState;
    end : boolean;
    expect : Type|null;
    raw : boolean;
    utterance : string;
    entities : EntityMap;
    numResults : number;
}

function flagEquals(flags : Record<string, boolean>, equalTo : Record<string, boolean>) : boolean {
    for (const key in flags) {
        if (equalTo[key] !== flags[key])
            return false;
    }
    return true;
}

export default class DialoguePolicy {
    private _thingpedia : Tp.BaseClient;
    private _schemas : SchemaRetriever;
    private _locale : string;
    private _timezone : string|undefined;
    private _langPack : I18n.LanguagePack;
    private _rng : () => number;
    private _debug : number;
    private _anonymous : boolean;
    private _extraFlags : Record<string, boolean>;

    private _sentenceGenerator : SentenceGenerator<Ast.DialogueState|null, Ast.DialogueState, AgentReplyRecord<Ast.DialogueState>>|null;
    private _generatorDevices : string[]|null;
    private _generatorOptions : SentenceGeneratorOptions<Ast.DialogueState|null, Ast.DialogueState>|undefined;
    private _entityAllocator : Syntax.SequentialEntityAllocator;

    constructor(options : DialoguePolicyOptions) {
        this._thingpedia = options.thingpedia;
        this._schemas = options.schemas;
        this._locale = options.locale;
        this._timezone = options.timezone;
        this._langPack = I18n.get(options.locale);
        this._entityAllocator = new Syntax.SequentialEntityAllocator({});

        this._rng = options.rng;
        assert(this._rng);
        this._debug = options.debug;
        this._anonymous = options.anonymous;
        this._extraFlags = options.extraFlags;

        this._sentenceGenerator = null;
        this._generatorDevices = null;
        this._generatorOptions = undefined;
    }

    private async _initializeGenerator(forDevices : string[]) {
        console.log('Initializing dialogue policy for devices: ' + forDevices.join(', '));

        this._generatorOptions = {
            contextual: true,
            rootSymbol: '$agent',
            forSide: 'agent',
            flags: {
                dialogues: true,
                inference: true,
                anonymous: this._anonymous,
                ...this._extraFlags
            },
            rng: this._rng,
            locale: this._locale,
            timezone: this._timezone,
            templateFiles: [TEMPLATE_FILE_PATH],
            thingpediaClient: this._thingpedia,
            schemaRetriever: this._schemas,
            entityAllocator: this._entityAllocator,
            onlyDevices: forDevices,
            maxDepth: MAX_DEPTH,
            maxConstants: 5,
            targetPruningSize: TARGET_PRUNING_SIZES[0],
            debug: this._debug,

            contextInitializer: (state, functionTable, contextTable) => {
                // ask the target language to extract the constants from the context
                this._entityAllocator.reset();
                if (state !== null) {
                    const constants = ThingTalkUtils.extractConstants(state, this._entityAllocator);
                    sentenceGenerator.addConstantsFromContext(constants);
                }
                return functionTable.context!(state, contextTable);
            }
        };
        const sentenceGenerator = new SentenceGenerator<Ast.DialogueState|null, Ast.DialogueState, AgentReplyRecord<Ast.DialogueState>>(this._generatorOptions!);
        this._sentenceGenerator = sentenceGenerator;
        this._generatorDevices = forDevices;
        await this._sentenceGenerator.initialize();
    }

    private _extractDevices(state : Ast.DialogueState|Ast.Program|null) : string[] {
        if (state === null)
            return MUST_INCLUDE_DEVICES;
        const devices = new Set<string>();
        state.visit(new class extends Ast.NodeVisitor {
            visitDeviceSelector(selector : Ast.DeviceSelector) : boolean {
                devices.add(selector.kind);
                return true;
            }
        });
        for (const d of MUST_INCLUDE_DEVICES)
            devices.add(d);
        const deviceArray = Array.from(devices);
        deviceArray.sort();
        return deviceArray;
    }

    private async _ensureGeneratorForState(state : Ast.DialogueState|Ast.Program|null) {
        const devices = this._extractDevices(state);
        if (this._generatorDevices && arrayEqual(this._generatorDevices, devices)
            && flagEquals(this._extraFlags, this._generatorOptions!.flags))
            return;
        await this._initializeGenerator(devices);
    }

    async handleAnswer(state : Ast.DialogueState|null, value : Ast.Value) : Promise<Ast.DialogueState|null> {
        if (state === null)
            return null;
        await this._ensureGeneratorForState(state);
        return this._sentenceGenerator!.invokeFunction('answer', state, value, this._sentenceGenerator!.contextTable);
    }

    private _generateDerivation(state : Ast.DialogueState|null) {
        let derivation;

        // try with a low pruning size first, because that's faster, and then increase
        // the pruning size if we don't find anything useful
        for (const pruningSize of TARGET_PRUNING_SIZES) {
            this._generatorOptions!.targetPruningSize = pruningSize;
            derivation = this._sentenceGenerator!.generateOne(state);
            if (derivation !== undefined)
                break;
        }
        return derivation;
    }

    async chooseAction(state : Ast.DialogueState|null) : Promise<PolicyResult|undefined> {
        await this._ensureGeneratorForState(state);

        const derivation = this._generateDerivation(state);
        if (derivation === undefined)
            return derivation;

        let utterance = derivation.chooseBestSentence();
        utterance = this._langPack.postprocessSynthetic(utterance, derivation.value.state, this._rng, 'agent');

        return {
            state: derivation.value.state,
            end: derivation.value.end,
            expect: derivation.value.expect,
            raw: derivation.value.raw,
            utterance,
            entities: this._entityAllocator.entities,
            numResults: derivation.value.numResults
        };
    }

    async getFollowUp(state : Ast.DialogueState) : Promise<Ast.DialogueState|null> {
        await this._ensureGeneratorForState(state);

        return this._sentenceGenerator!.invokeFunction('followUp', state, this._sentenceGenerator!.contextTable);
    }

    async getNotificationState(appName : string|null, program : Ast.Program, result : Ast.DialogueHistoryResultItem) {
        await this._ensureGeneratorForState(program);

        return this._sentenceGenerator!.invokeFunction('notification', appName, program, result, this._sentenceGenerator!.contextTable);
    }

    async getAsyncErrorState(appName : string|null, program : Ast.Program, error : Ast.Value) {
        await this._ensureGeneratorForState(program);

        return this._sentenceGenerator!.invokeFunction('notifyError', appName, program, error, this._sentenceGenerator!.contextTable);
    }

    async getInitialState() {
        await this._ensureGeneratorForState(null);
        return this._sentenceGenerator!.invokeFunction('initialState', this._sentenceGenerator!.contextTable);
    }
}

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
22	import assert from 'assert';	97✔
23	import * as Tp from 'thingpedia';
24	import { Ast, Type, SchemaRetriever, Syntax } from 'thingtalk';	97✔
25
26	import * as I18n from '../i18n';	97✔
27	import SentenceGenerator, { SentenceGeneratorOptions } from '../sentence-generator/generator';	97✔
28	import { AgentReplyRecord } from '../sentence-generator/types';
29	import * as ThingTalkUtils from '../utils/thingtalk';	97✔
30	import { EntityMap } from '../utils/entity-utils';
31
32	const MAX_DEPTH = 7;	97✔
33	const TARGET_PRUNING_SIZES = [15, 50, 100];	97✔
34
35	let TEMPLATE_FILE_PATH : string;
36	try {	97✔
37	// try the path relative to our build location first (in dist/lib/dialogue-agent)
38	TEMPLATE_FILE_PATH = require.resolve('../../../languages-dist/thingtalk/en/dialogue.genie');	97✔
39	} catch(e) {
40	if (e.code !== 'MODULE_NOT_FOUND')	3!
41	throw e;	×
42	try {	3✔
43	// if that fails, try the location relative to our source directory
44	// (in case we're running with ts-node)
45	TEMPLATE_FILE_PATH = require.resolve('../../languages-dist/thingtalk/en/dialogue.genie');	3✔
46	} catch(e) {
47	if (e.code !== 'MODULE_NOT_FOUND')	×
48	throw e;	×
49	// if that still fails, we're probably in the "compile-template" call
50	// in a clean build, so set ourselves empty (it will not matter)
51	TEMPLATE_FILE_PATH = '';	×
52	}
53	}
54
55	function arrayEqual<T>(a : T[], b : T[]) : boolean {
56	if (a.length !== b.length)	268✔
57	return false;	12✔
58	for (let i = 0; i < a.length; i++) {	256✔
59	if (a[i] !== b[i])	456✔
60	return false;	25✔
61	}
62	return true;	231✔
63	}
64
65	/*interface GeneratorOptions {
66	locale : string;
67	templateFiles : string[];
68	flags : { [key : string] : boolean };
69	rootSymbol ?: string;
70	targetPruningSize : number;
71	maxDepth : number;
72	maxConstants : number;
73	debug : number;
74	rng : () => number;
75
76	thingpediaClient ?: Tp.BaseClient;
77	schemaRetriever ?: SchemaRetriever;
78	onlyDevices ?: string[];
79	whiteList ?: string;
80
81	contextual : true;
82	contextInitializer : ContextInitializer;
83	}*/
84
85	interface DialoguePolicyOptions {
86	thingpedia : Tp.BaseClient;
87	schemas : SchemaRetriever;
88	locale : string;
89	timezone : string\|undefined;
90	extraFlags : Record<string, boolean>;
91	anonymous : boolean;
92
93	rng : () => number;
94	debug : number;
95	}
96
97	// HACK
98	const MUST_INCLUDE_DEVICES = ['org.thingpedia.covid-vaccine'];	97✔
99
100	interface PolicyResult {
101	state : Ast.DialogueState;
102	end : boolean;
103	expect : Type\|null;
104	raw : boolean;
105	utterance : string;
106	entities : EntityMap;
107	numResults : number;
108	}
109
110	function flagEquals(flags : Record<string, boolean>, equalTo : Record<string, boolean>) : boolean {
111	for (const key in flags) {	231✔
112	if (equalTo[key] !== flags[key])	176!
NEW 113	return false;	×
114	}
115	return true;	231✔
116	}
117
118	export default class DialoguePolicy {	97✔
119	private _thingpedia : Tp.BaseClient;
120	private _schemas : SchemaRetriever;
121	private _locale : string;
122	private _timezone : string\|undefined;
123	private _langPack : I18n.LanguagePack;
124	private _rng : () => number;
125	private _debug : number;
126	private _anonymous : boolean;
127	private _extraFlags : Record<string, boolean>;
128
129	private _sentenceGenerator : SentenceGenerator<Ast.DialogueState\|null, Ast.DialogueState, AgentReplyRecord<Ast.DialogueState>>\|null;
130	private _generatorDevices : string[]\|null;
131	private _generatorOptions : SentenceGeneratorOptions<Ast.DialogueState\|null, Ast.DialogueState>\|undefined;
132	private _entityAllocator : Syntax.SequentialEntityAllocator;
133
134	constructor(options : DialoguePolicyOptions) {
135	this._thingpedia = options.thingpedia;	35✔
136	this._schemas = options.schemas;	35✔
137	this._locale = options.locale;	35✔
138	this._timezone = options.timezone;	35✔
139	this._langPack = I18n.get(options.locale);	35✔
140	this._entityAllocator = new Syntax.SequentialEntityAllocator({});	35✔
141
142	this._rng = options.rng;	35✔
143	assert(this._rng);	35✔
144	this._debug = options.debug;	35✔
145	this._anonymous = options.anonymous;	35✔
146	this._extraFlags = options.extraFlags;	35✔
147
148	this._sentenceGenerator = null;	35✔
149	this._generatorDevices = null;	35✔
150	this._generatorOptions = undefined;	35✔
151	}
152
153	private async _initializeGenerator(forDevices : string[]) {
154	console.log('Initializing dialogue policy for devices: ' + forDevices.join(', '));	42✔
155
156	this._generatorOptions = {	42✔
157	contextual: true,
158	rootSymbol: '$agent',
159	forSide: 'agent',
160	flags: {
161	dialogues: true,
162	inference: true,
163	anonymous: this._anonymous,
164	...this._extraFlags
165	},
166	rng: this._rng,
167	locale: this._locale,
168	timezone: this._timezone,
169	templateFiles: [TEMPLATE_FILE_PATH],
170	thingpediaClient: this._thingpedia,
171	schemaRetriever: this._schemas,
172	entityAllocator: this._entityAllocator,
173	onlyDevices: forDevices,
174	maxDepth: MAX_DEPTH,
175	maxConstants: 5,
176	targetPruningSize: TARGET_PRUNING_SIZES[0],
177	debug: this._debug,
178
179	contextInitializer: (state, functionTable, contextTable) => {
180	// ask the target language to extract the constants from the context
181	this._entityAllocator.reset();	146✔
182	if (state !== null) {	146!
183	const constants = ThingTalkUtils.extractConstants(state, this._entityAllocator);	146✔
184	sentenceGenerator.addConstantsFromContext(constants);	146✔
185	}
186	return functionTable.context!(state, contextTable);	146✔
187	}
188	};
189	const sentenceGenerator = new SentenceGenerator<Ast.DialogueState\|null, Ast.DialogueState, AgentReplyRecord<Ast.DialogueState>>(this._generatorOptions!);	42✔
190	this._sentenceGenerator = sentenceGenerator;	42✔
191	this._generatorDevices = forDevices;	42✔
192	await this._sentenceGenerator.initialize();	42✔
193	}
194
195	private _extractDevices(state : Ast.DialogueState\|Ast.Program\|null) : string[] {
196	if (state === null)	273✔
197	return MUST_INCLUDE_DEVICES;	1✔
198	const devices = new Set<string>();	272✔
199	state.visit(new class extends Ast.NodeVisitor {	272✔
200	visitDeviceSelector(selector : Ast.DeviceSelector) : boolean {
201	devices.add(selector.kind);	357✔
202	return true;	357✔
203	}
204	});
205	for (const d of MUST_INCLUDE_DEVICES)	272✔
206	devices.add(d);	272✔
207	const deviceArray = Array.from(devices);	272✔
208	deviceArray.sort();	272✔
209	return deviceArray;	272✔
210	}
211
212	private async _ensureGeneratorForState(state : Ast.DialogueState\|Ast.Program\|null) {
213	const devices = this._extractDevices(state);	273✔
214	if (this._generatorDevices && arrayEqual(this._generatorDevices, devices)	273✔
215	&& flagEquals(this._extraFlags, this._generatorOptions!.flags))
216	return;	231✔
217	await this._initializeGenerator(devices);	42✔
218	}
219
220	async handleAnswer(state : Ast.DialogueState\|null, value : Ast.Value) : Promise<Ast.DialogueState\|null> {
221	if (state === null)	13!
222	return null;	×
223	await this._ensureGeneratorForState(state);	13✔
224	return this._sentenceGenerator!.invokeFunction('answer', state, value, this._sentenceGenerator!.contextTable);	13✔
225	}
226
227	private _generateDerivation(state : Ast.DialogueState\|null) {
228	let derivation;
229
230	// try with a low pruning size first, because that's faster, and then increase
231	// the pruning size if we don't find anything useful
232	for (const pruningSize of TARGET_PRUNING_SIZES) {	146✔
233	this._generatorOptions!.targetPruningSize = pruningSize;	146✔
234	derivation = this._sentenceGenerator!.generateOne(state);	146✔
235	if (derivation !== undefined)	146!
236	break;	146✔
237	}
238	return derivation;	146✔
239	}
240
241	async chooseAction(state : Ast.DialogueState\|null) : Promise<PolicyResult\|undefined> {
242	await this._ensureGeneratorForState(state);	146✔
243
244	const derivation = this._generateDerivation(state);	146✔
245	if (derivation === undefined)	146!
246	return derivation;	×
247
248	let utterance = derivation.chooseBestSentence();	146✔
249	utterance = this._langPack.postprocessSynthetic(utterance, derivation.value.state, this._rng, 'agent');	146✔
250
251	return {	146✔
252	state: derivation.value.state,
253	end: derivation.value.end,
254	expect: derivation.value.expect,
255	raw: derivation.value.raw,
256	utterance,
257	entities: this._entityAllocator.entities,
258	numResults: derivation.value.numResults
259	};
260	}
261
262	async getFollowUp(state : Ast.DialogueState) : Promise<Ast.DialogueState\|null> {
263	await this._ensureGeneratorForState(state);	86✔
264
265	return this._sentenceGenerator!.invokeFunction('followUp', state, this._sentenceGenerator!.contextTable);	86✔
266	}
267
268	async getNotificationState(appName : string\|null, program : Ast.Program, result : Ast.DialogueHistoryResultItem) {
269	await this._ensureGeneratorForState(program);	27✔
270
271	return this._sentenceGenerator!.invokeFunction('notification', appName, program, result, this._sentenceGenerator!.contextTable);	27✔
272	}
273
274	async getAsyncErrorState(appName : string\|null, program : Ast.Program, error : Ast.Value) {
275	await this._ensureGeneratorForState(program);	×
276
277	return this._sentenceGenerator!.invokeFunction('notifyError', appName, program, error, this._sentenceGenerator!.contextTable);	×
278	}
279
280	async getInitialState() {
281	await this._ensureGeneratorForState(null);	1✔
282	return this._sentenceGenerator!.invokeFunction('initialState', this._sentenceGenerator!.contextTable);	1✔
283	}
284	}

stanford-oval / genie-toolkit / 1986

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