1200

pending completion

Build # 1200

Build Type

Pull #281

travis-ci-com

Committed by

web-flow

Commit Message

Merge 49f822d66 into 0334fb50c

Pull Request Pull Request #281: minor tweaks to improve agent response

Run Details

6654 of 12586 branches covered (52.87%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 2 files covered. (100.0%)

37 existing lines in 6 files now uncovered.

15333 of 24279 relevant lines covered (63.15%)

1215955.68 hits per line

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

52.0

/lib/dialogue-agent/execution/statement_simulator.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 assert = require('assert');

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

const { collectDisambiguationHints, getBestEntityMatch } = require('../entity-linking/entity-finder');
const {
    ResultGenerator,
    SimulationExecEnvironment,
    SimulatedError
} = require('./simulation_exec_environment');

// above MORE_SIZE, we set the "more" bit
const MORE_SIZE = 50;
// above PAGE_SIZE, we set the count but don't actually show the full list of results
const PAGE_SIZE = 10;

class ThingTalkSimulatorState {
    constructor(options) {
        this._locale = options.locale;
        this._schemas = options.schemaRetriever;
        this._rng = options.rng;
        this._database = options.database;
        this._overrides = options.overrides || new Map;

        this._execEnv = new SimulationExecEnvironment(this._locale, this._schemas, this._database, {
            rng: this._rng
        });
        this._previousIdEntities = new Map;
    }

     async compile(stmt, cache) {
        const clone = stmt.clone();

        const previousIdEntities = this._previousIdEntities;
        clone.visit(new class extends Ast.NodeVisitor {
            visitValue(value) {
                if (value.isLocation && value.value.isRelative) {
                    switch (value.value.relativeTag) {
                    case 'current_location':
                        value.value = new Ast.Location.Absolute(2, 2, 'here');
                        break;
                    case 'home':
                        value.value = new Ast.Location.Absolute(3, 3, 'home');
                        break;
                    case 'work':
                        value.value = new Ast.Location.Absolute(4, 4, 'work');
                        break;
                    }
                }
                if (value.isEntity && value.value === null) {
                    const resolved = getBestEntityMatch(value.display, value.type,
                        previousIdEntities.get(value.type) || []);
                    if (resolved) {
                        value.value = resolved.value;
                        value.display = resolved.name;
                    }
                }
                assert(value.isConcrete());
                return true;
            }
        });

        const program = new Ast.Program(null, [], [], [clone]);
        const cacheKey = program.prettyprint();
        //console.error(cacheKey);

        let compiled = cache.get(cacheKey);
        if (compiled)
            return compiled;

        try {
            const compiler = new ThingTalk.Compiler(this._schemas);

            compiled = await compiler.compileProgram(program);
            assert(compiled.rules.length === 0);
            cache.set(cacheKey, compiled);
        } catch(e) {
            console.error(`Failed to compile program: ` + e.message);
            console.error(program.prettyprint());
            throw e;
        }
        return compiled;
    }

    async simulate(stmt, compiled) {
        const results = [];
        let error = null;
        const generator = new ResultGenerator(this._rng, this._overrides);
        for (let slot of stmt.iterateSlots2()) {
            if (slot instanceof Ast.Selector)
                continue;
            generator.addCandidate(slot.get());
        }
        this._execEnv.generator = generator;
        this._execEnv.output = async (outputType, outputValue) => {
            const mapped = new Ast.DialogueHistoryResultItem(null, await this._mapResult(outputType, outputValue));
            collectDisambiguationHints(mapped, this._previousIdEntities);
            results.push(mapped);
        };
        this._execEnv.reportError = async (msg, err) => {
            if (!(err instanceof SimulatedError)) {
                console.error(`Failed to execute program`);
                console.error(msg, err);
                console.error(new Ast.Program(null, [], [], [stmt]).prettyprint());
                process.exit(1);
                return;
            }
            if (err.code)
                error = new Ast.Value.Enum(err.code);
            else
                error = new Ast.Value.String(err.message);
        };

        try {
            await compiled.command(this._execEnv);
        } catch(e) {
            console.error(`Failed to execute program: ` + e.message);
            console.error(new Ast.Program(null, [], [], [stmt]).prettyprint());
            throw e;
        }

        const numResults = results.length;
        return new Ast.DialogueHistoryResultList(null, results.slice(0, PAGE_SIZE),
            new Ast.Value.Number(Math.min(MORE_SIZE, numResults)), numResults > MORE_SIZE, error);
    }

    _inferType(jsValue) {
        if (typeof jsValue === 'boolean')
            return Type.Boolean;
        if (typeof jsValue === 'string')
            return Type.String;
        if (typeof jsValue === 'number')
            return Type.Number;
        if (jsValue instanceof ThingTalk.Builtin.Currency)
            return Type.Currency;
        if (jsValue instanceof ThingTalk.Builtin.Entity)
            return Type.Entity('');
        if (jsValue instanceof ThingTalk.Builtin.Time)
            return Type.Time;
        if (jsValue instanceof Date)
            return Type.Date;
        if (Array.isArray(jsValue) && jsValue.length > 0)
            return Type.Array(this._inferType(jsValue[0]));
        if (Array.isArray(jsValue))
            return Type.Array(Type.Any);

        return Type.Any;
    }

    _outputTypeToSchema(outputType) {
        let [kind, fname] = outputType.split(':');
        let ftype = 'query';
        if (fname.startsWith('action/')) {
            ftype = 'action';
            fname = fname.substring('action/'.length);
        }
        return this._schemas.getSchemaAndNames(kind, ftype, fname);
    }

    async _mapResult(outputType, outputValue) {
        const mappedResult = {};
        if (outputType === null) {
            // fallback
            for (let key in outputValue) {
                const jsValue = outputValue[key];
                mappedResult[key] = Ast.Value.fromJS(this._inferType(jsValue), jsValue);
            }
            return mappedResult;
        }

        if (outputType.indexOf('+') >= 0) {
            let types = outputType.split('+');
            outputType = types[types.length-1];
        }

        const aggregation = /^([a-zA-Z]+)\(([^)]+)\)$/.exec(outputType);
        if (aggregation !== null) {
            let operator;
            [, operator, outputType] = aggregation;

            const field = Object.keys(outputValue)[0];
            const value = outputValue[field];
            if (operator === 'count') {
                mappedResult[field] = Ast.Value.fromJS(Type.Number, outputValue[field]);
                return mappedResult;
            }

            const schema = await this._outputTypeToSchema(outputType);
            const type = schema.getArgType(field) || this._inferType(value);
            mappedResult[field] = Ast.Value.fromJS(type, value);
        } else {
            const schema = await this._outputTypeToSchema(outputType);

            for (let key in outputValue) {
                const value = outputValue[key];
                if (value === null || value === undefined)
                    continue;
                const type = schema.getArgType(key) || this._inferType(value);
                if (type.isCompound)
                    mappedResult[key] = this._mapCompound(key + '.', schema, value);
                else
                    mappedResult[key] = Ast.Value.fromJS(type, value);
            }
        }
        return mappedResult;
    }

    _mapCompound(prefix, schema, object) {
        let result = {};
        for (let key in object) {
            const value = object[key];
            const type = schema.getArgType(prefix + key) || this._inferType(value);
            if (type.isCompound)
                result[key] = this._mapCompound(prefix + key + '.', type, object);
            else
                result[key] = Ast.Value.fromJS(type, value);
        }
        return new Ast.Value.Object(result);
    }
}

/**
 * Simulate the execution of ThingTalk code.
 */
class ThingTalkStatementSimulator {
    constructor(options) {
        this._options = options;
        this.cache = new Map;
    }

    async executeStatement(stmt, execState) {
        assert(stmt instanceof Ast.Statement.Command || stmt instanceof Ast.Statement.Rule);

        if (stmt instanceof Ast.Statement.Rule) {
            // nothing to do, this always returns nothing
            return [[], execState];
        }

        if (execState === undefined)
            execState = new ThingTalkSimulatorState(this._options);

        // there is no way around this, we need to compile and run the program!
        const compiled = await execState.compile(stmt, this.cache);
        const resultList = await execState.simulate(stmt, compiled);
        return [resultList, execState];
    }
}
module.exports = ThingTalkStatementSimulator;

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 assert = require('assert');	13✔
23
24	const ThingTalk = require('thingtalk');	13✔
25	const Ast = ThingTalk.Ast;	13✔
26	const Type = ThingTalk.Type;	13✔
27
28	const { collectDisambiguationHints, getBestEntityMatch } = require('../entity-linking/entity-finder');	13✔
29	const {
30	ResultGenerator,
31	SimulationExecEnvironment,
32	SimulatedError
33	} = require('./simulation_exec_environment');	13✔
34
35	// above MORE_SIZE, we set the "more" bit
36	const MORE_SIZE = 50;	13✔
37	// above PAGE_SIZE, we set the count but don't actually show the full list of results
38	const PAGE_SIZE = 10;	13✔
39
40	class ThingTalkSimulatorState {
41	constructor(options) {
42	this._locale = options.locale;	1,770✔
43	this._schemas = options.schemaRetriever;	1,770✔
44	this._rng = options.rng;	1,770✔
45	this._database = options.database;	1,770✔
46	this._overrides = options.overrides \|\| new Map;	1,770✔
47
48	this._execEnv = new SimulationExecEnvironment(this._locale, this._schemas, this._database, {	1,770✔
49	rng: this._rng
50	});
51	this._previousIdEntities = new Map;	1,770✔
52	}
53
54	async compile(stmt, cache) {
55	const clone = stmt.clone();	4,807✔
56
57	const previousIdEntities = this._previousIdEntities;	4,807✔
58	clone.visit(new class extends Ast.NodeVisitor {	4,807✔
59	visitValue(value) {
60	if (value.isLocation && value.value.isRelative) {	13,536!
61	switch (value.value.relativeTag) {	×
62	case 'current_location':
63	value.value = new Ast.Location.Absolute(2, 2, 'here');	×
64	break;	×
65	case 'home':
66	value.value = new Ast.Location.Absolute(3, 3, 'home');	×
67	break;	×
68	case 'work':
69	value.value = new Ast.Location.Absolute(4, 4, 'work');	×
70	break;	×
71	}
72	}
73	if (value.isEntity && value.value === null) {	13,536!
74	const resolved = getBestEntityMatch(value.display, value.type,	×
75	previousIdEntities.get(value.type) \|\| []);	×
76	if (resolved) {	×
77	value.value = resolved.value;	×
78	value.display = resolved.name;	×
79	}
80	}
81	assert(value.isConcrete());	13,536✔
82	return true;	13,536✔
83	}
84	});
85
86	const program = new Ast.Program(null, [], [], [clone]);	4,807✔
87	const cacheKey = program.prettyprint();	4,807✔
88	//console.error(cacheKey);
89
90	let compiled = cache.get(cacheKey);	4,807✔
91	if (compiled)	4,807✔
92	return compiled;	2,368✔
93
94	try {	2,439✔
95	const compiler = new ThingTalk.Compiler(this._schemas);	2,439✔
96
97	compiled = await compiler.compileProgram(program);	2,439✔
98	assert(compiled.rules.length === 0);	2,439✔
99	cache.set(cacheKey, compiled);	2,439✔
100	} catch(e) {
101	console.error(`Failed to compile program: ` + e.message);	×
102	console.error(program.prettyprint());	×
103	throw e;	×
104	}
105	return compiled;	2,439✔
106	}
107
108	async simulate(stmt, compiled) {
109	const results = [];	4,807✔
110	let error = null;	4,807✔
111	const generator = new ResultGenerator(this._rng, this._overrides);	4,807✔
112	for (let slot of stmt.iterateSlots2()) {	4,807✔
113	if (slot instanceof Ast.Selector)	18,343✔
114	continue;	4,807✔
115	generator.addCandidate(slot.get());	13,536✔
116	}
117	this._execEnv.generator = generator;	4,807✔
118	this._execEnv.output = async (outputType, outputValue) => {	4,807✔
119	const mapped = new Ast.DialogueHistoryResultItem(null, await this._mapResult(outputType, outputValue));	69,262✔
120	collectDisambiguationHints(mapped, this._previousIdEntities);	69,262✔
121	results.push(mapped);	69,262✔
122	};
123	this._execEnv.reportError = async (msg, err) => {	4,807✔
124	if (!(err instanceof SimulatedError)) {	53!
125	console.error(`Failed to execute program`);	×
126	console.error(msg, err);	×
127	console.error(new Ast.Program(null, [], [], [stmt]).prettyprint());	×
128	process.exit(1);	×
129	return;	×
130	}
131	if (err.code)	53!
132	error = new Ast.Value.Enum(err.code);	53✔
133	else
UNCOV 134	error = new Ast.Value.String(err.message);	×
135	};
136
137	try {	4,807✔
138	await compiled.command(this._execEnv);	4,807✔
139	} catch(e) {
140	console.error(`Failed to execute program: ` + e.message);	×
141	console.error(new Ast.Program(null, [], [], [stmt]).prettyprint());	×
142	throw e;	×
143	}
144
145	const numResults = results.length;	4,807✔
146	return new Ast.DialogueHistoryResultList(null, results.slice(0, PAGE_SIZE),	4,807✔
147	new Ast.Value.Number(Math.min(MORE_SIZE, numResults)), numResults > MORE_SIZE, error);
148	}
149
150	_inferType(jsValue) {
151	if (typeof jsValue === 'boolean')	×
152	return Type.Boolean;	×
153	if (typeof jsValue === 'string')	×
154	return Type.String;	×
155	if (typeof jsValue === 'number')	×
156	return Type.Number;	×
157	if (jsValue instanceof ThingTalk.Builtin.Currency)	×
158	return Type.Currency;	×
159	if (jsValue instanceof ThingTalk.Builtin.Entity)	×
160	return Type.Entity('');	×
161	if (jsValue instanceof ThingTalk.Builtin.Time)	×
162	return Type.Time;	×
163	if (jsValue instanceof Date)	×
164	return Type.Date;	×
165	if (Array.isArray(jsValue) && jsValue.length > 0)	×
166	return Type.Array(this._inferType(jsValue[0]));	×
167	if (Array.isArray(jsValue))	×
168	return Type.Array(Type.Any);	×
169
170	return Type.Any;	×
171	}
172
173	_outputTypeToSchema(outputType) {
174	let [kind, fname] = outputType.split(':');	69,257✔
175	let ftype = 'query';	69,257✔
176	if (fname.startsWith('action/')) {	69,257✔
177	ftype = 'action';	402✔
178	fname = fname.substring('action/'.length);	402✔
179	}
180	return this._schemas.getSchemaAndNames(kind, ftype, fname);	69,257✔
181	}
182
183	async _mapResult(outputType, outputValue) {
184	const mappedResult = {};	69,262✔
185	if (outputType === null) {	69,262!
186	// fallback
187	for (let key in outputValue) {	×
188	const jsValue = outputValue[key];	×
189	mappedResult[key] = Ast.Value.fromJS(this._inferType(jsValue), jsValue);	×
190	}
191	return mappedResult;	×
192	}
193
194	if (outputType.indexOf('+') >= 0) {	69,262!
195	let types = outputType.split('+');	×
196	outputType = types[types.length-1];	×
197	}
198
199	const aggregation = /^([a-zA-Z]+)\(([^)]+)\)$/.exec(outputType);	69,262✔
200	if (aggregation !== null) {	69,262✔
201	let operator;
202	[, operator, outputType] = aggregation;	5✔
203
204	const field = Object.keys(outputValue)[0];	5✔
205	const value = outputValue[field];	5✔
206	if (operator === 'count') {	5!
207	mappedResult[field] = Ast.Value.fromJS(Type.Number, outputValue[field]);	5✔
208	return mappedResult;	5✔
209	}
210
211	const schema = await this._outputTypeToSchema(outputType);	×
212	const type = schema.getArgType(field) \|\| this._inferType(value);	×
213	mappedResult[field] = Ast.Value.fromJS(type, value);	×
214	} else {
215	const schema = await this._outputTypeToSchema(outputType);	69,257✔
216
217	for (let key in outputValue) {	69,257✔
218	const value = outputValue[key];	421,200✔
219	if (value === null \|\| value === undefined)	421,200!
220	continue;	×
221	const type = schema.getArgType(key) \|\| this._inferType(value);	421,200!
222	if (type.isCompound)	421,200!
223	mappedResult[key] = this._mapCompound(key + '.', schema, value);	×
224	else
225	mappedResult[key] = Ast.Value.fromJS(type, value);	421,200✔
226	}
227	}
228	return mappedResult;	69,257✔
229	}
230
231	_mapCompound(prefix, schema, object) {
232	let result = {};	×
233	for (let key in object) {	×
234	const value = object[key];	×
235	const type = schema.getArgType(prefix + key) \|\| this._inferType(value);	×
236	if (type.isCompound)	×
237	result[key] = this._mapCompound(prefix + key + '.', type, object);	×
238	else
239	result[key] = Ast.Value.fromJS(type, value);	×
240	}
241	return new Ast.Value.Object(result);	×
242	}
243	}
244
245	/**
246	* Simulate the execution of ThingTalk code.
247	*/
248	class ThingTalkStatementSimulator {
249	constructor(options) {
250	this._options = options;	2✔
251	this.cache = new Map;	2✔
252	}
253
254	async executeStatement(stmt, execState) {
255	assert(stmt instanceof Ast.Statement.Command \|\| stmt instanceof Ast.Statement.Rule);	4,807!
256
257	if (stmt instanceof Ast.Statement.Rule) {	4,807!
258	// nothing to do, this always returns nothing
259	return [[], execState];	×
260	}
261
262	if (execState === undefined)	4,807✔
263	execState = new ThingTalkSimulatorState(this._options);	1,770✔
264
265	// there is no way around this, we need to compile and run the program!
266	const compiled = await execState.compile(stmt, this.cache);	4,807✔
267	const resultList = await execState.simulate(stmt, compiled);	4,807✔
268	return [resultList, execState];	4,807✔
269	}
270	}
271	module.exports = ThingTalkStatementSimulator;	13✔

stanford-oval / genie-toolkit / 1200

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