1258

pending completion

Build # 1258

Build Type

Pull #283

travis-ci-com

Committed by

web-flow

Commit Message

Merge 7261303f6 into a182bbff2

Pull Request Pull Request #283: Pass thingtalk code to nlp server

Run Details

6631 of 12819 branches covered (51.73%)

Branch coverage included in aggregate %.

3 of 19 new or added lines in 5 files covered. (15.79%)

12 existing lines in 5 files now uncovered.

15198 of 24660 relevant lines covered (61.63%)

1488001.63 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,747✔
32
33	this._overrides = overrides;	4,747✔
34	this._candidates = new Map;	4,747✔
35	this._constants = new Map;	4,747✔
36	this._results = [];	4,747✔
37	}
38
39	_doAddCandidate(key, jsValue) {
40	let candidates = this._candidates.get(key);	13,796✔
41	if (candidates === undefined) {	13,796✔
42	candidates = [];	8,075✔
43	this._candidates.set(key, candidates);	8,075✔
44	}
45	candidates.push(jsValue);	13,796✔
46	}
47
48	addCandidate(value) {
49	if (value.isArray \|\| !value.isConstant())	16,235✔
50	return;	1,131✔
51
52	if (value.isBoolean \|\| value.isEnum)	15,104✔
53	return;	1,308✔
54
55	const jsValue = value.toJS();	13,796✔
56
57	if (value.isString)	13,796✔
58	this._doAddCandidate('QUOTED_STRING', jsValue);	9,957✔
59	else if (value.isNumber)	3,839✔
60	this._doAddCandidate('NUMBER', jsValue);	336✔
61	else if (value.isCurrency)	3,503!
62	this._doAddCandidate('CURRENCY', jsValue.value);	×
63	else if (value.isMeasure)	3,503✔
64	this._doAddCandidate('MEASURE_' + value.getType().type, jsValue);	1,108✔
65	else if (value.isTime)	2,395✔
66	this._doAddCandidate('TIME', jsValue);	922✔
67	else if (value.isDate)	1,473✔
68	this._doAddCandidate('DATE', jsValue);	1,465✔
69	else if (value.isLocation)	8✔
70	this._doAddCandidate('LOCATION', jsValue);	3✔
71	else if (value.isEntity)	5!
72	this._doAddCandidate('ENTITY_' + value.type, String(jsValue));	5✔
73	}
74
75	generate(schema, params, index) {
76	let result = {};	82,231✔
77	Object.assign(result, params);	82,231✔
78	for (let arg of schema.iterateArguments()) {	82,231✔
79	if (arg.direction !== Ast.ArgDirection.OUT)	557,113✔
80	continue;	17,903✔
81	if (arg.name.indexOf('.') >= 0)	539,210!
82	continue;	×
83	if (this._overrides.has(arg.name))	539,210!
84	result[arg.name] = this._overrides.get(arg.name);	×
85	else if (arg.name === 'id' && arg.type.isEntity)	539,210✔
86	result[arg.name] = new ThingTalk.Builtin.Entity(`str:ENTITY_${arg.type.type}::${index}:`, null);	48,596✔
87	else
88	result[arg.name] = this._generateValue(arg.type, arg.name !== 'id', arg);	490,614✔
89	}
90	return result;	82,231✔
91	}
92
93	_generateValue(type, repeatable = true, arg) {	×
94	if (type.isCompound) {	492,571!
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) {	492,571✔
105	let length = randint(1, 3, this._rng);	994✔
106	let buffer = [];	994✔
107	// do not repeat values inside the array
108	for (let i = 0; i < length; i++)	994✔
109	buffer.push(this._generateValue(type.elem, false, arg));	1,957✔
110	return buffer;	994✔
111	}
112
113	if (type.isBoolean)	491,577✔
114	return !!coin(0.5, this._rng);	38,594✔
115	if (type.isString)	452,983✔
116	return this._generateString(`QUOTED_STRING`, repeatable);	185,312✔
117	if (type.isNumber)	267,671✔
118	return this._generateNumber(`NUMBER`, repeatable, arg);	19,721✔
119	if (type.isMeasure)	247,950✔
120	return this._generateNumber(`MEASURE_` + type.unit, repeatable, arg);	12,798✔
121	if (type.isCurrency)	235,152✔
122	return new ThingTalk.Builtin.Currency(this._generateNumber(`CURRENCY`, repeatable), 'usd');	12,782✔
123	if (type.isTime)	222,370✔
124	return this._generateTime(repeatable);	25,564✔
125	if (type.isDate)	196,806✔
126	return this._generateDate(repeatable);	24,411✔
127	if (type.isLocation)	172,395!
128	return this._generateLocation(repeatable);	×
129	if (type.isEnum)	172,395✔
130	return uniform(type.entries, this._rng);	102,414✔
131	if (type.isEntity)	69,981!
132	return new ThingTalk.Builtin.Entity(this._generateString('ENTITY_' + type.type, repeatable), null);	69,981✔
133
134	throw new TypeError(`Invalid constant of type ${type}`);	×
135	}
136
137	_generateTime(repeatable) {
138	const reused = this._reuseConstant('TIME', repeatable);	25,564✔
139	if (reused !== undefined)	25,564✔
140	return reused;	6,006✔
141
142	const newTime = new ThingTalk.Builtin.Time(randint(0, 23), randint(0, 59), 0);	19,558✔
143	this._constants.get('TIME').push(newTime);	19,558✔
144	return newTime;	19,558✔
145	}
146
147	_generateDate(repeatable) {
148	const reused = this._reuseConstant('DATE', repeatable);	24,411✔
149	if (reused !== undefined)	24,411✔
150	return reused;	4,927✔
151
152	const num = this._generateNumber('DATE::number', repeatable);	19,484✔
153	assert(Number.isFinite(num));	19,484✔
154	const date = new Date(2018, 0, num);	19,484✔
155	assert(Number.isFinite(date.getTime()));	19,484✔
156	return date;	19,484✔
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);	64,785✔
173	if (reused !== undefined)	64,785✔
174	return reused;	8,281✔
175
176	let min, max;
177	min = 20;	56,504✔
178	max = 1000;	56,504✔
179	if (arg) {	56,504✔
180	let minArg = arg.getImplementationAnnotation('min_number');	27,410✔
181	if (minArg !== undefined) {	27,410✔
182	min = minArg;	15,269✔
183	max = Math.max(max, minArg + 20);	15,269✔
184	}
185	let maxArg = arg.getImplementationAnnotation('max_number');	27,410✔
186	if (maxArg !== undefined)	27,410✔
187	max = maxArg;	15,269✔
188	}
189
190	// with 50% probability, generate a "small" number
191	if (coin(0.5, this._rng)) {	56,504✔
192	min = Math.max(min, 1);	28,398✔
193	max = Math.min(max, 20);	28,398✔
194	}
195	if (max <= min)	56,504✔
196	max = min;	20,823✔
197
198	let newNumber = randint(min, max, this._rng);	56,504✔
199	assert(Number.isFinite(newNumber));	56,504✔
200	this._constants.get(key).push(newNumber);	56,504✔
201	return newNumber;	56,504✔
202	}
203
204	_generateString(key, repeatable) {
205	const reused = this._reuseConstant(key, repeatable);	255,325✔
206	if (reused !== undefined)	255,325✔
207	return reused;	107,895✔
208
209	const newString = `str:${key}::${Math.floor(this._rng() * 50)}:`;	147,430✔
210	this._constants.get(key).push(newString);	147,430✔
211	return newString;	147,430✔
212	}
213
214	generateString() {
215	return this._generateString('QUOTED_STRING', false);	32✔
216	}
217
218	_reuseConstant(key, repeatable) {
219	// first check if we have something in the program already
220	let candidates = this._candidates.get(key);	370,085✔
221	if (repeatable && candidates && candidates.length > 0 && coin(0.5, this._rng))	370,085✔
222	return uniform(candidates, this._rng);	103,124✔
223
224	// then try to reuse one of the constants we already generated
225	let previous = this._constants.get(key);	266,961✔
226	if (previous === undefined) {	266,961✔
227	previous = [];	3,673✔
228	this._constants.set(key, previous);	3,673✔
229	}
230
231	if (repeatable && previous.length > 0 && coin(0.1, this._rng))	266,961✔
232	return uniform(previous, this._rng);	23,985✔
233
234	return undefined;	242,976✔
235	}
236	}
237
238	class SimulatedError extends Error {
239	constructor(message, code) {
240	super(message);	32✔
241	this.code = code;	32✔
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,346✔
292	super(locale, 'America/Los_Angeles', schemas);	1,347✔
293	this._execCache = [];	1,347✔
294
295	this._schemas = schemas;	1,347✔
296	this._database = database;	1,347✔
297	this._rng = rng;	1,347✔
298	this._simulateErrors = simulateErrors;	1,347✔
299
300	this.output = null;	1,347✔
301	this.generator = null;	1,347✔
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,308✔
315	let [_function, cachedparams, result] = cached;	6,643✔
316	if (_function === functionKey &&	6,643✔
317	ThingTalk.Builtin.equality(cachedparams, params))
318	return result;	3,059✔
319	}
320	return null;	1,249✔
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 \|\| {});	32!
337	if (errors.length === 0)	32!
UNCOV 338	throw new SimulatedError(this.generator.generateString());	×
339	else
340	throw new SimulatedError(this.generator.generateString(), uniform(errors, this._rng));	32✔
341	}
342
343	async invokeAction(kind, attrs, fname, params) {
344	const outputType = kind + ':action/' + fname;	463✔
345	const schema = await this._schemas.getMeta(kind, 'action', fname);	463✔
346
347	// with some probability, fail the action
348	if (this._simulateErrors && coin(0.1, this._rng)) {	463✔
349	await this._failAction(schema);	32✔
350	return undefined;	×
351	}
352
353	let anyOutArgument = false;	431✔
354	for (let arg of schema.iterateArguments()) {	431✔
355	if (!arg.is_input) {	2,067✔
356	anyOutArgument = true;	427✔
357	break;	427✔
358	}
359	}
360
361	if (anyOutArgument)	431✔
362	return [[outputType, this.generator.generate(schema, params, 0)]];	427✔
363
364	return undefined;	4✔
365	}
366
367	async _doInvokeQuery(kind, fname, params, hints) {
368	const outputType = kind + ':' + fname;	1,249✔
369	const schema = await this._schemas.getMeta(kind, 'query', fname);	1,249✔
370	if (this._database && this._database.has(outputType)) {	1,249✔
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,236✔
422	// with some probability, return no results, so we hit the search error path
423	if (coin(0.1, this._rng)) {	1,190✔
424	numResults = 0;	108✔
425	cacheable = false;	108✔
426	} else {
427	numResults = randint(50, 100, this._rng);	1,082✔
428	cacheable = true;	1,082✔
429	}
430	} else {
431	numResults = 1;	46✔
432	cacheable = true;	46✔
433	}
434
435	let results = [];	1,236✔
436	for (let i = 0; i < numResults; i++)	1,236✔
437	results.push([outputType, this.generator.generate(schema, params, i)]);	81,804✔
438
439	return [results, cacheable];	1,236✔
440	}
441
442	async invokeQuery(kind, attrs, fname, params, hints) {
443	const functionKey = kind + ':' + fname;	4,308✔
444	const cached = this._findInCache(functionKey, params);	4,308✔
445	if (cached)	4,308✔
446	return Promise.resolve(cached);	3,059✔
447
448	const [list, cacheable] = await this._doInvokeQuery(kind, fname, params, hints);	1,249✔
449	if (cacheable)	1,249✔
450	this._execCache.push([functionKey, params, list]);	1,129✔
451	return list;	1,249✔
452	}
453	}
454
455	module.exports = {	14✔
456	ResultGenerator,
457	SimulationExecEnvironment,
458	SimulatedError
459	};

stanford-oval / genie-toolkit / 1258

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