1332

pending completion

Build # 1332

Build Type

push

travis-ci-com

Committed by

web-flow

Commit Message

Merge pull request #355 from stanford-oval/wip/last-minute-fixes

Last minute fixes

Run Details

6928 of 13031 branches covered (53.17%)

Branch coverage included in aggregate %.

13 of 23 new or added lines in 4 files covered. (56.52%)

14 existing lines in 6 files now uncovered.

15601 of 24860 relevant lines covered (62.76%)

1661846.86 hits per line

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

54.04

/languages/thingtalk/dialogue_acts/recommendation.js

// -*- mode: js; 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>
"use strict";

const assert = require('assert');

const ThingTalk = require('thingtalk');
const Ast = ThingTalk.Ast;

const C = require('../ast_manip');

const { SlotBag, checkAndAddSlot } = require('../slot_bag');
const {
    makeAgentReply,
    makeSimpleState,
    addActionParam,
    addNewItem,
} = require('../state_manip');
const {
    isInfoPhraseCompatibleWithResult,
    findChainParam
} = require('./common');
const {
    refineFilterToAnswerQuestionOrChangeFilter,
    combinePreambleAndRequest,
    proposalReply
} = require('./refinement-helpers');
const {
    checkInfoPhrase
} = require('./results');


function makeActionRecommendation(ctx, action) {
    assert(action instanceof Ast.Invocation);

    const results = ctx.results;
    assert(results.length > 0);
    const currentTable = ctx.current.stmt.table;
    if (currentTable && currentTable.isSlice && currentTable.limit.value !== 1)
        return null;

    const topResult = results[0];
    const id = topResult.value.id;
    if (!id)
        return null;

    if (action.in_params.length !== 1)
        return null;

    for (let param of action.in_params) {
        if (param.value.equals(id))
            return { topResult, info: null, action };
    }

    return null;
}

function makeArgMinMaxRecommendation(ctx, name, base, param, direction) {
    if (!ctx.resultInfo.argMinMaxField)
        return null;
    if (!C.isSameFunction(base.schema, ctx.currentFunctionSchema))
        return null;
    if (direction !== ctx.resultInfo.argMinMaxField[1] ||
        param.name !== ctx.resultInfo.argMinMaxField[0])
        return null;

    return makeRecommendation(ctx, name);
}

function makeRecommendation(ctx, name) {
    const results = ctx.results;
    assert(results.length > 0);
    const currentTable = ctx.current.stmt.table;
    if (currentTable && currentTable.isSlice && currentTable.limit.value !== 1)
        return null;

    const topResult = results[0];
    const id = topResult.value.id;

    if (!id || !id.equals(name))
        return null;

    return { topResult, ctx, info: null, action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next) : null };
}

function makeThingpediaRecommendation(ctx, info) {
    const results = ctx.results;
    assert(results.length > 0);
    const currentTable = ctx.current.stmt.table;
    if (currentTable && currentTable.isSlice && currentTable.limit.value !== 1)
        return null;

    const topResult = results[0];
    if (!topResult.value.id)
        return null;

    if (!isInfoPhraseCompatibleWithResult(topResult, info))
        return null;

    return { topResult, ctx, info, action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next) : null };
}


function checkRecommendation({ topResult, action: nextAction }, info) {
    assert(info instanceof SlotBag);
    if (!topResult.value.id)
        return null;

    const resultType = topResult.value.id.getType();
    const idType = info.schema.getArgType('id');
    if (!idType || !idType.equals(resultType))
        return null;

    if (!isInfoPhraseCompatibleWithResult(topResult, info))
        return null;

    return { topResult, info, action: nextAction };
}

function checkActionForRecommendation({ topResult, info, action: nextAction }, action) {
    if (!topResult.value.id)
        return null;
    const resultType = topResult.value.id.getType();

    if (nextAction !== null) {
        if (!C.isSameFunction(nextAction.schema, action.schema))
            return null;
    }

    if (!C.hasArgumentOfType(action, resultType))
        return null;

    return { topResult, info, action };
}

// make a recommendation that looks like an answer, that is, "so and so is a ..."
function makeAnswerStyleRecommendation({ topResult, ctx, action }, filter) {
    let info = new SlotBag(ctx.currentFunctionSchema);
    info = checkAndAddSlot(info, filter);
    if (info === null)
        return null;
    info = checkInfoPhrase(ctx, info);
    if (info === null)
        return null;

    return checkRecommendation({ topResult, action }, info);
}


function makeDisplayResult(ctx, info) {
    const results = ctx.results;
    assert(results.length > 0);
    const topResult = results[0];

    if (ctx.currentFunctionSchema.is_list)
        return null;
    if (!isInfoPhraseCompatibleWithResult(topResult, info))
        return null;
    info = checkInfoPhrase(ctx, info);
    if (info === null)
        return null;

    return { topResult, ctx, info, action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next) : null, hasAnythingElse: false };
}

function combineDisplayResult(proposal, newInfo) {
    const { ctx, info:oldInfo } = proposal;
    const results = ctx.results;
    assert(results.length > 0);
    const topResult = results[0];
    assert (isInfoPhraseCompatibleWithResult(topResult, newInfo));

    newInfo = SlotBag.merge(oldInfo, newInfo);
    if (newInfo === null)
        return null;

    const newProposal = {};
    Object.assign(newProposal, proposal);
    newProposal.info = newInfo;
    return newProposal;
}

function makeRecommendationReply(ctx, proposal) {
    const { topResult, action, hasLearnMore } = proposal;
    const options = {};
    if (action || hasLearnMore)
        options.end = false;
    if (action === null) {
        return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_recommend_one', null), proposal, null, options);
    } else {
        const chainParam = findChainParam(topResult, action);
        if (!chainParam)
            return null;
        return makeAgentReply(ctx, addActionParam(ctx, 'sys_recommend_one', action, chainParam, topResult.value.id, 'proposed'),
            proposal, null, options);
    }
}

function makeDisplayResultReply(ctx, proposal) {
    const { action, hasAnythingElse } = proposal;
    const options = {};
    if (action || hasAnythingElse)
        options.end = false;
    return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_display_result', null), proposal, null, options);
}

function negativeRecommendationReply(ctx, [preamble, request]) {
    const proposal = ctx.aux;
    const { topResult, info, } = proposal;
    const proposalType = topResult.value.id.getType();
    request = combinePreambleAndRequest(preamble, request, info, proposalType);
    if (request === null)
        return null;
    return proposalReply(ctx, request, refineFilterToAnswerQuestionOrChangeFilter);
}

function positiveRecommendationReply(ctx, acceptedAction, name) {
    const proposal = ctx.aux;
    const { topResult, action: actionProposal } = proposal;

    if (acceptedAction === null) {
        // if the user did not give an action earlier, and no action
        // was proposed by the agent right now, the flow is roughly
        //
        // U: hello i am looking for a restaurant
        // A: how about the ... ?
        // U: sure I like that
        //
        // this doesn't make much sense, so we don't want this flow
        if (actionProposal === null)
            return null;

        acceptedAction = actionProposal;
    }

    if (actionProposal !== null && !C.isSameFunction(actionProposal.schema, acceptedAction.schema))
        return null;
    if (name !== null && !topResult.value.id.equals(name))
        return null;

    // do not consider a phrase of the form "play X" to be "accepting the action by name"
    // if the action auto-confirms, because the user is likely playing something else
    if (acceptedAction && name) {
        const confirm = C.normalizeConfirmAnnotation(acceptedAction.schema);
        if (confirm === 'auto')
            return null;
    }

    const chainParam = findChainParam(topResult, acceptedAction);
    if (!chainParam)
        return null;
    return addActionParam(ctx, 'execute', acceptedAction, chainParam, topResult.value.id, 'accepted');
}

function recommendationCancelReply(ctx, valid) {
    // see dialogue.genie for the meaning of this boolean
    if (!valid)
        return null;

    // "thank you" closes the dialogue
    // we cannot close the dialogue if we have pending actions
    if (ctx.next)
        return null;
    return makeSimpleState(ctx, 'cancel', null);
}

function recommendationLearnMoreReply(ctx, name) {
    const proposal = ctx.aux;
    const { topResult, } = proposal;
    if (name !== null && !topResult.value.id.equals(name))
        return null;
    return makeSimpleState(ctx, 'learn_more', null);
}

function repeatCommandReply(ctx) {
    if (ctx.next)
        return null;
    if (ctx.currentFunctionSchema.is_monitorable)
        return null;

    const clone = ctx.current.clone();
    clone.results = null;
    clone.confirm = 'accepted';
    return addNewItem(ctx, 'execute', null, 'accepted', clone);
}

module.exports = {
    makeActionRecommendation,
    makeArgMinMaxRecommendation,
    makeRecommendation,
    makeThingpediaRecommendation,
    makeAnswerStyleRecommendation,
    checkRecommendation,
    checkActionForRecommendation,
    makeDisplayResult,
    combineDisplayResult,
    makeRecommendationReply,
    makeDisplayResultReply,

    positiveRecommendationReply,
    negativeRecommendationReply,
    recommendationCancelReply,
    recommendationLearnMoreReply,
    repeatCommandReply,
};

1	// -- mode: js; 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	"use strict";
21
22	const assert = require('assert');	3✔
23
24	const ThingTalk = require('thingtalk');	3✔
25	const Ast = ThingTalk.Ast;	3✔
26
27	const C = require('../ast_manip');	3✔
28
29	const { SlotBag, checkAndAddSlot } = require('../slot_bag');	3✔
30	const {
31	makeAgentReply,
32	makeSimpleState,
33	addActionParam,
34	addNewItem,
35	} = require('../state_manip');	3✔
36	const {
37	isInfoPhraseCompatibleWithResult,
38	findChainParam
39	} = require('./common');	3✔
40	const {
41	refineFilterToAnswerQuestionOrChangeFilter,
42	combinePreambleAndRequest,
43	proposalReply
44	} = require('./refinement-helpers');	3✔
45	const {
46	checkInfoPhrase
47	} = require('./results');	3✔
48
49
50	function makeActionRecommendation(ctx, action) {
51	assert(action instanceof Ast.Invocation);	×
52
53	const results = ctx.results;	×
54	assert(results.length > 0);	×
55	const currentTable = ctx.current.stmt.table;	×
56	if (currentTable && currentTable.isSlice && currentTable.limit.value !== 1)	×
57	return null;	×
58
59	const topResult = results[0];	×
60	const id = topResult.value.id;	×
61	if (!id)	×
62	return null;	×
63
64	if (action.in_params.length !== 1)	×
65	return null;	×
66
67	for (let param of action.in_params) {	×
68	if (param.value.equals(id))	×
69	return { topResult, info: null, action };	×
70	}
71
72	return null;	×
73	}
74
75	function makeArgMinMaxRecommendation(ctx, name, base, param, direction) {
76	if (!ctx.resultInfo.argMinMaxField)	8,822!
NEW 77	return null;	×
78	if (!C.isSameFunction(base.schema, ctx.currentFunctionSchema))	8,822✔
79	return null;	7,350✔
80	if (direction !== ctx.resultInfo.argMinMaxField[1] \|\|	1,472✔
81	param.name !== ctx.resultInfo.argMinMaxField[0])
82	return null;	1,300✔
83
84	return makeRecommendation(ctx, name);	172✔
85	}
86
87	function makeRecommendation(ctx, name) {
88	const results = ctx.results;	286✔
89	assert(results.length > 0);	286✔
90	const currentTable = ctx.current.stmt.table;	286✔
91	if (currentTable && currentTable.isSlice && currentTable.limit.value !== 1)	286✔
92	return null;	11✔
93
94	const topResult = results[0];	275✔
95	const id = topResult.value.id;	275✔
96
97	if (!id \|\| !id.equals(name))	275✔
98	return null;	201✔
99
100	return { topResult, ctx, info: null, action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next) : null };	74!
101	}
102
103	function makeThingpediaRecommendation(ctx, info) {
104	const results = ctx.results;	133✔
105	assert(results.length > 0);	133✔
106	const currentTable = ctx.current.stmt.table;	133✔
107	if (currentTable && currentTable.isSlice && currentTable.limit.value !== 1)	133✔
108	return null;	28✔
109
110	const topResult = results[0];	105✔
111	if (!topResult.value.id)	105!
112	return null;	×
113
114	if (!isInfoPhraseCompatibleWithResult(topResult, info))	105✔
115	return null;	18✔
116
117	return { topResult, ctx, info, action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next) : null };	87!
118	}
119
120
121	function checkRecommendation({ topResult, action: nextAction }, info) {
122	assert(info instanceof SlotBag);	179,214✔
123	if (!topResult.value.id)	179,214!
124	return null;	×
125
126	const resultType = topResult.value.id.getType();	179,214✔
127	const idType = info.schema.getArgType('id');	179,214✔
128	if (!idType \|\| !idType.equals(resultType))	179,214!
129	return null;	×
130
131	if (!isInfoPhraseCompatibleWithResult(topResult, info))	179,214✔
132	return null;	1,473✔
133
134	return { topResult, info, action: nextAction };	177,741✔
135	}
136
137	function checkActionForRecommendation({ topResult, info, action: nextAction }, action) {
138	if (!topResult.value.id)	65,232!
139	return null;	×
140	const resultType = topResult.value.id.getType();	65,232✔
141
142	if (nextAction !== null) {	65,232!
143	if (!C.isSameFunction(nextAction.schema, action.schema))	×
144	return null;	×
145	}
146
147	if (!C.hasArgumentOfType(action, resultType))	65,232!
148	return null;	×
149
150	return { topResult, info, action };	65,232✔
151	}
152
153	// make a recommendation that looks like an answer, that is, "so and so is a ..."
154	function makeAnswerStyleRecommendation({ topResult, ctx, action }, filter) {
155	let info = new SlotBag(ctx.currentFunctionSchema);	3,800✔
156	info = checkAndAddSlot(info, filter);	3,800✔
157	if (info === null)	3,800✔
158	return null;	2,855✔
159	info = checkInfoPhrase(ctx, info);	945✔
160	if (info === null)	945✔
161	return null;	792✔
162
163	return checkRecommendation({ topResult, action }, info);	153✔
164	}
165
166
167	function makeDisplayResult(ctx, info) {
168	const results = ctx.results;	3,174✔
169	assert(results.length > 0);	3,174✔
170	const topResult = results[0];	3,174✔
171
172	if (ctx.currentFunctionSchema.is_list)	3,174✔
173	return null;	204✔
174	if (!isInfoPhraseCompatibleWithResult(topResult, info))	2,970✔
175	return null;	2,822✔
176	info = checkInfoPhrase(ctx, info);	148✔
177	if (info === null)	148✔
178	return null;	62✔
179
180	return { topResult, ctx, info, action: ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next) : null, hasAnythingElse: false };	86!
181	}
182
183	function combineDisplayResult(proposal, newInfo) {
184	const { ctx, info:oldInfo } = proposal;	59✔
185	const results = ctx.results;	59✔
186	assert(results.length > 0);	59✔
187	const topResult = results[0];	59✔
188	assert (isInfoPhraseCompatibleWithResult(topResult, newInfo));	59✔
189
190	newInfo = SlotBag.merge(oldInfo, newInfo);	59✔
191	if (newInfo === null)	59✔
192	return null;	31✔
193
194	const newProposal = {};	28✔
195	Object.assign(newProposal, proposal);	28✔
196	newProposal.info = newInfo;	28✔
197	return newProposal;	28✔
198	}
199
200	function makeRecommendationReply(ctx, proposal) {
201	const { topResult, action, hasLearnMore } = proposal;	14,978✔
202	const options = {};	14,978✔
203	if (action \|\| hasLearnMore)	14,978✔
204	options.end = false;	7,632✔
205	if (action === null) {	14,978✔
206	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_recommend_one', null), proposal, null, options);	7,346✔
207	} else {
208	const chainParam = findChainParam(topResult, action);	7,632✔
209	if (!chainParam)	7,632!
210	return null;	×
211	return makeAgentReply(ctx, addActionParam(ctx, 'sys_recommend_one', action, chainParam, topResult.value.id, 'proposed'),	7,632✔
212	proposal, null, options);
213	}
214	}
215
216	function makeDisplayResultReply(ctx, proposal) {
217	const { action, hasAnythingElse } = proposal;	69✔
218	const options = {};	69✔
219	if (action \|\| hasAnythingElse)	69!
UNCOV 220	options.end = false;	×
221	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_display_result', null), proposal, null, options);	69✔
222	}
223
224	function negativeRecommendationReply(ctx, [preamble, request]) {
225	const proposal = ctx.aux;	×
226	const { topResult, info, } = proposal;	×
227	const proposalType = topResult.value.id.getType();	×
228	request = combinePreambleAndRequest(preamble, request, info, proposalType);	×
229	if (request === null)	×
230	return null;	×
231	return proposalReply(ctx, request, refineFilterToAnswerQuestionOrChangeFilter);	×
232	}
233
234	function positiveRecommendationReply(ctx, acceptedAction, name) {
235	const proposal = ctx.aux;	×
236	const { topResult, action: actionProposal } = proposal;	×
237
238	if (acceptedAction === null) {	×
239	// if the user did not give an action earlier, and no action
240	// was proposed by the agent right now, the flow is roughly
241	//
242	// U: hello i am looking for a restaurant
243	// A: how about the ... ?
244	// U: sure I like that
245	//
246	// this doesn't make much sense, so we don't want this flow
247	if (actionProposal === null)	×
248	return null;	×
249
250	acceptedAction = actionProposal;	×
251	}
252
253	if (actionProposal !== null && !C.isSameFunction(actionProposal.schema, acceptedAction.schema))	×
254	return null;	×
255	if (name !== null && !topResult.value.id.equals(name))	×
256	return null;	×
257
258	// do not consider a phrase of the form "play X" to be "accepting the action by name"
259	// if the action auto-confirms, because the user is likely playing something else
NEW 260	if (acceptedAction && name) {	×
NEW 261	const confirm = C.normalizeConfirmAnnotation(acceptedAction.schema);	×
NEW 262	if (confirm === 'auto')	×
NEW 263	return null;	×
264	}
265
266	const chainParam = findChainParam(topResult, acceptedAction);	×
267	if (!chainParam)	×
268	return null;	×
269	return addActionParam(ctx, 'execute', acceptedAction, chainParam, topResult.value.id, 'accepted');	×
270	}
271
272	function recommendationCancelReply(ctx, valid) {
273	// see dialogue.genie for the meaning of this boolean
274	if (!valid)	×
275	return null;	×
276
277	// "thank you" closes the dialogue
278	// we cannot close the dialogue if we have pending actions
279	if (ctx.next)	×
280	return null;	×
281	return makeSimpleState(ctx, 'cancel', null);	×
282	}
283
284	function recommendationLearnMoreReply(ctx, name) {
285	const proposal = ctx.aux;	×
286	const { topResult, } = proposal;	×
287	if (name !== null && !topResult.value.id.equals(name))	×
288	return null;	×
289	return makeSimpleState(ctx, 'learn_more', null);	×
290	}
291
292	function repeatCommandReply(ctx) {
293	if (ctx.next)	×
294	return null;	×
295	if (ctx.currentFunctionSchema.is_monitorable)	×
296	return null;	×
297
298	const clone = ctx.current.clone();	×
299	clone.results = null;	×
300	clone.confirm = 'accepted';	×
301	return addNewItem(ctx, 'execute', null, 'accepted', clone);	×
302	}
303
304	module.exports = {	3✔
305	makeActionRecommendation,
306	makeArgMinMaxRecommendation,
307	makeRecommendation,
308	makeThingpediaRecommendation,
309	makeAnswerStyleRecommendation,
310	checkRecommendation,
311	checkActionForRecommendation,
312	makeDisplayResult,
313	combineDisplayResult,
314	makeRecommendationReply,
315	makeDisplayResultReply,
316
317	positiveRecommendationReply,
318	negativeRecommendationReply,
319	recommendationCancelReply,
320	recommendationLearnMoreReply,
321	repeatCommandReply,
322	};

stanford-oval / genie-toolkit / 1332

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