1665

pending completion

Build # 1665

Build Type

push

travis-ci-com

Committed by

web-flow

Commit Message

Merge pull request #469 from stanford-oval/wip/recording-mode-fix

Fix logging: update the log whenever agent/user says something

Run Details

10858 of 23300 branches covered (46.6%)

Branch coverage included in aggregate %.

35 of 37 new or added lines in 2 files covered. (94.59%)

5 existing lines in 3 files now uncovered.

25418 of 43947 relevant lines covered (57.84%)

547033.37 hits per line

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

88.98

/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,
    replaceAction,
} 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 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!, action.schema!))
        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 || [];
    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;
    }

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

function actionSuccessQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
    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';	2✔
23
24	import { Ast } from 'thingtalk';	2✔
25
26	import * as C from '../ast_manip';	2✔
27
28	import { SlotBag } from '../slot_bag';	2✔
29	import {	2✔
30	ContextInfo,
31	makeAgentReply,
32	makeSimpleState,
33	setOrAddInvocationParam,
34	replaceAction,
35	} from '../state_manip';
36	import {	2✔
37	isInfoPhraseCompatibleWithResult
38	} from './common';
39
40	export type ActionSuccessPhraseWithResult = [Ast.Expression\|null, SlotBag];
41
42	export function actionSuccessPhraseWithResultKeyFn([expression, bag] : ActionSuccessPhraseWithResult) {	2✔
43	return {	860✔
44	functionName: bag.schema!.qualifiedName
45	};
46	}
47
48	function makeThingpediaActionSuccessPhrase(ctx : ContextInfo, info : SlotBag) {
49	const results = ctx.results;	15✔
50	if (!results \|\| results.length !== 1)	15✔
51	return null;	11✔
52
53	const ctxInvocation = C.getInvocation(ctx.current!);	4✔
54	if (!C.isSameFunction(ctxInvocation.schema!, info.schema!))	4!
55	return null;	×
56
57	const topResult = results[0];	4✔
58	if (!isInfoPhraseCompatibleWithResult(topResult, info))	4!
UNCOV 59	return null;	×
60
61	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), info);	4✔
62	}
63
64	function makeCompleteActionSuccessPhrase(ctx : ContextInfo, action : Ast.Expression, info : SlotBag\|null) {
65	const results = ctx.results;	26,112✔
66	assert(results);	26,112✔
67
68	// check the action is the same we actually executed, and all the parameters we're mentioning
69	// match the actual parameters of the action
70	let last;
71	if (action instanceof Ast.ChainExpression)	26,112✔
72	last = action.last;	2✔
73	else
74	last = action;	26,110✔
75	assert(last instanceof Ast.InvocationExpression);	26,112✔
76	const ctxInvocation = C.getInvocation(ctx.current!);	26,112✔
77	if (!C.isSameFunction(ctxInvocation.schema!, action.schema!))	26,112!
78	return null;	×
79
80	for (const newParam of last.invocation.in_params) {	26,112✔
81	if (newParam.value.isUndefined)	30,285✔
82	continue;	3,079✔
83
84	let found = false, wasParamPassing = false;	27,206✔
85	for (const oldParam of ctxInvocation.in_params) {	27,206✔
86	assert(!oldParam.value.isUndefined); // we ran the action, so it cannot have $? params	65,483✔
87
88	if (newParam.name === oldParam.name) {	65,483✔
89	if (newParam.value instanceof Ast.VarRefValue) {	27,043✔
90	// we're using a join to describe this action
91	// we don't need to check that the table is correct, because
92	// the table comes from a context phrase, but do check the action
93	// is correct
94	if (oldParam.value instanceof Ast.VarRefValue) {	2!
95	wasParamPassing = true;	2✔
96	if (newParam.value.name !== oldParam.value.name)	2!
97	return null;	×
98	} else {
99	return null;	×
100	}
101	} else {
102	// newParam is a constant, but oldParam might be a param passing
103	if (oldParam.value instanceof Ast.VarRefValue)	27,041✔
104	wasParamPassing = true;	629✔
105	else if (!newParam.value.equals(oldParam.value))	26,412✔
106	return null;	24,896✔
107	}
108	found = true;	2,147✔
109	break;	2,147✔
110	}
111	}
112	if (!found) {	2,310✔
113	const arg = action.schema!.getArgument(newParam.name)!;	163✔
114	if (arg.is_input)	163!
115	return null;	163✔
116
117	// if newParam is an output parameter that we appended to describe the result
118	// of the action, we allow it to be missing from the action, and we'll check
119	// against the result entry
120	}
121
122	if (!(newParam.value instanceof Ast.VarRefValue)) {	2,147✔
123	// if we can't check in the result bag, and we didn't find a constant
124	// to check against in the program, then this phrase is no good
125	// because we're hallucinating the value
126	if (results.length === 0 && (!found \|\| wasParamPassing))	2,145!
127	return null;	×
128	if (results.length > 1)	2,145✔
129	return null;	397✔
130
131	// if the parameter is a constant, check also the result entry, if we have one
132	// this checks that input parameters are correct, if they were parameter passed
133	// and checks that the output parameters are correct
134	if (results.length >= 1) {	1,748✔
135	const topResult = results[0];	1,727✔
136	const resultValue = topResult.value[newParam.name];	1,727✔
137	if (!resultValue)	1,727!
138	return null;	×
139
140	if (!resultValue.equals(newParam.value))	1,727✔
141	return null;	225✔
142	}
143	}
144	}
145
146	if (info !== null) {	431✔
147	if (results.length < 1)	6!
148	return null;	×
149	assert(info instanceof SlotBag);	6✔
150	if (!results.every((r) => isInfoPhraseCompatibleWithResult(r, info)))	6!
151	return null;	×
152	}
153
154	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), info);	431✔
155	}
156
157	function makeGenericActionSuccessPhrase(ctx : ContextInfo) {
158	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), null);	166✔
159	}
160
161	export interface ErrorMessage {
162	code : string;
163	bag : SlotBag;
164	}
165
166	function checkThingpediaErrorMessage(ctx : ContextInfo, msg : ErrorMessage) {
167	if (!C.isSameFunction(ctx.currentFunction!, msg.bag.schema!))	177!
168	return null;	×
169	const error = ctx.error;	177✔
170	if (!(error instanceof Ast.EnumValue) \|\| error.value !== msg.code)	177✔
171	return null;	36✔
172
173	const action = C.getInvocation(ctx.current!);	141✔
174	for (const in_param of action.in_params) {	141✔
175	if (msg.bag.has(in_param.name) && !msg.bag.get(in_param.name)!.equals(in_param.value))	199✔
176	return null;	38✔
177	}
178
179	return ctx;	103✔
180	}
181
182	function checkActionErrorMessage(ctx : ContextInfo, action : Ast.Invocation) {
183	// check the action is the same we actually executed, and all the parameters we're mentioning
184	// match the actual parameters of the action
185	if (!C.isSameFunction(ctx.currentFunction!, action.schema!))	18,035✔
186	return null;	2,244✔
187	const ctxInvocation = C.getInvocation(ctx.current!);	15,791✔
188	for (const newParam of action.in_params) {	15,791✔
189	if (newParam.value.isUndefined)	17,069✔
190	continue;	3,375✔
191
192	let found = false;	13,694✔
193	for (const oldParam of ctxInvocation.in_params) {	13,694✔
194	if (newParam.name === oldParam.name) {	20,234✔
195	if (!newParam.value.equals(oldParam.value))	13,611✔
196	return null;	13,220✔
197	found = true;	391✔
198	break;	391✔
199	}
200	}
201	if (!found)	474✔
202	return null;	83✔
203	}
204
205	return ctx;	2,488✔
206	}
207
208	function makeActionErrorPhrase(ctx : ContextInfo, questions : C.ParamSlot[]) {
209	const schema = ctx.currentFunction!;	205,441✔
210	for (const q of questions) {	205,441✔
211	if (!C.isSameFunction(schema, q.schema))	206,169✔
212	return null;	199,438✔
213	const arg = schema.getArgument(q.name);	6,731✔
214	if (!arg \|\| !arg.is_input)	6,731!
215	return null;	×
216	}
217	assert(Array.isArray(questions));	6,003✔
218
219	if (questions.length === 0)	6,003✔
220	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error', null));	101✔
221
222	if (questions.length === 1) {	5,902✔
223	const type = schema.getArgType(questions[0].name)!;	5,073✔
224	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error_question', questions.map((q) => q.name)), null, type);	5,073✔
225	}
226	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error_question', questions.map((q) => q.name)));	1,658✔
227	}
228
229	function actionErrorChangeParam(ctx : ContextInfo, answer : Ast.Value\|C.InputParamSlot) {
230	const schema = ctx.currentFunction!;	3,504,886✔
231	const questions = ctx.state.dialogueActParam \|\| [];	3,504,886✔
232	let ipslot : C.InputParamSlot;
233	if (answer instanceof Ast.Value) {	3,504,886✔
234	if (questions.length !== 1)	1,743,290✔
235	return null;	60,949✔
236	const arg = schema.getArgument(questions[0]);	1,682,341✔
237	if (!arg \|\| !arg.is_input \|\| !arg.type.equals(answer.getType()))	1,682,341✔
238	return null;	1,677,756✔
239	ipslot = {	4,585✔
240	schema,
241	ptype: answer.getType(),
242	ast: new Ast.InputParam(null, questions[0], answer)
243	};
244	} else {
245	ipslot = answer;	1,761,596✔
246	if (!C.isSameFunction(ipslot.schema, schema))	1,761,596✔
247	return null;	1,686,734✔
248	}
249
250	const action = C.getInvocation(ctx.current!);	79,447✔
251	if (!action)	79,447!
252	return null;	×
253	// shallow clone
254	const clone = action.clone();	79,447✔
255	setOrAddInvocationParam(clone, ipslot.ast.name, ipslot.ast.value);	79,447✔
256	return replaceAction(ctx, 'execute', clone, 'accepted');	79,447✔
257	}
258
259	function actionSuccessQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
260	for (const q of questions) {	299,443✔
261	if (!C.isSameFunction(q.schema, ctx.currentFunction!))	299,443✔
262	return null;	299,195✔
263	const arg = ctx.currentFunction!.getArgument(q.name);	248✔
264	if (!arg \|\| arg.is_input)	248!
265	return null;	×
266	}
267	return makeSimpleState(ctx, 'action_question', questions.map((q) => q.name));	248✔
268	}
269
270	export {
271	makeThingpediaActionSuccessPhrase,	2✔
272	makeCompleteActionSuccessPhrase,	2✔
273	makeGenericActionSuccessPhrase,	2✔
274	checkThingpediaErrorMessage,	2✔
275	checkActionErrorMessage,	2✔
276	makeActionErrorPhrase,	2✔
277
278	actionErrorChangeParam,	2✔
279	actionSuccessQuestion	2✔
280	};

stanford-oval / genie-toolkit / 1665

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