1259

pending completion

Build # 1259

Build Type

Pull #286

travis-ci-com

Committed by

web-flow

Commit Message

Merge 9792ac4b2 into a182bbff2

Pull Request Pull Request #286: replace_parameters.js: fix constantToNN to parse entities correctly

Run Details

6623 of 12998 branches covered (50.95%)

Branch coverage included in aggregate %.

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

26 existing lines in 6 files now uncovered.

15146 of 24481 relevant lines covered (61.87%)

1494467.34 hits per line

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

78.74

/lib/dialogue-agent/simulator/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;
                });
            }

            const mapped = 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];
            });

            // note: if the query is a list, we return everything, and the query response is not
            // cached between successive statements, so we can change the sort order depending on
            // what the user is filtering for
            // if the query is a single result, the result is cached if the query is monitorable
            // so we return consistent results to later projection questions
            if (schema.is_list)
                return [mapped, false];
            else
                return [[uniform(mapped, this._rng)], schema.is_monitorable];
        }

        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');	14✔
23
24	const ThingTalk = require('thingtalk');	14✔
25	const Ast = ThingTalk.Ast;	14✔
26
27	const { coin, uniform, randint } = require('../../utils/random');	14✔
28
29	class ResultGenerator {
30	constructor(rng, overrides) {
31	this._rng = rng;	4,776✔
32
33	this._overrides = overrides;	4,776✔
34	this._candidates = new Map;	4,776✔
35	this._constants = new Map;	4,776✔
36	this._results = [];	4,776✔
37	}
38
39	_doAddCandidate(key, jsValue) {
40	let candidates = this._candidates.get(key);	13,763✔
41	if (candidates === undefined) {	13,763✔
42	candidates = [];	8,537✔
43	this._candidates.set(key, candidates);	8,537✔
44	}
45	candidates.push(jsValue);	13,763✔
46	}
47
48	addCandidate(value) {
49	if (value.isArray \|\| !value.isConstant())	16,639✔
50	return;	1,410✔
51
52	if (value.isBoolean \|\| value.isEnum)	15,229✔
53	return;	1,466✔
54
55	const jsValue = value.toJS();	13,763✔
56
57	if (value.isString)	13,763✔
58	this._doAddCandidate('QUOTED_STRING', jsValue);	9,362✔
59	else if (value.isNumber)	4,401✔
60	this._doAddCandidate('NUMBER', jsValue);	358✔
61	else if (value.isCurrency)	4,043!
62	this._doAddCandidate('CURRENCY', jsValue.value);	×
63	else if (value.isMeasure)	4,043✔
64	this._doAddCandidate('MEASURE_' + value.getType().type, jsValue);	1,385✔
65	else if (value.isTime)	2,658✔
66	this._doAddCandidate('TIME', jsValue);	957✔
67	else if (value.isDate)	1,701✔
68	this._doAddCandidate('DATE', jsValue);	1,691✔
69	else if (value.isLocation)	10✔
70	this._doAddCandidate('LOCATION', jsValue);	3✔
71	else if (value.isEntity)	7!
72	this._doAddCandidate('ENTITY_' + value.type, String(jsValue));	7✔
73	}
74
75	generate(schema, params, index) {
76	let result = {};	80,983✔
77	Object.assign(result, params);	80,983✔
78	for (let arg of schema.iterateArguments()) {	80,983✔
79	if (arg.direction !== Ast.ArgDirection.OUT)	550,271✔
80	continue;	17,078✔
81	if (arg.name.indexOf('.') >= 0)	533,193!
82	continue;	×
83	if (this._overrides.has(arg.name))	533,193!
84	result[arg.name] = this._overrides.get(arg.name);	×
85	else if (arg.name === 'id' && arg.type.isEntity)	533,193✔
86	result[arg.name] = new ThingTalk.Builtin.Entity(`str:ENTITY_${arg.type.type}::${index}:`, null);	48,001✔
87	else
88	result[arg.name] = this._generateValue(arg.type, arg.name !== 'id', arg);	485,192✔
89	}
90	return result;	80,983✔
91	}
92
93	_generateValue(type, repeatable = true, arg) {	×
94	if (type.isCompound) {	487,162!
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) {	487,162✔
105	let length = randint(1, 3, this._rng);	998✔
106	let buffer = [];	998✔
107	// do not repeat values inside the array
108	for (let i = 0; i < length; i++)	998✔
109	buffer.push(this._generateValue(type.elem, false, arg));	1,970✔
110	return buffer;	998✔
111	}
112
113	if (type.isBoolean)	486,164✔
114	return !!coin(0.5, this._rng);	38,159✔
115	if (type.isString)	448,005✔
116	return this._generateString(`QUOTED_STRING`, repeatable);	183,604✔
117	if (type.isNumber)	264,401✔
118	return this._generateNumber(`NUMBER`, repeatable, arg);	19,618✔
119	if (type.isMeasure)	244,783✔
120	return this._generateNumber(`MEASURE_` + type.unit, repeatable, arg);	12,163✔
121	if (type.isCurrency)	232,620✔
122	return new ThingTalk.Builtin.Currency(this._generateNumber(`CURRENCY`, repeatable), 'usd');	12,147✔
123	if (type.isTime)	220,473✔
124	return this._generateTime(repeatable);	24,294✔
125	if (type.isDate)	196,179✔
126	return this._generateDate(repeatable);	25,049✔
127	if (type.isLocation)	171,130!
128	return this._generateLocation(repeatable);	×
129	if (type.isEnum)	171,130✔
130	return uniform(type.entries, this._rng);	101,643✔
131	if (type.isEntity)	69,487!
132	return new ThingTalk.Builtin.Entity(this._generateString('ENTITY_' + type.type, repeatable), null);	69,487✔
133
134	throw new TypeError(`Invalid constant of type ${type}`);	×
135	}
136
137	_generateTime(repeatable) {
138	const reused = this._reuseConstant('TIME', repeatable);	24,294✔
139	if (reused !== undefined)	24,294✔
140	return reused;	5,143✔
141
142	const newTime = new ThingTalk.Builtin.Time(randint(0, 23), randint(0, 59), 0);	19,151✔
143	this._constants.get('TIME').push(newTime);	19,151✔
144	return newTime;	19,151✔
145	}
146
147	_generateDate(repeatable) {
148	const reused = this._reuseConstant('DATE', repeatable);	25,049✔
149	if (reused !== undefined)	25,049✔
150	return reused;	5,169✔
151
152	const num = this._generateNumber('DATE::number', repeatable);	19,880✔
153	assert(Number.isFinite(num));	19,880✔
154	const date = new Date(2018, 0, num);	19,880✔
155	assert(Number.isFinite(date.getTime()));	19,880✔
156	return date;	19,880✔
157	}
158
159	_generateLocation(repeatable) {
160	const reused = this._reuseConstant('LOCATION', repeatable);	×
161	if (reused !== undefined)	×
162	return reused;	×
163
164	const lat = randint(-90, 90, this._rng);	×
165	const lon = randint(-180, 180, this._rng);	×
166	const newLocation = new ThingTalk.Builtin.Location(lat, lon, null);	×
167	this._constants.get('LOCATION').push(newLocation);	×
168	return newLocation;	×
169	}
170
171	_generateNumber(key, repeatable, arg) {
172	const reused = this._reuseConstant(key, repeatable);	63,808✔
173	if (reused !== undefined)	63,808✔
174	return reused;	8,222✔
175
176	let min, max;
177	min = 20;	55,586✔
178	max = 1000;	55,586✔
179	if (arg) {	55,586✔
180	let minArg = arg.getImplementationAnnotation('min_number');	26,731✔
181	if (minArg !== undefined) {	26,731✔
182	min = minArg;	15,097✔
183	max = Math.max(max, minArg + 20);	15,097✔
184	}
185	let maxArg = arg.getImplementationAnnotation('max_number');	26,731✔
186	if (maxArg !== undefined)	26,731✔
187	max = maxArg;	15,097✔
188	}
189
190	// with 50% probability, generate a "small" number
191	if (coin(0.5, this._rng)) {	55,586✔
192	min = Math.max(min, 1);	27,966✔
193	max = Math.min(max, 20);	27,966✔
194	}
195	if (max <= min)	55,586✔
196	max = min;	20,464✔
197
198	let newNumber = randint(min, max, this._rng);	55,586✔
199	assert(Number.isFinite(newNumber));	55,586✔
200	this._constants.get(key).push(newNumber);	55,586✔
201	return newNumber;	55,586✔
202	}
203
204	_generateString(key, repeatable) {
205	const reused = this._reuseConstant(key, repeatable);	253,130✔
206	if (reused !== undefined)	253,130✔
207	return reused;	106,945✔
208
209	const newString = `str:${key}::${Math.floor(this._rng() * 50)}:`;	146,185✔
210	this._constants.get(key).push(newString);	146,185✔
211	return newString;	146,185✔
212	}
213
214	generateString() {
215	return this._generateString('QUOTED_STRING', false);	39✔
216	}
217
218	_reuseConstant(key, repeatable) {
219	// first check if we have something in the program already
220	let candidates = this._candidates.get(key);	366,281✔
221	if (repeatable && candidates && candidates.length > 0 && coin(0.5, this._rng))	366,281✔
222	return uniform(candidates, this._rng);	101,610✔
223
224	// then try to reuse one of the constants we already generated
225	let previous = this._constants.get(key);	264,671✔
226	if (previous === undefined) {	264,671✔
227	previous = [];	3,635✔
228	this._constants.set(key, previous);	3,635✔
229	}
230
231	if (repeatable && previous.length > 0 && coin(0.1, this._rng))	264,671✔
232	return uniform(previous, this._rng);	23,869✔
233
234	return undefined;	240,802✔
235	}
236	}
237
238	class SimulatedError extends Error {
239	constructor(message, code) {
240	super(message);	39✔
241	this.code = code;	39✔
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,063✔
262	return value.map((v) => loadSimulationValue(schema, type.elem, v, keyPrefix));	3,418✔
263
264	if (type.isCompound) {	8,634!
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,634✔
275	if (typeof value === 'object')	3,121✔
276	return new ThingTalk.Entity(value.value, value.display);	2,560✔
277	else
278	return new ThingTalk.Entity(value, null);	561✔
279	}
280	if (type.isLocation)	5,513✔
281	return new ThingTalk.Location(value[0], value[1], value[2]);	181✔
282	if (type.isTime)	5,332!
283	return parseTime(value);	×
284	if (type.isDate)	5,332✔
285	return new Date(value);	630✔
286
287	return value;	4,702✔
288	}
289
290	class SimulationExecEnvironment extends ThingTalk.ExecEnvironment {
291	constructor(locale, schemas, database, { rng, simulateErrors = true }) {	1,196✔
292	super(locale, 'America/Los_Angeles', schemas);	1,197✔
293	this._execCache = [];	1,197✔
294
295	this._schemas = schemas;	1,197✔
296	this._database = database;	1,197✔
297	this._rng = rng;	1,197✔
298	this._simulateErrors = simulateErrors;	1,197✔
299
300	this.output = null;	1,197✔
301	this.generator = null;	1,197✔
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,393✔
315	let [_function, cachedparams, result] = cached;	5,876✔
316	if (_function === functionKey &&	5,876✔
317	ThingTalk.Builtin.equality(cachedparams, params))
318	return result;	3,155✔
319	}
320	return null;	1,238✔
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 \|\| {});	39!
337	if (errors.length === 0)	39!
UNCOV 338	throw new SimulatedError(this.generator.generateString());	×
339	else
340	throw new SimulatedError(this.generator.generateString(), uniform(errors, this._rng));	39✔
341	}
342
343	async invokeAction(kind, attrs, fname, params) {
344	const outputType = kind + ':action/' + fname;	407✔
345	const schema = await this._schemas.getMeta(kind, 'action', fname);	407✔
346
347	// with some probability, fail the action
348	if (this._simulateErrors && coin(0.1, this._rng)) {	407✔
349	await this._failAction(schema);	39✔
350	return undefined;	×
351	}
352
353	let anyOutArgument = false;	368✔
354	for (let arg of schema.iterateArguments()) {	368✔
355	if (!arg.is_input) {	1,752✔
356	anyOutArgument = true;	364✔
357	break;	364✔
358	}
359	}
360
361	if (anyOutArgument)	368✔
362	return [[outputType, this.generator.generate(schema, params, 0)]];	364✔
363
364	return undefined;	4✔
365	}
366
367	async _doInvokeQuery(kind, fname, params, hints) {
368	const outputType = kind + ':' + fname;	1,238✔
369	const schema = await this._schemas.getMeta(kind, 'query', fname);	1,238✔
370	if (this._database && this._database.has(outputType)) {	1,238✔
371	const data = this._database.get(outputType);	13✔
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')) {	13!
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')) {	13!
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	const mapped = data.map((item) => {	13✔
397	const mapped = {};	850✔
398	for (let key in item) {	850✔
399	const value = item[key];	6,645✔
400	const arg = schema.getArgument(key);	6,645✔
401	if (!arg)	6,645!
402	continue;	×
403	mapped[key] = loadSimulationValue(schema, arg.type, value, '');	6,645✔
404	}
405
406	return [outputType, mapped];	850✔
407	});
408
409	// note: if the query is a list, we return everything, and the query response is not
410	// cached between successive statements, so we can change the sort order depending on
411	// what the user is filtering for
412	// if the query is a single result, the result is cached if the query is monitorable
413	// so we return consistent results to later projection questions
414	if (schema.is_list)	13✔
415	return [mapped, false];	8✔
416	else
417	return [[uniform(mapped, this._rng)], schema.is_monitorable];	5✔
418	}
419
420	let numResults, cacheable;
421	if (schema.is_list) {	1,225✔
422	// with some probability, return no results, so we hit the search error path
423	if (coin(0.1, this._rng)) {	1,179✔
424	numResults = 0;	112✔
425	cacheable = false;	112✔
426	} else {
427	numResults = randint(50, 100, this._rng);	1,067✔
428	cacheable = true;	1,067✔
429	}
430	} else {
431	numResults = 1;	46✔
432	cacheable = true;	46✔
433	}
434
435	let results = [];	1,225✔
436	for (let i = 0; i < numResults; i++)	1,225✔
437	results.push([outputType, this.generator.generate(schema, params, i)]);	80,619✔
438
439	return [results, cacheable];	1,225✔
440	}
441
442	async invokeQuery(kind, attrs, fname, params, hints) {
443	const functionKey = kind + ':' + fname;	4,393✔
444	const cached = this._findInCache(functionKey, params);	4,393✔
445	if (cached)	4,393✔
446	return Promise.resolve(cached);	3,155✔
447
448	const [list, cacheable] = await this._doInvokeQuery(kind, fname, params, hints);	1,238✔
449	if (cacheable)	1,238✔
450	this._execCache.push([functionKey, params, list]);	1,114✔
451	return list;	1,238✔
452	}
453	}
454
455	module.exports = {	14✔
456	ResultGenerator,
457	SimulationExecEnvironment,
458	SimulatedError
459	};

stanford-oval / genie-toolkit / 1259

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