1180

pending completion

Build # 1180

Build Type

Pull #275

travis-ci-com

Committed by

web-flow

Commit Message

Merge 8852d0e33 into 1137d6898

Pull Request Pull Request #275: agent tests with manually written simulation data

Run Details

6815 of 12543 branches covered (54.33%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

15530 of 24193 relevant lines covered (64.19%)

1231400.82 hits per line

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

81.56

/lib/dialogue-agent/execution/simulation_exec_environment.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 { coin, uniform, randint } = require('../../utils/random');

class ResultGenerator {
    constructor(rng, overrides) {
        this._rng = rng;

        this._overrides = overrides;
        this._candidates = new Map;
        this._constants = new Map;
        this._results = [];
    }

    _doAddCandidate(key, jsValue) {
        let candidates = this._candidates.get(key);
        if (candidates === undefined) {
            candidates = [];
            this._candidates.set(key, candidates);
        }
        candidates.push(jsValue);
    }

    addCandidate(value) {
        if (value.isArray || !value.isConstant())
            return;

        if (value.isBoolean || value.isEnum)
            return;

        const jsValue = value.toJS();

        if (value.isString)
            this._doAddCandidate('QUOTED_STRING', jsValue);
        else if (value.isNumber)
            this._doAddCandidate('NUMBER', jsValue);
        else if (value.isCurrency)
            this._doAddCandidate('CURRENCY', jsValue.value);
        else if (value.isMeasure)
            this._doAddCandidate('MEASURE_' + value.getType().type, jsValue);
        else if (value.isTime)
            this._doAddCandidate('TIME', jsValue);
        else if (value.isDate)
            this._doAddCandidate('DATE', jsValue);
        else if (value.isLocation)
            this._doAddCandidate('LOCATION', jsValue);
        else if (value.isEntity)
            this._doAddCandidate('ENTITY_' + value.type, String(jsValue));
    }

    generate(schema, params, index) {
        let result = {};
        Object.assign(result, params);
        for (let arg of schema.iterateArguments()) {
            if (arg.direction !== Ast.ArgDirection.OUT)
                continue;
            if (arg.name.indexOf('.') >= 0)
                continue;
            if (this._overrides.has(arg.name))
                result[arg.name] = this._overrides.get(arg.name);
            else if (arg.name === 'id' && arg.type.isEntity)
                result[arg.name] = new ThingTalk.Builtin.Entity(`str:ENTITY_${arg.type.type}::${index}:`, null);
            else
                result[arg.name] = this._generateValue(arg.type, arg.name !== 'id', arg);
        }
        return result;
    }

    _generateValue(type, repeatable = true, arg) {
        if (type.isCompound) {
            let result = {};
            for (let field in type.fields) {
                const arg = type.fields[field];
                assert(arg instanceof Ast.ArgumentDef);
                result[field] = this._generateValue(arg.type, true, arg);
            }
            return result;
        }

        if (type.isArray) {
            let length = randint(1, 3, this._rng);
            let buffer = [];
            // do not repeat values inside the array
            for (let i = 0; i < length; i++)
                buffer.push(this._generateValue(type.elem, false, arg));
            return buffer;
        }

        if (type.isBoolean)
            return !!coin(0.5, this._rng);
        if (type.isString)
            return this._generateString(`QUOTED_STRING`, repeatable);
        if (type.isNumber)
            return this._generateNumber(`NUMBER`, repeatable, arg);
        if (type.isMeasure)
            return this._generateNumber(`MEASURE_` + type.unit, repeatable, arg);
        if (type.isCurrency)
            return new ThingTalk.Builtin.Currency(this._generateNumber(`CURRENCY`, repeatable), 'usd');
        if (type.isTime)
            return this._generateTime(repeatable);
        if (type.isDate)
            return this._generateDate(repeatable);
        if (type.isLocation)
            return this._generateLocation(repeatable);
        if (type.isEnum)
            return uniform(type.entries, this._rng);
        if (type.isEntity)
            return new ThingTalk.Builtin.Entity(this._generateString('ENTITY_' + type.type, repeatable), null);

        throw new TypeError(`Invalid constant of type ${type}`);
    }

    _generateTime(repeatable) {
        const reused = this._reuseConstant('TIME', repeatable);
        if (reused !== undefined)
            return reused;

        const newTime = new ThingTalk.Builtin.Time(randint(0, 23), randint(0, 59), 0);
        this._constants.get('TIME').push(newTime);
        return newTime;
    }

    _generateDate(repeatable) {
        const reused = this._reuseConstant('DATE', repeatable);
        if (reused !== undefined)
            return reused;

        const num = this._generateNumber('DATE::number', repeatable);
        assert(Number.isFinite(num));
        const date = new Date(2018, 0, num);
        assert(Number.isFinite(date.getTime()));
        return date;
    }

    _generateLocation(repeatable) {
        const reused = this._reuseConstant('LOCATION', repeatable);
        if (reused !== undefined)
            return reused;

        const lat = randint(-90, 90, this._rng);
        const lon = randint(-180, 180, this._rng);
        const newLocation = new ThingTalk.Builtin.Location(lat, lon, null);
        this._constants.get('LOCATION').push(newLocation);
        return newLocation;
    }

    _generateNumber(key, repeatable, arg) {
        const reused = this._reuseConstant(key, repeatable);
        if (reused !== undefined)
            return reused;

        let min, max;
        min = 20;
        max = 1000;
        if (arg) {
            let minArg = arg.getImplementationAnnotation('min_number');
            if (minArg !== undefined) {
                min = minArg;
                max = Math.max(max, minArg + 20);
            }
            let maxArg = arg.getImplementationAnnotation('max_number');
            if (maxArg !== undefined)
                max = maxArg;
        }

        // with 50% probability, generate a "small" number
        if (coin(0.5, this._rng)) {
            min = Math.max(min, 1);
            max = Math.min(max, 20);
        }
        if (max <= min)
            max = min;

        let newNumber = randint(min, max, this._rng);
        assert(Number.isFinite(newNumber));
        this._constants.get(key).push(newNumber);
        return newNumber;
    }

    _generateString(key, repeatable) {
        const reused = this._reuseConstant(key, repeatable);
        if (reused !== undefined)
            return reused;

        const newString = `str:${key}::${Math.floor(this._rng() * 50)}:`;
        this._constants.get(key).push(newString);
        return newString;
    }

    generateString() {
        return this._generateString('QUOTED_STRING', false);
    }

    _reuseConstant(key, repeatable) {
        // first check if we have something in the program already
        let candidates = this._candidates.get(key);
        if (repeatable && candidates && candidates.length > 0 && coin(0.5, this._rng))
            return uniform(candidates, this._rng);

        // then try to reuse one of the constants we already generated
        let previous = this._constants.get(key);
        if (previous === undefined) {
            previous = [];
            this._constants.set(key, previous);
        }

        if (repeatable && previous.length > 0 && coin(0.1, this._rng))
            return uniform(previous, this._rng);

        return undefined;
    }
}

class SimulatedError extends Error {
    constructor(message, code) {
        super(message);
        this.code = code;
    }
}

function parseTime(v) {
    if (typeof v === 'string') {
        let [hour, minute, second] = v.split(':');
        hour = parseInt(hour);
        minute = parseInt(minute);
        if (second === undefined)
            second = 0;
        else
            second = parseInt(second);
        return new ThingTalk.Time(hour, minute, second);
    } else {
        return new ThingTalk.Time(v.hour, v.minute, v.second);
    }
}

function loadSimulationValue(schema, type, value, keyPrefix) {
    if (type.isArray)
        return value.map((v) => loadSimulationValue(schema, type.elem, v, keyPrefix));

    if (type.isCompound) {
        const mapped = {};
        for (let key in value) {
            const inner = value[key];
            const arg = schema.getArgument(keyPrefix + key);
            mapped[key] = loadSimulationValue(schema, arg.type, inner, keyPrefix + key + '.');
        }
        return mapped;
    }

    if (type.isEntity) {
        if (typeof value === 'object')
            return new ThingTalk.Entity(value.value, value.display);
        else
            return new ThingTalk.Entity(value, null);
    }
    if (type.isLocation)
        return new ThingTalk.Location(value[0], value[1], value[2]);
    if (type.isTime)
        return parseTime(value);
    if (type.isDate)
        return new Date(value);

    return value;
}

class SimulationExecEnvironment extends ThingTalk.ExecEnvironment {
    constructor(locale, schemas, database, { rng, simulateErrors = true }) {
        super(locale, 'America/Los_Angeles', schemas);
        this._execCache = [];

        this._schemas = schemas;
        this._database = database;
        this._rng = rng;
        this._simulateErrors = simulateErrors;

        this.output = null;
        this.generator = null;
    }

    get program_id() {
        return new ThingTalk.Entity('uuid-simulation', null);
    }

    clearGetCache() {
        // do not actually clear the get cache
        // all queries are expected to return consistent results
    }

    _findInCache(functionKey, params) {
        for (let cached of this._execCache) {
            let [_function, cachedparams, result] = cached;
            if (_function === functionKey &&
                ThingTalk.Builtin.equality(cachedparams, params))
                return result;
        }
        return null;
    }

    async readResult(functionKey, index) {
        for (let i = this._execCache.length-1; i >= 0; i--) {
            let [_function,, result] = this._execCache[i];
            if (_function === functionKey) {
                index --;
                if (index === 0)
                    return result;
            }
        }
        throw new Error(`Invalid readResult, no result for ${functionKey}[${index}]`);
    }

    _failAction(schema) {
        const errors = Object.keys(schema.metadata.on_error || {});
        if (errors.length === 0)
            throw new SimulatedError(this.generator.generateString());
        else
            throw new SimulatedError(this.generator.generateString(), uniform(errors, this._rng));
    }

    async invokeAction(kind, attrs, fname, params) {
        const outputType = kind + ':action/' + fname;
        const schema = await this._schemas.getMeta(kind, 'action', fname);

        // with some probability, fail the action
        if (this._simulateErrors && coin(0.1, this._rng)) {
            await this._failAction(schema);
            return undefined;
        }

        let anyOutArgument = false;
        for (let arg of schema.iterateArguments()) {
            if (!arg.is_input) {
                anyOutArgument = true;
                break;
            }
        }

        if (anyOutArgument)
            return [[outputType, this.generator.generate(schema, params, 0)]];

        return undefined;
    }

    async _doInvokeQuery(kind, fname, params, hints) {
        const outputType = kind + ':' + fname;
        const schema = await this._schemas.getMeta(kind, 'query', fname);
        if (this._database && this._database.has(outputType)) {
            const data = this._database.get(outputType);

            // HACK: sort multiwoz train search results so that the context is correct already
            // if the user is searching by arrive_by, sort by arrive_by desc

            if (hints.filter && hints.filter.some(([pname,]) => pname === 'arrive_by')) {
                data.sort((one, two) => {
                    if (one.arrive_by < two.arrive_by)
                        return 1;
                    if (two.arrive_by < one.arrive_by)
                        return -1;
                    return 0;
                });
            }
            // if the user is searching by leave_at, sort by leave_at asc
            if (hints.filter && hints.filter.some(([pname,]) => pname === 'leave_at')) {
                data.sort((one, two) => {
                    if (one.leave_at < two.leave_at)
                        return -1;
                    if (two.leave_at < one.leave_at)
                        return 1;
                    return 0;
                });
            }

            // note: the query response is not cached between successive statements,
            // so we can change the sort order depending on what the user is filtering for

            return [data.map((item) => {
                const mapped = {};
                for (let key in item) {
                    const value = item[key];
                    const arg = schema.getArgument(key);
                    if (!arg)
                        continue;
                    mapped[key] = loadSimulationValue(schema, arg.type, value, '');
                }

                return [outputType, mapped];
            }), false];
        }

        let numResults, cacheable;
        if (schema.is_list) {
            // with some probability, return no results, so we hit the search error path
            if (coin(0.1, this._rng)) {
                numResults = 0;
                cacheable = false;
            } else {
                numResults = randint(50, 100, this._rng);
                cacheable = true;
            }
        } else {
            numResults = 1;
            cacheable = true;
        }

        let results = [];
        for (let i = 0; i < numResults; i++)
            results.push([outputType, this.generator.generate(schema, params, i)]);

        return [results, cacheable];
    }

    async invokeQuery(kind, attrs, fname, params, hints) {
        const functionKey = kind + ':' + fname;
        const cached = this._findInCache(functionKey, params);
        if (cached)
            return Promise.resolve(cached);

        const [list, cacheable] = await this._doInvokeQuery(kind, fname, params, hints);
        if (cacheable)
            this._execCache.push([functionKey, params, list]);
        return list;
    }
}

module.exports = {
    ResultGenerator,
    SimulationExecEnvironment,
    SimulatedError
};

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
27	const { coin, uniform, randint } = require('../../utils/random');	13✔
28
29	class ResultGenerator {
30	constructor(rng, overrides) {
31	this._rng = rng;	4,768✔
32
33	this._overrides = overrides;	4,768✔
34	this._candidates = new Map;	4,768✔
35	this._constants = new Map;	4,768✔
36	this._results = [];	4,768✔
37	}
38
39	_doAddCandidate(key, jsValue) {
40	let candidates = this._candidates.get(key);	10,315✔
41	if (candidates === undefined) {	10,315✔
42	candidates = [];	7,911✔
43	this._candidates.set(key, candidates);	7,911✔
44	}
45	candidates.push(jsValue);	10,315✔
46	}
47
48	addCandidate(value) {
49	if (value.isArray \|\| !value.isConstant())	13,508✔
50	return;	2,242✔
51
52	if (value.isBoolean \|\| value.isEnum)	11,266✔
53	return;	951✔
54
55	const jsValue = value.toJS();	10,315✔
56
57	if (value.isString)	10,315✔
58	this._doAddCandidate('QUOTED_STRING', jsValue);	4,996✔
59	else if (value.isNumber)	5,319✔
60	this._doAddCandidate('NUMBER', jsValue);	455✔
61	else if (value.isCurrency)	4,864!
62	this._doAddCandidate('CURRENCY', jsValue.value);	×
63	else if (value.isMeasure)	4,864✔
64	this._doAddCandidate('MEASURE_' + value.getType().type, jsValue);	2,191✔
65	else if (value.isTime)	2,673✔
66	this._doAddCandidate('TIME', jsValue);	776✔
67	else if (value.isDate)	1,897✔
68	this._doAddCandidate('DATE', jsValue);	1,709✔
69	else if (value.isLocation)	188✔
70	this._doAddCandidate('LOCATION', jsValue);	3✔
71	else if (value.isEntity)	185!
72	this._doAddCandidate('ENTITY_' + value.type, String(jsValue));	185✔
73	}
74
75	generate(schema, params, index) {
76	let result = {};	117,207✔
77	Object.assign(result, params);	117,207✔
78	for (let arg of schema.iterateArguments()) {	117,207✔
79	if (arg.direction !== Ast.ArgDirection.OUT)	788,773✔
80	continue;	27,024✔
81	if (arg.name.indexOf('.') >= 0)	761,749!
82	continue;	×
83	if (this._overrides.has(arg.name))	761,749!
84	result[arg.name] = this._overrides.get(arg.name);	×
85	else if (arg.name === 'id' && arg.type.isEntity)	761,749✔
86	result[arg.name] = new ThingTalk.Builtin.Entity(`str:ENTITY_${arg.type.type}::${index}:`, null);	66,916✔
87	else
88	result[arg.name] = this._generateValue(arg.type, arg.name !== 'id', arg);	694,833✔
89	}
90	return result;	117,207✔
91	}
92
93	_generateValue(type, repeatable = true, arg) {	×
94	if (type.isCompound) {	704,093!
95	let result = {};	×
96	for (let field in type.fields) {	×
97	const arg = type.fields[field];	×
98	assert(arg instanceof Ast.ArgumentDef);	×
99	result[field] = this._generateValue(arg.type, true, arg);	×
100	}
101	return result;	×
102	}
103
104	if (type.isArray) {	704,093✔
105	let length = randint(1, 3, this._rng);	4,672✔
106	let buffer = [];	4,672✔
107	// do not repeat values inside the array
108	for (let i = 0; i < length; i++)	4,672✔
109	buffer.push(this._generateValue(type.elem, false, arg));	9,260✔
110	return buffer;	4,672✔
111	}
112
113	if (type.isBoolean)	699,421✔
114	return !!coin(0.5, this._rng);	39,864✔
115	if (type.isString)	659,557✔
116	return this._generateString(`QUOTED_STRING`, repeatable);	273,691✔
117	if (type.isNumber)	385,866✔
118	return this._generateNumber(`NUMBER`, repeatable, arg);	33,001✔
119	if (type.isMeasure)	352,865✔
120	return this._generateNumber(`MEASURE_` + type.unit, repeatable, arg);	16,883✔
121	if (type.isCurrency)	335,982✔
122	return new ThingTalk.Builtin.Currency(this._generateNumber(`CURRENCY`, repeatable), 'usd');	16,862✔
123	if (type.isTime)	319,120✔
124	return this._generateTime(repeatable);	33,724✔
125	if (type.isDate)	285,396✔
126	return this._generateDate(repeatable);	27,379✔
127	if (type.isLocation)	258,017✔
128	return this._generateLocation(repeatable);	1✔
129	if (type.isEnum)	258,016✔
130	return uniform(type.entries, this._rng);	136,329✔
131	if (type.isEntity)	121,687!
132	return new ThingTalk.Builtin.Entity(this._generateString('ENTITY_' + type.type, repeatable), null);	121,687✔
133
134	throw new TypeError(`Invalid constant of type ${type}`);	×
135	}
136
137	_generateTime(repeatable) {
138	const reused = this._reuseConstant('TIME', repeatable);	33,724✔
139	if (reused !== undefined)	33,724✔
140	return reused;	8,033✔
141
142	const newTime = new ThingTalk.Builtin.Time(randint(0, 23), randint(0, 59), 0);	25,691✔
143	this._constants.get('TIME').push(newTime);	25,691✔
144	return newTime;	25,691✔
145	}
146
147	_generateDate(repeatable) {
148	const reused = this._reuseConstant('DATE', repeatable);	27,379✔
149	if (reused !== undefined)	27,379✔
150	return reused;	6,695✔
151
152	const num = this._generateNumber('DATE::number', repeatable);	20,684✔
153	assert(Number.isFinite(num));	20,684✔
154	const date = new Date(2018, 0, num);	20,684✔
155	assert(Number.isFinite(date.getTime()));	20,684✔
156	return date;	20,684✔
157	}
158
159	_generateLocation(repeatable) {
160	const reused = this._reuseConstant('LOCATION', repeatable);	1✔
161	if (reused !== undefined)	1!
UNCOV 162	return reused;	×
163
164	const lat = randint(-90, 90, this._rng);	1✔
165	const lon = randint(-180, 180, this._rng);	1✔
166	const newLocation = new ThingTalk.Builtin.Location(lat, lon, null);	1✔
167	this._constants.get('LOCATION').push(newLocation);	1✔
168	return newLocation;	1✔
169	}
170
171	_generateNumber(key, repeatable, arg) {
172	const reused = this._reuseConstant(key, repeatable);	87,430✔
173	if (reused !== undefined)	87,430✔
174	return reused;	11,968✔
175
176	let min, max;
177	min = 20;	75,462✔
178	max = 1000;	75,462✔
179	if (arg) {	75,462✔
180	let minArg = arg.getImplementationAnnotation('min_number');	41,501✔
181	if (minArg !== undefined) {	41,501✔
182	min = minArg;	15,889✔
183	max = Math.max(max, minArg + 20);	15,889✔
184	}
185	let maxArg = arg.getImplementationAnnotation('max_number');	41,501✔
186	if (maxArg !== undefined)	41,501✔
187	max = maxArg;	15,889✔
188	}
189
190	// with 50% probability, generate a "small" number
191	if (coin(0.5, this._rng)) {	75,462✔
192	min = Math.max(min, 1);	37,867✔
193	max = Math.min(max, 20);	37,867✔
194	}
195	if (max <= min)	75,462✔
196	max = min;	29,966✔
197
198	let newNumber = randint(min, max, this._rng);	75,462✔
199	assert(Number.isFinite(newNumber));	75,462✔
200	this._constants.get(key).push(newNumber);	75,462✔
201	return newNumber;	75,462✔
202	}
203
204	_generateString(key, repeatable) {
205	const reused = this._reuseConstant(key, repeatable);	395,428✔
206	if (reused !== undefined)	395,428✔
207	return reused;	114,620✔
208
209	const newString = `str:${key}::${Math.floor(this._rng() * 50)}:`;	280,808✔
210	this._constants.get(key).push(newString);	280,808✔
211	return newString;	280,808✔
212	}
213
214	generateString() {
215	return this._generateString('QUOTED_STRING', false);	50✔
216	}
217
218	_reuseConstant(key, repeatable) {
219	// first check if we have something in the program already
220	let candidates = this._candidates.get(key);	543,962✔
221	if (repeatable && candidates && candidates.length > 0 && coin(0.5, this._rng))	543,962✔
222	return uniform(candidates, this._rng);	100,806✔
223
224	// then try to reuse one of the constants we already generated
225	let previous = this._constants.get(key);	443,156✔
226	if (previous === undefined) {	443,156✔
227	previous = [];	5,147✔
228	this._constants.set(key, previous);	5,147✔
229	}
230
231	if (repeatable && previous.length > 0 && coin(0.1, this._rng))	443,156✔
232	return uniform(previous, this._rng);	40,510✔
233
234	return undefined;	402,646✔
235	}
236	}
237
238	class SimulatedError extends Error {
239	constructor(message, code) {
240	super(message);	50✔
241	this.code = code;	50✔
242	}
243	}
244
245	function parseTime(v) {
246	if (typeof v === 'string') {	×
247	let [hour, minute, second] = v.split(':');	×
248	hour = parseInt(hour);	×
249	minute = parseInt(minute);	×
250	if (second === undefined)	×
251	second = 0;	×
252	else
253	second = parseInt(second);	×
254	return new ThingTalk.Time(hour, minute, second);	×
255	} else {
256	return new ThingTalk.Time(v.hour, v.minute, v.second);	×
257	}
258	}
259
260	function loadSimulationValue(schema, type, value, keyPrefix) {
261	if (type.isArray)	10,039✔
262	return value.map((v) => loadSimulationValue(schema, type.elem, v, keyPrefix));	3,418✔
263
264	if (type.isCompound) {	8,610!
265	const mapped = {};	×
266	for (let key in value) {	×
267	const inner = value[key];	×
268	const arg = schema.getArgument(keyPrefix + key);	×
269	mapped[key] = loadSimulationValue(schema, arg.type, inner, keyPrefix + key + '.');	×
270	}
271	return mapped;	×
272	}
273
274	if (type.isEntity) {	8,610✔
275	if (typeof value === 'object')	3,103✔
276	return new ThingTalk.Entity(value.value, value.display);	2,560✔
277	else
278	return new ThingTalk.Entity(value, null);	543✔
279	}
280	if (type.isLocation)	5,507✔
281	return new ThingTalk.Location(value[0], value[1], value[2]);	183✔
282	if (type.isTime)	5,324!
283	return parseTime(value);	×
284	if (type.isDate)	5,324✔
285	return new Date(value);	630✔
286
287	return value;	4,694✔
288	}
289
290	class SimulationExecEnvironment extends ThingTalk.ExecEnvironment {
291	constructor(locale, schemas, database, { rng, simulateErrors = true }) {	1,998✔
292	super(locale, 'America/Los_Angeles', schemas);	1,999✔
293	this._execCache = [];	1,999✔
294
295	this._schemas = schemas;	1,999✔
296	this._database = database;	1,999✔
297	this._rng = rng;	1,999✔
298	this._simulateErrors = simulateErrors;	1,999✔
299
300	this.output = null;	1,999✔
301	this.generator = null;	1,999✔
302	}
303
304	get program_id() {
305	return new ThingTalk.Entity('uuid-simulation', null);	×
306	}
307
308	clearGetCache() {
309	// do not actually clear the get cache
310	// all queries are expected to return consistent results
311	}
312
313	_findInCache(functionKey, params) {
314	for (let cached of this._execCache) {	4,321✔
315	let [_function, cachedparams, result] = cached;	3,255✔
316	if (_function === functionKey &&	3,255✔
317	ThingTalk.Builtin.equality(cachedparams, params))
318	return result;	2,545✔
319	}
320	return null;	1,776✔
321	}
322
323	async readResult(functionKey, index) {
324	for (let i = this._execCache.length-1; i >= 0; i--) {	×
325	let [_function,, result] = this._execCache[i];	×
326	if (_function === functionKey) {	×
327	index --;	×
328	if (index === 0)	×
329	return result;	×
330	}
331	}
332	throw new Error(`Invalid readResult, no result for ${functionKey}[${index}]`);	×
333	}
334
335	_failAction(schema) {
336	const errors = Object.keys(schema.metadata.on_error \|\| {});	50✔
337	if (errors.length === 0)	50✔
338	throw new SimulatedError(this.generator.generateString());	1✔
339	else
340	throw new SimulatedError(this.generator.generateString(), uniform(errors, this._rng));	49✔
341	}
342
343	async invokeAction(kind, attrs, fname, params) {
344	const outputType = kind + ':action/' + fname;	471✔
345	const schema = await this._schemas.getMeta(kind, 'action', fname);	471✔
346
347	// with some probability, fail the action
348	if (this._simulateErrors && coin(0.1, this._rng)) {	471✔
349	await this._failAction(schema);	50✔
350	return undefined;	×
351	}
352
353	let anyOutArgument = false;	421✔
354	for (let arg of schema.iterateArguments()) {	421✔
355	if (!arg.is_input) {	1,981✔
356	anyOutArgument = true;	408✔
357	break;	408✔
358	}
359	}
360
361	if (anyOutArgument)	421✔
362	return [[outputType, this.generator.generate(schema, params, 0)]];	408✔
363
364	return undefined;	13✔
365	}
366
367	async _doInvokeQuery(kind, fname, params, hints) {
368	const outputType = kind + ':' + fname;	1,776✔
369	const schema = await this._schemas.getMeta(kind, 'query', fname);	1,776✔
370	if (this._database && this._database.has(outputType)) {	1,776✔
371	const data = this._database.get(outputType);	11✔
372
373	// HACK: sort multiwoz train search results so that the context is correct already
374	// if the user is searching by arrive_by, sort by arrive_by desc
375
376	if (hints.filter && hints.filter.some(([pname,]) => pname === 'arrive_by')) {	11!
377	data.sort((one, two) => {	×
378	if (one.arrive_by < two.arrive_by)	×
379	return 1;	×
380	if (two.arrive_by < one.arrive_by)	×
381	return -1;	×
382	return 0;	×
383	});
384	}
385	// if the user is searching by leave_at, sort by leave_at asc
386	if (hints.filter && hints.filter.some(([pname,]) => pname === 'leave_at')) {	11!
387	data.sort((one, two) => {	×
388	if (one.leave_at < two.leave_at)	×
389	return -1;	×
390	if (two.leave_at < one.leave_at)	×
391	return 1;	×
392	return 0;	×
393	});
394	}
395
396	// note: the query response is not cached between successive statements,
397	// so we can change the sort order depending on what the user is filtering for
398
399	return [data.map((item) => {	11✔
400	const mapped = {};	832✔
401	for (let key in item) {	832✔
402	const value = item[key];	6,621✔
403	const arg = schema.getArgument(key);	6,621✔
404	if (!arg)	6,621!
405	continue;	×
406	mapped[key] = loadSimulationValue(schema, arg.type, value, '');	6,621✔
407	}
408
409	return [outputType, mapped];	832✔
410	}), false];
411	}
412
413	let numResults, cacheable;
414	if (schema.is_list) {	1,765✔
415	// with some probability, return no results, so we hit the search error path
416	if (coin(0.1, this._rng)) {	1,722✔
417	numResults = 0;	169✔
418	cacheable = false;	169✔
419	} else {
420	numResults = randint(50, 100, this._rng);	1,553✔
421	cacheable = true;	1,553✔
422	}
423	} else {
424	numResults = 1;	43✔
425	cacheable = true;	43✔
426	}
427
428	let results = [];	1,765✔
429	for (let i = 0; i < numResults; i++)	1,765✔
430	results.push([outputType, this.generator.generate(schema, params, i)]);	116,799✔
431
432	return [results, cacheable];	1,765✔
433	}
434
435	async invokeQuery(kind, attrs, fname, params, hints) {
436	const functionKey = kind + ':' + fname;	4,321✔
437	const cached = this._findInCache(functionKey, params);	4,321✔
438	if (cached)	4,321✔
439	return Promise.resolve(cached);	2,545✔
440
441	const [list, cacheable] = await this._doInvokeQuery(kind, fname, params, hints);	1,776✔
442	if (cacheable)	1,776✔
443	this._execCache.push([functionKey, params, list]);	1,596✔
444	return list;	1,776✔
445	}
446	}
447
448	module.exports = {	13✔
449	ResultGenerator,
450	SimulationExecEnvironment,
451	SimulatedError
452	};

stanford-oval / genie-toolkit / 1180

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