1663

pending completion

Build # 1663

Build Type

Pull #469

travis-ci-com

Committed by

web-flow

Commit Message

Merge 2c164dbef into c0f477e24

Pull Request Pull Request #469: Fix logging: update the log whenever agent/user says something

Run Details

10843 of 23300 branches covered (46.54%)

Branch coverage included in aggregate %.

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

23 existing lines in 8 files now uncovered.

25400 of 43947 relevant lines covered (57.8%)

542884.78 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 {	950✔
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;	6✔
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!
UNCOV 59	return null;	×
60
61	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), info);	9✔
62	}
63
64	function makeCompleteActionSuccessPhrase(ctx : ContextInfo, action : Ast.Expression, info : SlotBag\|null) {
65	const results = ctx.results;	26,033✔
66	assert(results);	26,033✔
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,033✔
72	last = action.last;	3✔
73	else
74	last = action;	26,030✔
75	assert(last instanceof Ast.InvocationExpression);	26,033✔
76	const ctxInvocation = C.getInvocation(ctx.current!);	26,033✔
77	if (!C.isSameFunction(ctxInvocation.schema!, action.schema!))	26,033!
78	return null;	×
79
80	for (const newParam of last.invocation.in_params) {	26,033✔
81	if (newParam.value.isUndefined)	30,215✔
82	continue;	3,075✔
83
84	let found = false, wasParamPassing = false;	27,140✔
85	for (const oldParam of ctxInvocation.in_params) {	27,140✔
86	assert(!oldParam.value.isUndefined); // we ran the action, so it cannot have $? params	65,417✔
87
88	if (newParam.name === oldParam.name) {	65,417✔
89	if (newParam.value instanceof Ast.VarRefValue) {	26,977✔
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) {	3!
95	wasParamPassing = true;	3✔
96	if (newParam.value.name !== oldParam.value.name)	3!
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)	26,974✔
104	wasParamPassing = true;	654✔
105	else if (!newParam.value.equals(oldParam.value))	26,320✔
106	return null;	24,800✔
107	}
108	found = true;	2,177✔
109	break;	2,177✔
110	}
111	}
112	if (!found) {	2,340✔
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,177✔
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,174!
127	return null;	×
128	if (results.length > 1)	2,174✔
129	return null;	414✔
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,760✔
135	const topResult = results[0];	1,731✔
136	const resultValue = topResult.value[newParam.name];	1,731✔
137	if (!resultValue)	1,731!
138	return null;	×
139
140	if (!resultValue.equals(newParam.value))	1,731✔
141	return null;	236✔
142	}
143	}
144	}
145
146	if (info !== null) {	420✔
147	if (results.length < 1)	5!
148	return null;	×
149	assert(info instanceof SlotBag);	5✔
150	if (!results.every((r) => isInfoPhraseCompatibleWithResult(r, info)))	5!
151	return null;	×
152	}
153
154	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), info);	420✔
155	}
156
157	function makeGenericActionSuccessPhrase(ctx : ContextInfo) {
158	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), null);	167✔
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!))	187!
168	return null;	×
169	const error = ctx.error;	187✔
170	if (!(error instanceof Ast.EnumValue) \|\| error.value !== msg.code)	187✔
171	return null;	36✔
172
173	const action = C.getInvocation(ctx.current!);	151✔
174	for (const in_param of action.in_params) {	151✔
175	if (msg.bag.has(in_param.name) && !msg.bag.get(in_param.name)!.equals(in_param.value))	209✔
176	return null;	38✔
177	}
178
179	return ctx;	113✔
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!))	17,123✔
186	return null;	2,321✔
187	const ctxInvocation = C.getInvocation(ctx.current!);	14,802✔
188	for (const newParam of action.in_params) {	14,802✔
189	if (newParam.value.isUndefined)	16,080✔
190	continue;	3,783✔
191
192	let found = false;	12,297✔
193	for (const oldParam of ctxInvocation.in_params) {	12,297✔
194	if (newParam.name === oldParam.name) {	18,837✔
195	if (!newParam.value.equals(oldParam.value))	12,214✔
196	return null;	11,870✔
197	found = true;	344✔
198	break;	344✔
199	}
200	}
201	if (!found)	427✔
202	return null;	83✔
203	}
204
205	return ctx;	2,849✔
206	}
207
208	function makeActionErrorPhrase(ctx : ContextInfo, questions : C.ParamSlot[]) {
209	const schema = ctx.currentFunction!;	194,113✔
210	for (const q of questions) {	194,113✔
211	if (!C.isSameFunction(schema, q.schema))	194,831✔
212	return null;	188,202✔
213	const arg = schema.getArgument(q.name);	6,629✔
214	if (!arg \|\| !arg.is_input)	6,629!
215	return null;	×
216	}
217	assert(Array.isArray(questions));	5,911✔
218
219	if (questions.length === 0)	5,911✔
220	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error', null));	111✔
221
222	if (questions.length === 1) {	5,800✔
223	const type = schema.getArgType(questions[0].name)!;	4,971✔
224	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error_question', questions.map((q) => q.name)), null, type);	4,971✔
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,112,452✔
231	const questions = ctx.state.dialogueActParam \|\| [];	3,112,452✔
232	let ipslot : C.InputParamSlot;
233	if (answer instanceof Ast.Value) {	3,112,452✔
234	if (questions.length !== 1)	1,568,583✔
235	return null;	69,360✔
236	const arg = schema.getArgument(questions[0]);	1,499,223✔
237	if (!arg \|\| !arg.is_input \|\| !arg.type.equals(answer.getType()))	1,499,223✔
238	return null;	1,494,772✔
239	ipslot = {	4,451✔
240	schema,
241	ptype: answer.getType(),
242	ast: new Ast.InputParam(null, questions[0], answer)
243	};
244	} else {
245	ipslot = answer;	1,543,869✔
246	if (!C.isSameFunction(ipslot.schema, schema))	1,543,869✔
247	return null;	1,473,866✔
248	}
249
250	const action = C.getInvocation(ctx.current!);	74,454✔
251	if (!action)	74,454!
252	return null;	×
253	// shallow clone
254	const clone = action.clone();	74,454✔
255	setOrAddInvocationParam(clone, ipslot.ast.name, ipslot.ast.value);	74,454✔
256	return replaceAction(ctx, 'execute', clone, 'accepted');	74,454✔
257	}
258
259	function actionSuccessQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
260	for (const q of questions) {	312,341✔
261	if (!C.isSameFunction(q.schema, ctx.currentFunction!))	312,341✔
262	return null;	312,087✔
263	const arg = ctx.currentFunction!.getArgument(q.name);	254✔
264	if (!arg \|\| arg.is_input)	254!
265	return null;	×
266	}
267	return makeSimpleState(ctx, 'action_question', questions.map((q) => q.name));	254✔
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 / 1663

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