1734

pending completion

Build # 1734

Build Type

Pull #516

travis-ci-com

Committed by

web-flow

Commit Message

Merge 28aa77f52 into 2eade6aa4

Pull Request Pull Request #516: Update ThingTalk to git

Run Details

10929 of 23388 branches covered (46.73%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

12 existing lines in 2 files now uncovered.

25495 of 44048 relevant lines covered (57.88%)

562857.2 hits per line

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

86.75

/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;
    }
    // TODO implement this template for queries
    if (schema.functionType !== 'action')
        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 {	3,834✔
44	functionName: bag.schema!.qualifiedName
45	};
46	}
47
48	function makeThingpediaActionSuccessPhrase(ctx : ContextInfo, info : SlotBag) {
49	const results = ctx.results;	25✔
50	if (!results \|\| results.length !== 1)	25✔
51	return null;	13✔
52
53	const ctxInvocation = C.getInvocation(ctx.current!);	12✔
54	if (!C.isSameFunction(ctxInvocation.schema!, info.schema!))	12!
55	return null;	×
56
57	const topResult = results[0];	12✔
58	if (!isInfoPhraseCompatibleWithResult(topResult, info))	12!
59	return null;	×
60
61	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), info);	12✔
62	}
63
64	function makeCompleteActionSuccessPhrase(ctx : ContextInfo, action : Ast.Expression, info : SlotBag\|null) {
65	const results = ctx.results;	28,168✔
66	assert(results);	28,168✔
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)	28,168✔
72	last = action.last;	3✔
73	else
74	last = action;	28,165✔
75	assert(last instanceof Ast.InvocationExpression);	28,168✔
76	const ctxInvocation = C.getInvocation(ctx.current!);	28,168✔
77	if (!C.isSameFunction(ctxInvocation.schema!, action.schema!))	28,168!
78	return null;	×
79
80	for (const newParam of last.invocation.in_params) {	28,168✔
81	if (newParam.value.isUndefined)	31,799✔
82	continue;	2,823✔
83
84	let found = false, wasParamPassing = false;	28,976✔
85	for (const oldParam of ctxInvocation.in_params) {	28,976✔
86	assert(!oldParam.value.isUndefined); // we ran the action, so it cannot have $? params	71,570✔
87
88	if (newParam.name === oldParam.name) {	71,570✔
89	if (newParam.value instanceof Ast.VarRefValue) {	28,838✔
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)	28,835✔
104	wasParamPassing = true;	822✔
105	else if (!newParam.value.equals(oldParam.value))	28,013✔
106	return null;	26,463✔
107	}
108	found = true;	2,375✔
109	break;	2,375✔
110	}
111	}
112	if (!found) {	2,513✔
113	const arg = action.schema!.getArgument(newParam.name)!;	138✔
114	if (arg.is_input)	138!
115	return null;	138✔
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,375✔
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,372!
127	return null;	×
128	if (results.length > 1)	2,372✔
129	return null;	311✔
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) {	2,061✔
135	const topResult = results[0];	1,963✔
136	const resultValue = topResult.value[newParam.name];	1,963✔
137	if (!resultValue)	1,963!
138	return null;	×
139
140	if (!resultValue.equals(newParam.value))	1,963✔
141	return null;	489✔
142	}
143	}
144	}
145
146	if (info !== null) {	767✔
147	if (results.length < 1)	39!
148	return null;	×
149	assert(info instanceof SlotBag);	39✔
150	if (!results.every((r) => isInfoPhraseCompatibleWithResult(r, info)))	40✔
151	return null;	1✔
152	}
153
154	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), info);	766✔
155	}
156
157	function makeGenericActionSuccessPhrase(ctx : ContextInfo) {
158	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), null);	161✔
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!))	162!
168	return null;	×
169	const error = ctx.error;	162✔
170	if (!(error instanceof Ast.EnumValue) \|\| error.value !== msg.code)	162✔
171	return null;	45✔
172
173	const action = C.getInvocation(ctx.current!);	117✔
174	for (const in_param of action.in_params) {	117✔
175	if (msg.bag.has(in_param.name) && !msg.bag.get(in_param.name)!.equals(in_param.value))	122✔
176	return null;	17✔
177	}
178
179	return ctx;	100✔
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!))	35,456✔
186	return null;	23,189✔
187	const ctxInvocation = C.getInvocation(ctx.current!);	12,267✔
188	for (const newParam of action.in_params) {	12,267✔
189	if (newParam.value.isUndefined)	12,267✔
190	continue;	2,360✔
191
192	let found = false;	9,907✔
193	for (const oldParam of ctxInvocation.in_params) {	9,907✔
194	if (newParam.name === oldParam.name) {	9,907!
195	if (!newParam.value.equals(oldParam.value))	9,907!
196	return null;	9,907✔
UNCOV 197	found = true;	×
UNCOV 198	break;	×
199	}
200	}
UNCOV 201	if (!found)	×
202	return null;	×
203	}
204
205	return ctx;	2,360✔
206	}
207
208	function makeActionErrorPhrase(ctx : ContextInfo, questions : C.ParamSlot[]) {
209	const schema = ctx.currentFunction!;	177,840✔
210	for (const q of questions) {	177,840✔
211	if (!C.isSameFunction(schema, q.schema))	177,735✔
212	return null;	173,627✔
213	const arg = schema.getArgument(q.name);	4,108✔
214	if (!arg \|\| !arg.is_input)	4,108!
215	return null;	×
216	}
217	assert(Array.isArray(questions));	4,213✔
218
219	if (questions.length === 0)	4,213✔
220	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error', null));	113✔
221
222	if (questions.length === 1) {	4,100✔
223	const type = schema.getArgType(questions[0].name)!;	4,092✔
224	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error_question', questions.map((q) => q.name)), null, type);	4,092✔
225	}
226	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error_question', questions.map((q) => q.name)));	16✔
227	}
228
229	function actionErrorChangeParam(ctx : ContextInfo, answer : Ast.Value\|C.InputParamSlot) {
230	const schema = ctx.currentFunction!;	1,576,155✔
231	const questions = ctx.state.dialogueActParam \|\| [];	1,576,155✔
232	let ipslot : C.InputParamSlot;
233	if (answer instanceof Ast.Value) {	1,576,155✔
234	if (questions.length !== 1)	780,748✔
235	return null;	34,438✔
236	const arg = schema.getArgument(questions[0]);	746,310✔
237	if (!arg \|\| !arg.is_input \|\| !arg.type.equals(answer.getType()))	746,310✔
238	return null;	743,640✔
239	ipslot = {	2,670✔
240	schema,
241	ptype: answer.getType(),
242	ast: new Ast.InputParam(null, questions[0], answer)
243	};
244	} else {
245	ipslot = answer;	795,407✔
246	if (!C.isSameFunction(ipslot.schema, schema))	795,407✔
247	return null;	768,197✔
248	}
249	// TODO implement this template for queries
250	if (schema.functionType !== 'action')	29,880✔
251	return null;	1,516✔
252
253	const action = C.getInvocation(ctx.current!);	28,364✔
254	if (!action)	28,364!
255	return null;	×
256	// shallow clone
257	const clone = action.clone();	28,364✔
258	setOrAddInvocationParam(clone, ipslot.ast.name, ipslot.ast.value);	28,364✔
259	return replaceAction(ctx, 'execute', clone, 'accepted');	28,364✔
260	}
261
262	function actionSuccessQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
263	for (const q of questions) {	470,990✔
264	if (!C.isSameFunction(q.schema, ctx.currentFunction!))	470,990✔
265	return null;	470,532✔
266	const arg = ctx.currentFunction!.getArgument(q.name);	458✔
267	if (!arg \|\| arg.is_input)	458!
268	return null;	×
269	}
270	return makeSimpleState(ctx, 'action_question', questions.map((q) => q.name));	458✔
271	}
272
273	export {
274	makeThingpediaActionSuccessPhrase,	2✔
275	makeCompleteActionSuccessPhrase,	2✔
276	makeGenericActionSuccessPhrase,	2✔
277	checkThingpediaErrorMessage,	2✔
278	checkActionErrorMessage,	2✔
279	makeActionErrorPhrase,	2✔
280
281	actionErrorChangeParam,	2✔
282	actionSuccessQuestion	2✔
283	};

stanford-oval / genie-toolkit / 1734

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