1862

pending completion

Build # 1862

Build Type

Pull #558

travis-ci-com

Committed by

web-flow

Commit Message

Merge 06afa0432 into 044c55009

Pull Request Pull Request #558: Basic support for streams

Run Details

11403 of 24725 branches covered (46.12%)

Branch coverage included in aggregate %.

63 of 70 new or added lines in 8 files covered. (90.0%)

421 existing lines in 15 files now uncovered.

26734 of 46701 relevant lines covered (57.25%)

494122.52 hits per line

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

86.67

/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[]) {
    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';	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 {	4,385✔
44	functionName: bag.schema!.qualifiedName
45	};
46	}
47
48	function makeThingpediaActionSuccessPhrase(ctx : ContextInfo, info : SlotBag) {
49	const results = ctx.results;	72✔
50	if (!results \|\| results.length !== 1)	72!
51	return null;	×
52
53	const ctxInvocation = C.getInvocation(ctx.current!);	72✔
54	if (!C.isSameFunction(ctxInvocation.schema!, info.schema!))	72!
55	return null;	×
56
57	const topResult = results[0];	72✔
58	if (!isInfoPhraseCompatibleWithResult(topResult, info))	72✔
59	return null;	47✔
60
61	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), info);	25✔
62	}
63
64	function makeCompleteActionSuccessPhrase(ctx : ContextInfo, action : Ast.Expression, info : SlotBag\|null) {
65	const results = ctx.results;	58,726✔
66	assert(results);	58,726✔
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)	58,726!
UNCOV 72	last = action.last;	×
73	else
74	last = action;	58,726✔
75	assert(last instanceof Ast.InvocationExpression);	58,726✔
76	const ctxInvocation = C.getInvocation(ctx.current!);	58,726✔
77	if (!C.isSameFunction(ctxInvocation.schema!, action.schema!))	58,726!
78	return null;	×
79
80	for (const newParam of last.invocation.in_params) {	58,726✔
81	if (newParam.value.isUndefined)	67,251✔
82	continue;	5,605✔
83
84	let found = false, wasParamPassing = false;	61,646✔
85	for (const oldParam of ctxInvocation.in_params) {	61,646✔
86	assert(!oldParam.value.isUndefined); // we ran the action, so it cannot have $? params	167,651✔
87
88	if (newParam.name === oldParam.name) {	167,651✔
89	if (newParam.value instanceof Ast.VarRefValue) {	61,514!
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
UNCOV 94	if (oldParam.value instanceof Ast.VarRefValue) {	×
UNCOV 95	wasParamPassing = true;	×
UNCOV 96	if (newParam.value.name !== oldParam.value.name)	×
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)	61,514✔
104	wasParamPassing = true;	1,078✔
105	else if (!newParam.value.equals(oldParam.value))	60,436✔
106	return null;	56,185✔
107	}
108	found = true;	5,329✔
109	break;	5,329✔
110	}
111	}
112	if (!found) {	5,461✔
113	const arg = action.schema!.getArgument(newParam.name)!;	132✔
114	if (arg.is_input)	132!
115	return null;	132✔
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)) {	5,329!
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))	5,329!
127	return null;	×
128	if (results.length > 1)	5,329✔
129	return null;	141✔
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) {	5,188✔
135	const topResult = results[0];	5,003✔
136	const resultValue = topResult.value[newParam.name];	5,003✔
137	if (!resultValue)	5,003!
138	return null;	×
139
140	if (!resultValue.equals(newParam.value))	5,003✔
141	return null;	902✔
142	}
143	}
144	}
145
146	if (info !== null) {	1,366✔
147	if (results.length < 1)	109!
148	return null;	×
149	assert(info instanceof SlotBag);	109✔
150	if (!results.every((r) => isInfoPhraseCompatibleWithResult(r, info)))	109!
151	return null;	×
152	}
153
154	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), info);	1,366✔
155	}
156
157	function makeGenericActionSuccessPhrase(ctx : ContextInfo) {
158	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_success', null), null);	592✔
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!))	144!
168	return null;	×
169	const error = ctx.error;	144✔
170	if (!(error instanceof Ast.EnumValue) \|\| error.value !== msg.code)	144✔
171	return null;	43✔
172
173	const action = C.getInvocation(ctx.current!);	101✔
174	for (const in_param of action.in_params) {	101✔
175	if (msg.bag.has(in_param.name) && !msg.bag.get(in_param.name)!.equals(in_param.value))	122✔
176	return null;	7✔
177	}
178
179	return ctx;	94✔
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!))	185,840✔
186	return null;	123,674✔
187	const ctxInvocation = C.getInvocation(ctx.current!);	62,166✔
188	for (const newParam of action.in_params) {	62,166✔
189	if (newParam.value.isUndefined)	63,928✔
190	continue;	3,356✔
191
192	let found = false;	60,572✔
193	for (const oldParam of ctxInvocation.in_params) {	60,572✔
194	if (newParam.name === oldParam.name) {	77,848✔
195	if (!newParam.value.equals(oldParam.value))	60,550✔
196	return null;	59,664✔
197	found = true;	886✔
198	break;	886✔
199	}
200	}
201	if (!found)	908✔
202	return null;	22✔
203	}
204
205	return ctx;	2,480✔
206	}
207
208	function makeActionErrorPhrase(ctx : ContextInfo, questions : C.ParamSlot[]) {
209	const schema = ctx.currentFunction!;	308,241✔
210	for (const q of questions) {	308,241✔
211	if (!C.isSameFunction(schema, q.schema))	307,040✔
212	return null;	298,314✔
213	const arg = schema.getArgument(q.name);	8,726✔
214	if (!arg \|\| !arg.is_input)	8,726✔
215	return null;	836✔
216	}
217	assert(Array.isArray(questions));	9,091✔
218
219	if (questions.length === 0)	9,091✔
220	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error', null));	2,058✔
221
222	if (questions.length === 1) {	7,033✔
223	const type = schema.getArgType(questions[0].name)!;	6,176✔
224	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error_question', questions.map((q) => q.name)), null, type);	6,176✔
225	}
226	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_action_error_question', questions.map((q) => q.name)));	1,714✔
227	}
228
229	function actionErrorChangeParam(ctx : ContextInfo, answer : Ast.Value\|C.InputParamSlot) {
230	const schema = ctx.currentFunction!;	2,284,924✔
231	const questions = ctx.state.dialogueActParam \|\| [];	2,284,924✔
232	let ipslot : C.InputParamSlot;
233	if (answer instanceof Ast.Value) {	2,284,924✔
234	if (questions.length !== 1)	1,060,412✔
235	return null;	612,174✔
236	const arg = schema.getArgument(questions[0]);	448,238✔
237	if (!arg \|\| !arg.is_input \|\| !arg.type.equals(answer.getType()))	448,238✔
238	return null;	446,979✔
239	ipslot = {	1,259✔
240	schema,
241	ptype: answer.getType(),
242	ast: new Ast.InputParam(null, questions[0], answer)
243	};
244	} else {
245	ipslot = answer;	1,224,512✔
246	if (!C.isSameFunction(ipslot.schema, schema))	1,224,512✔
247	return null;	1,197,961✔
248	}
249	// TODO implement this template for queries
250	if (schema.functionType !== 'action')	27,810✔
251	return null;	2,992✔
252
253	const action = C.getInvocation(ctx.current!);	24,818✔
254	if (!action)	24,818!
255	return null;	×
256	// shallow clone
257	const clone = action.clone();	24,818✔
258	setOrAddInvocationParam(clone, ipslot.ast.name, ipslot.ast.value);	24,818✔
259	return replaceAction(ctx, 'execute', clone, 'accepted');	24,818✔
260	}
261
262	function actionSuccessQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
263	if (ctx.resultInfo && ctx.resultInfo.hasStream)	333,204✔
264	return null;	24,683✔
265
266	for (const q of questions) {	308,521✔
267	if (!C.isSameFunction(q.schema, ctx.currentFunction!))	308,521✔
268	return null;	306,660✔
269	const arg = ctx.currentFunction!.getArgument(q.name);	1,861✔
270	if (!arg \|\| arg.is_input)	1,861!
271	return null;	×
272	}
273	return makeSimpleState(ctx, 'action_question', questions.map((q) => q.name));	1,861✔
274	}
275
276	export {
277	makeThingpediaActionSuccessPhrase,	2✔
278	makeCompleteActionSuccessPhrase,	2✔
279	makeGenericActionSuccessPhrase,	2✔
280	checkThingpediaErrorMessage,	2✔
281	checkActionErrorMessage,	2✔
282	makeActionErrorPhrase,	2✔
283
284	actionErrorChangeParam,	2✔
285	actionSuccessQuestion	2✔
286	};

stanford-oval / genie-toolkit / 1862

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