1989

pending completion

Build # 1989

Build Type

Pull #619

travis-ci-com

Committed by

web-flow

Commit Message

Merge 5472d1976 into b74f3c67e

Pull Request Pull Request #619: Implement stream based STT through almond-cloud WS

Run Details

12260 of 25903 branches covered (47.33%)

Branch coverage included in aggregate %.

1 of 36 new or added lines in 2 files covered. (2.78%)

11 existing lines in 5 files now uncovered.

28530 of 48639 relevant lines covered (58.66%)

413490.53 hits per line

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

61.62

/lib/dialogue-agent/simulator/statement_simulator.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of Genie
//
// Copyright 2020 The Board of Trustees of the Leland Stanford Junior University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>


import assert from 'assert';

import {
    Ast,
    Type,
    Compiler,
    SchemaRetriever,
    Runtime,
    Builtin
} from 'thingtalk';

import {
    ResultGenerator,
    SimulationExecEnvironment,
    SimulatedError
} from './simulation_exec_environment';
import { SimulationDatabase } from './types';

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

interface SimulatorOptions {
    locale : string;
    timezone : string|undefined;
    schemaRetriever : SchemaRetriever;
    rng : () => number;
    database ?: SimulationDatabase;
    overrides ?: Map<string, string>;
}

type RawExecutionResult = Array<[string, Record<string, unknown>]>;
type ExecutionResult = [Ast.DialogueHistoryResultList, RawExecutionResult];

export class ThingTalkSimulatorState {
    private _locale : string;
    private _schemas : SchemaRetriever;
    private _rng : () => number;
    private _database : SimulationDatabase|undefined;
    private _overrides : Map<string, string>;
    private _execEnv : SimulationExecEnvironment;

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

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

    async compile(stmt : Ast.ExpressionStatement, cache : Map<string, Runtime.CompiledProgram>) : Promise<Runtime.CompiledProgram> {
        const clone = stmt.clone();

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

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

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

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

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

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

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

    private _inferType(key : string, jsValue : unknown) : Type {
        if (key === 'distance') // HACK
            return new Type.Measure('m');
        if (key === '__device')
            return new Type.Entity('tt:device_id');
        if (typeof jsValue === 'boolean')
            return Type.Boolean;
        if (typeof jsValue === 'string')
            return Type.String;
        if (typeof jsValue === 'number')
            return Type.Number;
        if (jsValue instanceof Builtin.Currency)
            return Type.Currency;
        if (jsValue instanceof Builtin.Entity)
            return new Type.Entity('');
        if (jsValue instanceof Builtin.Time)
            return Type.Time;
        if (jsValue instanceof Date)
            return Type.Date;
        if (Array.isArray(jsValue) && jsValue.length > 0)
            return new Type.Array(this._inferType(key, jsValue[0]));
        if (Array.isArray(jsValue))
            return new Type.Array(Type.Any);

        return Type.Any;
    }

    private _outputTypeToSchema(outputType : string) : Promise<Ast.FunctionDef> {
        const [kind, fname] = outputType.split(':');
        let ftype : 'query'|'action' = 'query';

        let fname_ = fname;
        if (fname_.startsWith('action/')) {
            ftype = 'action';
            fname_ = fname_.substring('action/'.length);
        }
        return this._schemas.getSchemaAndNames(kind, ftype, fname_);
    }

    private async _mapResult(outputType : string|null, outputValue : { [key : string] : unknown }) : Promise<{ [key : string] : Ast.Value }> {
        const mappedResult : { [key : string] : Ast.Value } = {};
        if (outputType === null) {
            // fallback
            for (const key in outputValue) {
                const jsValue = outputValue[key];
                mappedResult[key] = Ast.Value.fromJS(this._inferType(key, jsValue), jsValue);
            }
            return mappedResult;
        }

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

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

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

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

            for (const key in outputValue) {
                const value = outputValue[key];
                if (value === null || value === undefined)
                    continue;
                const type = schema.getArgType(key) || this._inferType(key, value);
                if (type instanceof Type.Compound)
                    mappedResult[key] = this._mapCompound(key + '.', schema, value as { [key : string] : unknown });
                else
                    mappedResult[key] = Ast.Value.fromJS(type, value);
            }
        }
        return mappedResult;
    }

    private _mapCompound(prefix : string, schema : Ast.FunctionDef, object : { [key : string] : unknown }) : Ast.Value {
        const result : { [key : string] : Ast.Value } = {};
        for (const key in object) {
            const value = object[key];
            const type = schema.getArgType(prefix + key) || this._inferType(key, value);
            if (type instanceof Type.Compound)
                result[key] = this._mapCompound(prefix + key + '.', schema, object as { [key : string] : unknown });
            else
                result[key] = Ast.Value.fromJS(type, value);
        }
        return new Ast.Value.Object(result);
    }
}

/**
 * Simulate the execution of ThingTalk code.
 */
export default class ThingTalkStatementSimulator {
    private _options : SimulatorOptions;
    private cache : Map<string, Runtime.CompiledProgram>;

    constructor(options : SimulatorOptions) {
        this._options = options;
        this.cache = new Map;
    }

    async executeStatement(stmt : Ast.ExpressionStatement,
                           execState : ThingTalkSimulatorState) : Promise<[Ast.DialogueHistoryResultList, RawExecutionResult, undefined, ThingTalkSimulatorState]> {
        if (stmt.stream) {
            // nothing to do, this always returns nothing
            return [new Ast.DialogueHistoryResultList(null, [],
                new Ast.Value.Number(0), false, null), [], undefined, execState];
        }

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

        // there is no way around this, we need to compile and run the program!
        const compiled = await execState.compile(stmt, this.cache);
        const [resultList, rawResults] = await execState.simulate(stmt, compiled);
        // ignore the new program record, it doesn't matter at simulation time
        return [resultList, rawResults, undefined, execState];
    }
}

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of Genie
4	//
5	// Copyright 2020 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19	// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
20
21
22	import assert from 'assert';	111✔
23
24	import {	111✔
25	Ast,
26	Type,
27	Compiler,
28	SchemaRetriever,
29	Runtime,
30	Builtin
31	} from 'thingtalk';
32
33	import {	111✔
34	ResultGenerator,
35	SimulationExecEnvironment,
36	SimulatedError
37	} from './simulation_exec_environment';
38	import { SimulationDatabase } from './types';
39
40	// above MORE_SIZE, we set the "more" bit
41	const MORE_SIZE = 50;	111✔
42	// above PAGE_SIZE, we set the count but don't actually show the full list of results
43	const PAGE_SIZE = 10;	111✔
44
45	interface SimulatorOptions {
46	locale : string;
47	timezone : string\|undefined;
48	schemaRetriever : SchemaRetriever;
49	rng : () => number;
50	database ?: SimulationDatabase;
51	overrides ?: Map<string, string>;
52	}
53
54	type RawExecutionResult = Array<[string, Record<string, unknown>]>;
55	type ExecutionResult = [Ast.DialogueHistoryResultList, RawExecutionResult];
56
57	export class ThingTalkSimulatorState {	111✔
58	private _locale : string;
59	private _schemas : SchemaRetriever;
60	private _rng : () => number;
61	private _database : SimulationDatabase\|undefined;
62	private _overrides : Map<string, string>;
63	private _execEnv : SimulationExecEnvironment;
64
65	constructor(options : SimulatorOptions) {
66	this._locale = options.locale;	3,239✔
67	this._schemas = options.schemaRetriever;	3,239✔
68	this._rng = options.rng;	3,239✔
69	this._database = options.database;	3,239✔
70	this._overrides = options.overrides \|\| new Map;	3,239✔
71
72	this._execEnv = new SimulationExecEnvironment(this._locale, options.timezone, this._schemas, this._database, {	3,239✔
73	rng: this._rng
74	});
75	}
76
77	async compile(stmt : Ast.ExpressionStatement, cache : Map<string, Runtime.CompiledProgram>) : Promise<Runtime.CompiledProgram> {
78	const clone = stmt.clone();	8,524✔
79
80	const program = new Ast.Program(null, [], [], [clone]);	8,524✔
81	const cacheKey = program.prettyprint();	8,524✔
82	//console.error(cacheKey);
83
84	let compiled = cache.get(cacheKey);	8,524✔
85	if (compiled)	8,524✔
86	return compiled;	5,557✔
87
88	try {	2,967✔
89	const compiler = new Compiler(this._schemas);	2,967✔
90
91	compiled = await compiler.compileProgram(program);	2,967✔
92	assert(compiled.rules.length === 0);	2,967✔
93	cache.set(cacheKey, compiled);	2,967✔
94	} catch(e) {
95	console.error(`Failed to compile program: ` + e.message);	×
96	console.error(program.prettyprint());	×
97	throw e;	×
98	}
99	return compiled;	2,967✔
100	}
101
102	async simulate(stmt : Ast.ExpressionStatement, compiled : Runtime.CompiledProgram) : Promise<ExecutionResult> {
103	const results : Ast.DialogueHistoryResultItem[] = [];	8,524✔
104	const rawResults : RawExecutionResult = [];	8,524✔
105	let error : Ast.Value\|null = null;	8,524✔
106	const generator = new ResultGenerator(this._rng, this._overrides);	8,524✔
107	for (const slot of stmt.iterateSlots2()) {	8,524✔
108	if (slot instanceof Ast.DeviceSelector)	32,908✔
109	continue;	9,172✔
110	generator.addCandidate(slot.get());	23,736✔
111	}
112	this._execEnv.generator = generator;	8,524✔
113	this._execEnv.output = async (outputType : string, outputValue : { [key : string] : unknown }) => {	8,524✔
114	const mapped = new Ast.DialogueHistoryResultItem(null, await this._mapResult(outputType, outputValue));	180,462✔
115	results.push(mapped);	180,462✔
116	rawResults.push([outputType, outputValue]);	180,462✔
117	};
118	this._execEnv.reportError = async (msg, err) => {	8,524✔
119	if (!(err instanceof SimulatedError)) {	2,127!
120	console.error(`Failed to execute program`);	×
121	console.error(msg, err);	×
122	console.error(new Ast.Program(null, [], [], [stmt]).prettyprint());	×
123	process.exit(1);	×
124	return;	×
125	}
126	if (err.code)	2,127✔
127	error = new Ast.Value.Enum(err.code);	1,740✔
128	else
129	error = new Ast.Value.String(err.message);	387✔
130	};
131
132	try {	8,524✔
133	assert(typeof compiled.command === 'function');	8,524✔
134	await compiled.command(this._execEnv);	8,524✔
135	} catch(e) {
136	console.error(`Failed to execute program: ` + e.message);	×
137	console.error(new Ast.Program(null, [], [], [stmt]).prettyprint());	×
138	throw e;	×
139	}
140
141	const numResults = results.length;	8,524✔
142	return [new Ast.DialogueHistoryResultList(null, results.slice(0, PAGE_SIZE),	8,524✔
143	new Ast.Value.Number(Math.min(MORE_SIZE, numResults)), numResults > MORE_SIZE, error), rawResults];
144	}
145
146	private _inferType(key : string, jsValue : unknown) : Type {
147	if (key === 'distance') // HACK	27,488!
UNCOV 148	return new Type.Measure('m');	×
149	if (key === '__device')	27,488✔
150	return new Type.Entity('tt:device_id');	27,113✔
151	if (typeof jsValue === 'boolean')	375!
152	return Type.Boolean;	×
153	if (typeof jsValue === 'string')	375!
154	return Type.String;	×
155	if (typeof jsValue === 'number')	375!
156	return Type.Number;	375✔
157	if (jsValue instanceof Builtin.Currency)	×
158	return Type.Currency;	×
159	if (jsValue instanceof Builtin.Entity)	×
160	return new Type.Entity('');	×
161	if (jsValue instanceof Builtin.Time)	×
162	return Type.Time;	×
163	if (jsValue instanceof Date)	×
164	return Type.Date;	×
165	if (Array.isArray(jsValue) && jsValue.length > 0)	×
166	return new Type.Array(this._inferType(key, jsValue[0]));	×
167	if (Array.isArray(jsValue))	×
168	return new Type.Array(Type.Any);	×
169
170	return Type.Any;	×
171	}
172
173	private _outputTypeToSchema(outputType : string) : Promise<Ast.FunctionDef> {
174	const [kind, fname] = outputType.split(':');	180,334✔
175	let ftype : 'query'\|'action' = 'query';	180,334✔
176
177	let fname_ = fname;	180,334✔
178	if (fname_.startsWith('action/')) {	180,334✔
179	ftype = 'action';	15,448✔
180	fname_ = fname_.substring('action/'.length);	15,448✔
181	}
182	return this._schemas.getSchemaAndNames(kind, ftype, fname_);	180,334✔
183	}
184
185	private async _mapResult(outputType : string\|null, outputValue : { [key : string] : unknown }) : Promise<{ [key : string] : Ast.Value }> {
186	const mappedResult : { [key : string] : Ast.Value } = {};	180,462✔
187	if (outputType === null) {	180,462!
188	// fallback
189	for (const key in outputValue) {	×
190	const jsValue = outputValue[key];	×
191	mappedResult[key] = Ast.Value.fromJS(this._inferType(key, jsValue), jsValue);	×
192	}
193	return mappedResult;	×
194	}
195
196	if (outputType.indexOf('+') >= 0) {	180,462!
197	const types = outputType.split('+');	×
198	outputType = types[types.length-1];	×
199	}
200
201	const aggregation = /^([a-zA-Z]+)\(([^)]+)\)$/.exec(outputType);	180,462✔
202	if (aggregation !== null) {	180,462✔
203	let operator;
204	[, operator, outputType] = aggregation;	128✔
205
206	const field = Object.keys(outputValue)[0];	128✔
207	const value = outputValue[field];	128✔
208	if (operator === 'count') {	128!
209	mappedResult[field] = Ast.Value.fromJS(Type.Number, outputValue[field]);	128✔
210	return mappedResult;	128✔
211	}
212
213	const schema = await this._outputTypeToSchema(outputType);	×
214	const type = schema.getArgType(field) \|\| this._inferType(field, value);	×
215	mappedResult[field] = Ast.Value.fromJS(type, value);	×
216	} else {
217	const schema = await this._outputTypeToSchema(outputType);	180,334✔
218
219	for (const key in outputValue) {	180,334✔
220	const value = outputValue[key];	769,000✔
221	if (value === null \|\| value === undefined)	769,000!
222	continue;	×
223	const type = schema.getArgType(key) \|\| this._inferType(key, value);	769,000✔
224	if (type instanceof Type.Compound)	769,000!
225	mappedResult[key] = this._mapCompound(key + '.', schema, value as { [key : string] : unknown });	×
226	else
227	mappedResult[key] = Ast.Value.fromJS(type, value);	769,000✔
228	}
229	}
230	return mappedResult;	180,334✔
231	}
232
233	private _mapCompound(prefix : string, schema : Ast.FunctionDef, object : { [key : string] : unknown }) : Ast.Value {
234	const result : { [key : string] : Ast.Value } = {};	×
235	for (const key in object) {	×
236	const value = object[key];	×
237	const type = schema.getArgType(prefix + key) \|\| this._inferType(key, value);	×
238	if (type instanceof Type.Compound)	×
239	result[key] = this._mapCompound(prefix + key + '.', schema, object as { [key : string] : unknown });	×
240	else
241	result[key] = Ast.Value.fromJS(type, value);	×
242	}
243	return new Ast.Value.Object(result);	×
244	}
245	}
246
247	/**
248	* Simulate the execution of ThingTalk code.
249	*/
250	export default class ThingTalkStatementSimulator {	111✔
251	private _options : SimulatorOptions;
252	private cache : Map<string, Runtime.CompiledProgram>;
253
254	constructor(options : SimulatorOptions) {
255	this._options = options;	4✔
256	this.cache = new Map;	4✔
257	}
258
259	async executeStatement(stmt : Ast.ExpressionStatement,
260	execState : ThingTalkSimulatorState) : Promise<[Ast.DialogueHistoryResultList, RawExecutionResult, undefined, ThingTalkSimulatorState]> {
261	if (stmt.stream) {	9,845✔
262	// nothing to do, this always returns nothing
263	return [new Ast.DialogueHistoryResultList(null, [],	1,321✔
264	new Ast.Value.Number(0), false, null), [], undefined, execState];
265	}
266
267	if (execState === undefined)	8,524✔
268	execState = new ThingTalkSimulatorState(this._options);	3,239✔
269
270	// there is no way around this, we need to compile and run the program!
271	const compiled = await execState.compile(stmt, this.cache);	8,524✔
272	const [resultList, rawResults] = await execState.simulate(stmt, compiled);	8,524✔
273	// ignore the new program record, it doesn't matter at simulation time
274	return [resultList, rawResults, undefined, execState];	8,524✔
275	}
276	}

stanford-oval / genie-toolkit / 1989

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