1927

pending completion

Build # 1927

Build Type

Pull #578

travis-ci-com

Committed by

web-flow

Commit Message

Merge 338037b9c into 0ab9e58d8

Pull Request Pull Request #578: Support for multiple devices during training

Run Details

12095 of 25621 branches covered (47.21%)

Branch coverage included in aggregate %.

56 of 60 new or added lines in 5 files covered. (93.33%)

83 existing lines in 7 files now uncovered.

28292 of 48296 relevant lines covered (58.58%)

410289.93 hits per line

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

83.33

/languages/thingtalk/dialogue_acts/action-results.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 } from 'thingtalk';

import * as C from '../ast_manip';

import { SlotBag } from '../slot_bag';
import {
    ContextInfo,
    makeAgentReply,
    makeSimpleState,
    setOrAddInvocationParam,
    addNewItem,
} from '../state_manip';
import {
    isInfoPhraseCompatibleWithResult
} from './common';

export type ActionSuccessPhraseWithResult = [Ast.Expression|null, SlotBag];

export function actionSuccessPhraseWithResultKeyFn([expression, bag] : ActionSuccessPhraseWithResult) {
    return {
        functionName: bag.schema!.qualifiedName
    };
}

function makeThingpediaActionSuccessPhrase(ctx : ContextInfo, info : SlotBag) {
    const results = ctx.results;
    if (!results || results.length !== 1)
        return null;

    const ctxInvocation = C.getInvocation(ctx.current!);
    if (!C.isSameFunction(ctxInvocation.schema!, info.schema!))
        return null;

    const topResult = results[0];
    if (!isInfoPhraseCompatibleWithResult(topResult, info))
        return null;

    return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), info);
}

function checkSelector(ctxSelector : Ast.DeviceSelector, actionSelector : Ast.DeviceSelector) : boolean {
    if (actionSelector.all !== ctxSelector.all)
        return false;

    const deviceName = ctxSelector.attributes.find((ip) => ip.name === 'name')?.value;

    if (actionSelector.attributes.length > 0 &&
        actionSelector.attributes[0].name === 'name') {
        /* we have a device name */
        assert(actionSelector.attributes[0].value instanceof Ast.StringValue);
        const actionDeviceName = actionSelector.attributes[0].value;

        if (!deviceName || !actionDeviceName.equals(deviceName))
            return false;
    }

    return true;
}

function makeCompleteActionSuccessPhrase(ctx : ContextInfo, action : Ast.Expression, info : SlotBag|null) {
    const results = ctx.results;
    assert(results);

    // check the action is the same we actually executed, and all the parameters we're mentioning
    // match the actual parameters of the action
    let last;
    if (action instanceof Ast.ChainExpression)
        last = action.last;
    else
        last = action;
    assert(last instanceof Ast.InvocationExpression);
    const ctxInvocation = C.getInvocation(ctx.current!);
    if (!C.isSameFunction(ctxInvocation.schema!, last.invocation.schema!))
        return null;
    if (!checkSelector(ctxInvocation.selector, last.invocation.selector))
        return null;

    for (const newParam of last.invocation.in_params) {
        if (newParam.value.isUndefined)
            continue;

        let found = false, wasParamPassing = false;
        for (const oldParam of ctxInvocation.in_params) {
            assert(!oldParam.value.isUndefined); // we ran the action, so it cannot have $? params

            if (newParam.name === oldParam.name) {
                if (newParam.value instanceof Ast.VarRefValue) {
                    // we're using a join to describe this action
                    // we don't need to check that the table is correct, because
                    // the table comes from a context phrase, but do check the action
                    // is correct
                    if (oldParam.value instanceof Ast.VarRefValue) {
                        wasParamPassing = true;
                        if (newParam.value.name !== oldParam.value.name)
                            return null;
                    } else {
                        return null;
                    }
                } else {
                    // newParam is a constant, but oldParam might be a param passing
                    if (oldParam.value instanceof Ast.VarRefValue)
                        wasParamPassing = true;
                    else if (!newParam.value.equals(oldParam.value))
                        return null;
                }
                found = true;
                break;
            }
        }
        if (!found) {
            const arg = action.schema!.getArgument(newParam.name)!;
            if (arg.is_input)
                return null;

            // if newParam is an output parameter that we appended to describe the result
            // of the action, we allow it to be missing from the action, and we'll check
            // against the result entry
        }

        if (!(newParam.value instanceof Ast.VarRefValue)) {
            // if we can't check in the result bag, and we didn't find a constant
            // to check against in the program, then this phrase is no good
            // because we're hallucinating the value
            if (results.length === 0 && (!found || wasParamPassing))
                return null;
            if (results.length > 1)
                return null;

            // if the parameter is a constant, check also the result entry, if we have one
            // this checks that input parameters are correct, if they were parameter passed
            // and checks that the output parameters are correct
            if (results.length >= 1) {
                const topResult = results[0];
                const resultValue = topResult.value[newParam.name];
                if (!resultValue)
                    return null;

                if (!resultValue.equals(newParam.value))
                    return null;
            }
        }
    }

    if (info !== null) {
        if (results.length < 1)
            return null;
        assert(info instanceof SlotBag);
        if (!results.every((r) => isInfoPhraseCompatibleWithResult(r, info)))
            return null;
    }

    return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), info);
}

function makeGenericActionSuccessPhrase(ctx : ContextInfo) {
    return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), null);
}

export interface ErrorMessage {
    code : string;
    bag : SlotBag;
}

function checkThingpediaErrorMessage(ctx : ContextInfo, msg : ErrorMessage) {
    if (!C.isSameFunction(ctx.currentFunction!, msg.bag.schema!))
        return null;
    const error = ctx.error;
    if (!(error instanceof Ast.EnumValue) || error.value !== msg.code)
        return null;

    const action = C.getInvocation(ctx.current!);
    for (const in_param of action.in_params) {
        if (msg.bag.has(in_param.name) && !msg.bag.get(in_param.name)!.equals(in_param.value))
            return null;
    }

    return ctx;
}

function checkActionErrorMessage(ctx : ContextInfo, action : Ast.Invocation) {
    // check the action is the same we actually executed, and all the parameters we're mentioning
    // match the actual parameters of the action
    if (!C.isSameFunction(ctx.currentFunction!, action.schema!))
        return null;
    const ctxInvocation = C.getInvocation(ctx.current!);
    for (const newParam of action.in_params) {
        if (newParam.value.isUndefined)
            continue;

        let found = false;
        for (const oldParam of ctxInvocation.in_params) {
            if (newParam.name === oldParam.name) {
                if (!newParam.value.equals(oldParam.value))
                    return null;
                found = true;
                break;
            }
        }
        if (!found)
            return null;
    }

    return ctx;
}

function makeActionErrorPhrase(ctx : ContextInfo, questions : C.ParamSlot[]) {
    const schema = ctx.currentFunction!;
    for (const q of questions) {
        if (!C.isSameFunction(schema, q.schema))
            return null;
        const arg = schema.getArgument(q.name);
        if (!arg || !arg.is_input)
            return null;
    }
    assert(Array.isArray(questions));

    if (questions.length === 0)
        return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error', null));

    if (questions.length === 1) {
        const type = schema.getArgType(questions[0].name)!;
        return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error_question', questions.map((q) => q.name)), null, type);
    }
    return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error_question', questions.map((q) => q.name)));
}

function actionErrorChangeParam(ctx : ContextInfo, answer : Ast.Value|C.InputParamSlot) {
    const schema = ctx.currentFunction!;
    const questions = ctx.state.dialogueActParam as string[] || [];
    let ipslot : C.InputParamSlot;
    if (answer instanceof Ast.Value) {
        if (questions.length !== 1)
            return null;
        const arg = schema.getArgument(questions[0]);
        if (!arg || !arg.is_input || !arg.type.equals(answer.getType()))
            return null;
        ipslot = {
            schema,
            ptype: answer.getType(),
            ast: new Ast.InputParam(null, questions[0], answer)
        };
    } else {
        ipslot = answer;
        if (!C.isSameFunction(ipslot.schema, schema))
            return null;
    }
    // TODO implement this template for queries
    if (schema.functionType !== 'action')
        return null;

    const clone = ctx.current!.clone();
    const action = C.getInvocation(clone);
    if (!action)
        return null;
    setOrAddInvocationParam(action, ipslot.ast.name, ipslot.ast.value);
    return addNewItem(ctx, 'execute', null, 'accepted', clone);
}

function actionSuccessQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
    if (ctx.resultInfo && ctx.resultInfo.hasStream)
        return null;

    for (const q of questions) {
        if (!C.isSameFunction(q.schema, ctx.currentFunction!))
            return null;
        const arg = ctx.currentFunction!.getArgument(q.name);
        if (!arg || arg.is_input)
            return null;
    }
    return makeSimpleState(ctx, 'action_question', questions.map((q) => q.name));
}

export {
    makeThingpediaActionSuccessPhrase,
    makeCompleteActionSuccessPhrase,
    makeGenericActionSuccessPhrase,
    checkThingpediaErrorMessage,
    checkActionErrorMessage,
    makeActionErrorPhrase,

    actionErrorChangeParam,
    actionSuccessQuestion
};

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';	5✔
23
24	import { Ast } from 'thingtalk';	5✔
25
26	import * as C from '../ast_manip';	5✔
27
28	import { SlotBag } from '../slot_bag';	5✔
29	import {	5✔
30	ContextInfo,
31	makeAgentReply,
32	makeSimpleState,
33	setOrAddInvocationParam,
34	addNewItem,
35	} from '../state_manip';
36	import {	5✔
37	isInfoPhraseCompatibleWithResult
38	} from './common';
39
40	export type ActionSuccessPhraseWithResult = [Ast.Expression\|null, SlotBag];
41
42	export function actionSuccessPhraseWithResultKeyFn([expression, bag] : ActionSuccessPhraseWithResult) {	5✔
43	return {	4,442✔
44	functionName: bag.schema!.qualifiedName
45	};
46	}
47
48	function makeThingpediaActionSuccessPhrase(ctx : ContextInfo, info : SlotBag) {
49	const results = ctx.results;	9✔
50	if (!results \|\| results.length !== 1)	9!
UNCOV 51	return null;	×
52
53	const ctxInvocation = C.getInvocation(ctx.current!);	9✔
54	if (!C.isSameFunction(ctxInvocation.schema!, info.schema!))	9!
55	return null;	×
56
57	const topResult = results[0];	9✔
58	if (!isInfoPhraseCompatibleWithResult(topResult, info))	9!
59	return null;	×
60
61	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), info);	9✔
62	}
63
64	function checkSelector(ctxSelector : Ast.DeviceSelector, actionSelector : Ast.DeviceSelector) : boolean {
65	if (actionSelector.all !== ctxSelector.all)	66,457!
66	return false;	×
67
68	const deviceName = ctxSelector.attributes.find((ip) => ip.name === 'name')?.value;	66,457✔
69
70	if (actionSelector.attributes.length > 0 &&	66,457!
71	actionSelector.attributes[0].name === 'name') {
72	/* we have a device name */
73	assert(actionSelector.attributes[0].value instanceof Ast.StringValue);	×
74	const actionDeviceName = actionSelector.attributes[0].value;	×
75
76	if (!deviceName \|\| !actionDeviceName.equals(deviceName))	×
77	return false;	×
78	}
79
80	return true;	66,457✔
81	}
82
83	function makeCompleteActionSuccessPhrase(ctx : ContextInfo, action : Ast.Expression, info : SlotBag\|null) {
84	const results = ctx.results;	66,457✔
85	assert(results);	66,457✔
86
87	// check the action is the same we actually executed, and all the parameters we're mentioning
88	// match the actual parameters of the action
89	let last;
90	if (action instanceof Ast.ChainExpression)	66,457✔
91	last = action.last;	3✔
92	else
93	last = action;	66,454✔
94	assert(last instanceof Ast.InvocationExpression);	66,457✔
95	const ctxInvocation = C.getInvocation(ctx.current!);	66,457✔
96	if (!C.isSameFunction(ctxInvocation.schema!, last.invocation.schema!))	66,457!
97	return null;	×
98	if (!checkSelector(ctxInvocation.selector, last.invocation.selector))	66,457!
99	return null;	×
100
101	for (const newParam of last.invocation.in_params) {	66,457✔
102	if (newParam.value.isUndefined)	76,531✔
103	continue;	6,908✔
104
105	let found = false, wasParamPassing = false;	69,623✔
106	for (const oldParam of ctxInvocation.in_params) {	69,623✔
107	assert(!oldParam.value.isUndefined); // we ran the action, so it cannot have $? params	185,947✔
108
109	if (newParam.name === oldParam.name) {	185,947✔
110	if (newParam.value instanceof Ast.VarRefValue) {	69,479✔
111	// we're using a join to describe this action
112	// we don't need to check that the table is correct, because
113	// the table comes from a context phrase, but do check the action
114	// is correct
115	if (oldParam.value instanceof Ast.VarRefValue) {	3!
116	wasParamPassing = true;	3✔
117	if (newParam.value.name !== oldParam.value.name)	3!
118	return null;	×
119	} else {
120	return null;	×
121	}
122	} else {
123	// newParam is a constant, but oldParam might be a param passing
124	if (oldParam.value instanceof Ast.VarRefValue)	69,476✔
125	wasParamPassing = true;	1,032✔
126	else if (!newParam.value.equals(oldParam.value))	68,444✔
127	return null;	63,968✔
128	}
129	found = true;	5,511✔
130	break;	5,511✔
131	}
132	}
133	if (!found) {	5,655✔
134	const arg = action.schema!.getArgument(newParam.name)!;	144✔
135	if (arg.is_input)	144!
136	return null;	144✔
137
138	// if newParam is an output parameter that we appended to describe the result
139	// of the action, we allow it to be missing from the action, and we'll check
140	// against the result entry
141	}
142
143	if (!(newParam.value instanceof Ast.VarRefValue)) {	5,511✔
144	// if we can't check in the result bag, and we didn't find a constant
145	// to check against in the program, then this phrase is no good
146	// because we're hallucinating the value
147	if (results.length === 0 && (!found \|\| wasParamPassing))	5,508!
148	return null;	×
149	if (results.length > 1)	5,508✔
150	return null;	86✔
151
152	// if the parameter is a constant, check also the result entry, if we have one
153	// this checks that input parameters are correct, if they were parameter passed
154	// and checks that the output parameters are correct
155	if (results.length >= 1) {	5,422✔
156	const topResult = results[0];	5,323✔
157	const resultValue = topResult.value[newParam.name];	5,323✔
158	if (!resultValue)	5,323!
159	return null;	×
160
161	if (!resultValue.equals(newParam.value))	5,323✔
162	return null;	926✔
163	}
164	}
165	}
166
167	if (info !== null) {	1,333✔
168	if (results.length < 1)	19!
169	return null;	×
170	assert(info instanceof SlotBag);	19✔
171	if (!results.every((r) => isInfoPhraseCompatibleWithResult(r, info)))	19!
UNCOV 172	return null;	×
173	}
174
175	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), info);	1,333✔
176	}
177
178	function makeGenericActionSuccessPhrase(ctx : ContextInfo) {
179	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), null);	528✔
180	}
181
182	export interface ErrorMessage {
183	code : string;
184	bag : SlotBag;
185	}
186
187	function checkThingpediaErrorMessage(ctx : ContextInfo, msg : ErrorMessage) {
188	if (!C.isSameFunction(ctx.currentFunction!, msg.bag.schema!))	243!
189	return null;	×
190	const error = ctx.error;	243✔
191	if (!(error instanceof Ast.EnumValue) \|\| error.value !== msg.code)	243!
192	return null;	×
193
194	const action = C.getInvocation(ctx.current!);	243✔
195	for (const in_param of action.in_params) {	243✔
196	if (msg.bag.has(in_param.name) && !msg.bag.get(in_param.name)!.equals(in_param.value))	255!
197	return null;	×
198	}
199
200	return ctx;	243✔
201	}
202
203	function checkActionErrorMessage(ctx : ContextInfo, action : Ast.Invocation) {
204	// check the action is the same we actually executed, and all the parameters we're mentioning
205	// match the actual parameters of the action
206	if (!C.isSameFunction(ctx.currentFunction!, action.schema!))	144,490✔
207	return null;	81,866✔
208	const ctxInvocation = C.getInvocation(ctx.current!);	62,624✔
209	for (const newParam of action.in_params) {	62,624✔
210	if (newParam.value.isUndefined)	63,968✔
211	continue;	4,550✔
212
213	let found = false;	59,418✔
214	for (const oldParam of ctxInvocation.in_params) {	59,418✔
215	if (newParam.name === oldParam.name) {	73,106✔
216	if (!newParam.value.equals(oldParam.value))	59,418✔
217	return null;	58,882✔
218	found = true;	536✔
219	break;	536✔
220	}
221	}
222	if (!found)	536!
223	return null;	×
224	}
225
226	return ctx;	3,742✔
227	}
228
229	function makeActionErrorPhrase(ctx : ContextInfo, questions : C.ParamSlot[]) {
230	const schema = ctx.currentFunction!;	466,487✔
231	for (const q of questions) {	466,487✔
232	if (!C.isSameFunction(schema, q.schema))	464,656✔
233	return null;	457,405✔
234	const arg = schema.getArgument(q.name);	7,251✔
235	if (!arg \|\| !arg.is_input)	7,251✔
236	return null;	240✔
237	}
238	assert(Array.isArray(questions));	8,842✔
239
240	if (questions.length === 0)	8,842✔
241	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error', null));	2,590✔
242
243	if (questions.length === 1) {	6,252✔
244	const type = schema.getArgType(questions[0].name)!;	5,506✔
245	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error_question', questions.map((q) => q.name)), null, type);	5,506✔
246	}
247	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error_question', questions.map((q) => q.name)));	1,492✔
248	}
249
250	function actionErrorChangeParam(ctx : ContextInfo, answer : Ast.Value\|C.InputParamSlot) {
251	const schema = ctx.currentFunction!;	3,969,721✔
252	const questions = ctx.state.dialogueActParam as string[] \|\| [];	3,969,721✔
253	let ipslot : C.InputParamSlot;
254	if (answer instanceof Ast.Value) {	3,969,721✔
255	if (questions.length !== 1)	1,820,826✔
256	return null;	1,307,281✔
257	const arg = schema.getArgument(questions[0]);	513,545✔
258	if (!arg \|\| !arg.is_input \|\| !arg.type.equals(answer.getType()))	513,545✔
259	return null;	511,306✔
260	ipslot = {	2,239✔
261	schema,
262	ptype: answer.getType(),
263	ast: new Ast.InputParam(null, questions[0], answer)
264	};
265	} else {
266	ipslot = answer;	2,148,895✔
267	if (!C.isSameFunction(ipslot.schema, schema))	2,148,895✔
268	return null;	2,102,028✔
269	}
270	// TODO implement this template for queries
271	if (schema.functionType !== 'action')	49,106✔
272	return null;	385✔
273
274	const clone = ctx.current!.clone();	48,721✔
275	const action = C.getInvocation(clone);	48,721✔
276	if (!action)	48,721!
277	return null;	×
278	setOrAddInvocationParam(action, ipslot.ast.name, ipslot.ast.value);	48,721✔
279	return addNewItem(ctx, 'execute', null, 'accepted', clone);	48,721✔
280	}
281
282	function actionSuccessQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
283	if (ctx.resultInfo && ctx.resultInfo.hasStream)	427,164✔
284	return null;	30,615✔
285
286	for (const q of questions) {	396,549✔
287	if (!C.isSameFunction(q.schema, ctx.currentFunction!))	396,549✔
288	return null;	394,697✔
289	const arg = ctx.currentFunction!.getArgument(q.name);	1,852✔
290	if (!arg \|\| arg.is_input)	1,852!
291	return null;	×
292	}
293	return makeSimpleState(ctx, 'action_question', questions.map((q) => q.name));	1,852✔
294	}
295
296	export {
297	makeThingpediaActionSuccessPhrase,	5✔
298	makeCompleteActionSuccessPhrase,	5✔
299	makeGenericActionSuccessPhrase,	5✔
300	checkThingpediaErrorMessage,	5✔
301	checkActionErrorMessage,	5✔
302	makeActionErrorPhrase,	5✔
303
304	actionErrorChangeParam,	5✔
305	actionSuccessQuestion	5✔
306	};

stanford-oval / genie-toolkit / 1927

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